diff options
Diffstat (limited to 'sw/source/core/inc')
81 files changed, 1312 insertions, 1312 deletions
diff --git a/sw/source/core/inc/DocumentContentOperationsManager.hxx b/sw/source/core/inc/DocumentContentOperationsManager.hxx index d9122780fad9..24974d119c09 100644 --- a/sw/source/core/inc/DocumentContentOperationsManager.hxx +++ b/sw/source/core/inc/DocumentContentOperationsManager.hxx @@ -25,8 +25,8 @@ #include <ndarr.hxx> //Only for lcl_RstTxtAttr class SwDoc; -class SwNoTxtNode; -class SwFmtColl; +class SwNoTextNode; +class SwFormatColl; class SwHistory; namespace sw @@ -65,25 +65,25 @@ public: void TransliterateText(const SwPaM& rPaM, utl::TransliterationWrapper&) SAL_OVERRIDE; - SwFlyFrmFmt* Insert(const SwPaM &rRg, const OUString& rGrfName, const OUString& rFltName, const Graphic* pGraphic, - const SfxItemSet* pFlyAttrSet, const SfxItemSet* pGrfAttrSet, SwFrmFmt*) SAL_OVERRIDE; + SwFlyFrameFormat* Insert(const SwPaM &rRg, const OUString& rGrfName, const OUString& rFltName, const Graphic* pGraphic, + const SfxItemSet* pFlyAttrSet, const SfxItemSet* pGrfAttrSet, SwFrameFormat*) SAL_OVERRIDE; - SwFlyFrmFmt* Insert(const SwPaM& rRg, const GraphicObject& rGrfObj, const SfxItemSet* pFlyAttrSet, - const SfxItemSet* pGrfAttrSet, SwFrmFmt*) SAL_OVERRIDE; + SwFlyFrameFormat* Insert(const SwPaM& rRg, const GraphicObject& rGrfObj, const SfxItemSet* pFlyAttrSet, + const SfxItemSet* pGrfAttrSet, SwFrameFormat*) SAL_OVERRIDE; void ReRead(SwPaM&, const OUString& rGrfName, const OUString& rFltName, const Graphic* pGraphic, const GraphicObject* pGrfObj) SAL_OVERRIDE; - SwDrawFrmFmt* InsertDrawObj( const SwPaM &rRg, SdrObject& rDrawObj, const SfxItemSet& rFlyAttrSet ) SAL_OVERRIDE; + SwDrawFrameFormat* InsertDrawObj( const SwPaM &rRg, SdrObject& rDrawObj, const SfxItemSet& rFlyAttrSet ) SAL_OVERRIDE; - SwFlyFrmFmt* Insert(const SwPaM &rRg, const svt::EmbeddedObjectRef& xObj, const SfxItemSet* pFlyAttrSet, - const SfxItemSet* pGrfAttrSet, SwFrmFmt*) SAL_OVERRIDE; + SwFlyFrameFormat* Insert(const SwPaM &rRg, const svt::EmbeddedObjectRef& xObj, const SfxItemSet* pFlyAttrSet, + const SfxItemSet* pGrfAttrSet, SwFrameFormat*) SAL_OVERRIDE; - SwFlyFrmFmt* InsertOLE(const SwPaM &rRg, const OUString& rObjName, sal_Int64 nAspect, const SfxItemSet* pFlyAttrSet, - const SfxItemSet* pGrfAttrSet, SwFrmFmt*) SAL_OVERRIDE; + SwFlyFrameFormat* InsertOLE(const SwPaM &rRg, const OUString& rObjName, sal_Int64 nAspect, const SfxItemSet* pFlyAttrSet, + const SfxItemSet* pGrfAttrSet, SwFrameFormat*) SAL_OVERRIDE; bool SplitNode(const SwPosition &rPos, bool bChkTableStart) SAL_OVERRIDE; - bool AppendTxtNode(SwPosition& rPos) SAL_OVERRIDE; + bool AppendTextNode(SwPosition& rPos) SAL_OVERRIDE; bool ReplaceRange(SwPaM& rPam, const OUString& rNewStr, const bool bRegExReplace) SAL_OVERRIDE; @@ -114,11 +114,11 @@ public: const bool bCopyFlyAtFly = false, const bool bMergedFirstNode = false ) const; - /// Parameters for _Rst and lcl_SetTxtFmtColl + /// Parameters for _Rst and lcl_SetTextFormatColl //originallyfrom docfmt.cxx - struct ParaRstFmt + struct ParaRstFormat { - SwFmtColl* pFmtColl; + SwFormatColl* pFormatColl; SwHistory* pHistory; const SwPosition *pSttNd, *pEndNd; const SfxItemSet* pDelSet; @@ -130,9 +130,9 @@ public: /// From the attributes included in the range, delete only the ones which have exactly same range. Don't delete the ones which are simply included in the range. bool bExactRange; - ParaRstFmt(const SwPosition* pStt, const SwPosition* pEnd, + ParaRstFormat(const SwPosition* pStt, const SwPosition* pEnd, SwHistory* pHst, sal_uInt16 nWhch = 0, const SfxItemSet* pSet = 0) - : pFmtColl(0) + : pFormatColl(0) , pHistory(pHst) , pSttNd(pStt) , pEndNd(pEnd) @@ -146,7 +146,7 @@ public: { } }; - static bool lcl_RstTxtAttr( const SwNodePtr& rpNd, void* pArgs ); //originally from docfmt.cxx + static bool lcl_RstTextAttr( const SwNodePtr& rpNd, void* pArgs ); //originally from docfmt.cxx virtual ~DocumentContentOperationsManager(); @@ -159,10 +159,10 @@ private: bool DeleteRangeImpl(SwPaM&, const bool unused = false); bool DeleteRangeImplImpl(SwPaM &); bool ReplaceRangeImpl(SwPaM&, OUString const&, const bool); - SwFlyFrmFmt* _InsNoTxtNode( const SwPosition&rPos, SwNoTxtNode*, + SwFlyFrameFormat* _InsNoTextNode( const SwPosition&rPos, SwNoTextNode*, const SfxItemSet* pFlyAttrSet, const SfxItemSet* pGrfAttrSet, - SwFrmFmt* = 0 ); + SwFrameFormat* = 0 ); /* Copy a range within the same or to another document. Position may not lie within range! */ bool CopyImpl( SwPaM&, SwPosition&, const bool MakeNewFrms /*= true */, diff --git a/sw/source/core/inc/DocumentFieldsManager.hxx b/sw/source/core/inc/DocumentFieldsManager.hxx index 010481d7e16a..2e827fba9276 100644 --- a/sw/source/core/inc/DocumentFieldsManager.hxx +++ b/sw/source/core/inc/DocumentFieldsManager.hxx @@ -36,32 +36,32 @@ public: DocumentFieldsManager( SwDoc& i_rSwdoc ); - virtual const SwFldTypes *GetFldTypes() const SAL_OVERRIDE; - virtual SwFieldType *InsertFldType(const SwFieldType &) SAL_OVERRIDE; - virtual SwFieldType *GetSysFldType( const sal_uInt16 eWhich ) const SAL_OVERRIDE; - virtual SwFieldType* GetFldType(sal_uInt16 nResId, const OUString& rName, bool bDbFieldMatching) const SAL_OVERRIDE; - virtual void RemoveFldType(size_t nFld) SAL_OVERRIDE; - virtual void UpdateFlds( SfxPoolItem* pNewHt, bool bCloseDB) SAL_OVERRIDE; - virtual void InsDeletedFldType(SwFieldType &) SAL_OVERRIDE; + virtual const SwFieldTypes *GetFieldTypes() const SAL_OVERRIDE; + virtual SwFieldType *InsertFieldType(const SwFieldType &) SAL_OVERRIDE; + virtual SwFieldType *GetSysFieldType( const sal_uInt16 eWhich ) const SAL_OVERRIDE; + virtual SwFieldType* GetFieldType(sal_uInt16 nResId, const OUString& rName, bool bDbFieldMatching) const SAL_OVERRIDE; + virtual void RemoveFieldType(size_t nField) SAL_OVERRIDE; + virtual void UpdateFields( SfxPoolItem* pNewHt, bool bCloseDB) SAL_OVERRIDE; + virtual void InsDeletedFieldType(SwFieldType &) SAL_OVERRIDE; virtual bool PutValueToField(const SwPosition & rPos, const com::sun::star::uno::Any& rVal, sal_uInt16 nWhich) SAL_OVERRIDE; - virtual bool UpdateFld(SwTxtFld * rDstFmtFld, SwField & rSrcFld, SwMsgPoolItem * pMsgHnt, bool bUpdateTblFlds) SAL_OVERRIDE; - virtual void UpdateRefFlds(SfxPoolItem* pHt) SAL_OVERRIDE; - virtual void UpdateTblFlds(SfxPoolItem* pHt) SAL_OVERRIDE; - virtual void UpdateExpFlds(SwTxtFld* pFld, bool bUpdateRefFlds) SAL_OVERRIDE; - virtual void UpdateUsrFlds() SAL_OVERRIDE; - virtual void UpdatePageFlds(SfxPoolItem*) SAL_OVERRIDE; - virtual void LockExpFlds() SAL_OVERRIDE; - virtual void UnlockExpFlds() SAL_OVERRIDE; - virtual bool IsExpFldsLocked() const SAL_OVERRIDE; - virtual SwDocUpdtFld& GetUpdtFlds() const SAL_OVERRIDE; + virtual bool UpdateField(SwTextField * rDstFormatField, SwField & rSrcField, SwMsgPoolItem * pMsgHint, bool bUpdateTableFields) SAL_OVERRIDE; + virtual void UpdateRefFields(SfxPoolItem* pHt) SAL_OVERRIDE; + virtual void UpdateTableFields(SfxPoolItem* pHt) SAL_OVERRIDE; + virtual void UpdateExpFields(SwTextField* pField, bool bUpdateRefFields) SAL_OVERRIDE; + virtual void UpdateUsrFields() SAL_OVERRIDE; + virtual void UpdatePageFields(SfxPoolItem*) SAL_OVERRIDE; + virtual void LockExpFields() SAL_OVERRIDE; + virtual void UnlockExpFields() SAL_OVERRIDE; + virtual bool IsExpFieldsLocked() const SAL_OVERRIDE; + virtual SwDocUpdateField& GetUpdateFields() const SAL_OVERRIDE; virtual bool SetFieldsDirty(bool b, const SwNode* pChk, sal_uLong nLen) SAL_OVERRIDE; virtual void SetFixFields(bool bOnlyTimeDate, const DateTime* pNewDateTime) SAL_OVERRIDE; - virtual void FldsToCalc(SwCalc& rCalc, sal_uLong nLastNd, sal_uInt16 nLastCnt) SAL_OVERRIDE; - virtual void FldsToCalc(SwCalc& rCalc, const _SetGetExpFld& rToThisFld) SAL_OVERRIDE; - virtual void FldsToExpand(SwHash**& ppTbl, sal_uInt16& rTblSize, const _SetGetExpFld& rToThisFld) SAL_OVERRIDE; - virtual bool IsNewFldLst() const SAL_OVERRIDE; - virtual void SetNewFldLst( bool bFlag) SAL_OVERRIDE; - virtual void InsDelFldInFldLst(bool bIns, const SwTxtFld& rFld) SAL_OVERRIDE; + virtual void FieldsToCalc(SwCalc& rCalc, sal_uLong nLastNd, sal_uInt16 nLastCnt) SAL_OVERRIDE; + virtual void FieldsToCalc(SwCalc& rCalc, const _SetGetExpField& rToThisField) SAL_OVERRIDE; + virtual void FieldsToExpand(SwHash**& ppTable, sal_uInt16& rTableSize, const _SetGetExpField& rToThisField) SAL_OVERRIDE; + virtual bool IsNewFieldLst() const SAL_OVERRIDE; + virtual void SetNewFieldLst( bool bFlag) SAL_OVERRIDE; + virtual void InsDelFieldInFieldLst(bool bIns, const SwTextField& rField) SAL_OVERRIDE; //Non Interface methods @@ -75,7 +75,7 @@ public: @param rPos position to search at @return pointer to field at the given position or NULL in case no field is found */ - static SwTxtFld* GetTxtFldAtPos(const SwPosition& rPos); + static SwTextField* GetTextFieldAtPos(const SwPosition& rPos); bool containsUpdatableFields(); @@ -86,7 +86,7 @@ public: void ClearFieldTypes(); - void UpdateDBNumFlds( SwDBNameInfField& rDBFld, SwCalc& rCalc ); + void UpdateDBNumFields( SwDBNameInfField& rDBField, SwCalc& rCalc ); virtual ~DocumentFieldsManager(); @@ -94,10 +94,10 @@ private: SwDoc& m_rDoc; - bool mbNewFldLst; //< TRUE: Rebuild field-list. - SwDocUpdtFld *mpUpdtFlds; //< Struct for updating fields - SwFldTypes *mpFldTypes; - sal_Int8 mnLockExpFld; //< If != 0 UpdateExpFlds() has no effect! + bool mbNewFieldLst; //< TRUE: Rebuild field-list. + SwDocUpdateField *mpUpdateFields; //< Struct for updating fields + SwFieldTypes *mpFieldTypes; + sal_Int8 mnLockExpField; //< If != 0 UpdateExpFields() has no effect! }; } diff --git a/sw/source/core/inc/DocumentLayoutManager.hxx b/sw/source/core/inc/DocumentLayoutManager.hxx index ddc8ef30e4bd..abcd8eccec76 100644 --- a/sw/source/core/inc/DocumentLayoutManager.hxx +++ b/sw/source/core/inc/DocumentLayoutManager.hxx @@ -49,9 +49,9 @@ public: virtual SwLayouter* GetLayouter() SAL_OVERRIDE; virtual void SetLayouter( SwLayouter* pNew ) SAL_OVERRIDE; - virtual SwFrmFmt* MakeLayoutFmt( RndStdIds eRequest, const SfxItemSet* pSet ) SAL_OVERRIDE; - virtual void DelLayoutFmt( SwFrmFmt *pFmt ) SAL_OVERRIDE; - virtual SwFrmFmt* CopyLayoutFmt( const SwFrmFmt& rSrc, const SwFmtAnchor& rNewAnchor, bool bSetTxtFlyAtt, bool bMakeFrms ) SAL_OVERRIDE; + virtual SwFrameFormat* MakeLayoutFormat( RndStdIds eRequest, const SfxItemSet* pSet ) SAL_OVERRIDE; + virtual void DelLayoutFormat( SwFrameFormat *pFormat ) SAL_OVERRIDE; + virtual SwFrameFormat* CopyLayoutFormat( const SwFrameFormat& rSrc, const SwFormatAnchor& rNewAnchor, bool bSetTextFlyAtt, bool bMakeFrms ) SAL_OVERRIDE; //Non Interface methods void ClearSwLayouterEntries(); diff --git a/sw/source/core/inc/DocumentOutlineNodesManager.hxx b/sw/source/core/inc/DocumentOutlineNodesManager.hxx index c16a15732c0b..ccd88fac2946 100644 --- a/sw/source/core/inc/DocumentOutlineNodesManager.hxx +++ b/sw/source/core/inc/DocumentOutlineNodesManager.hxx @@ -35,7 +35,7 @@ public: DocumentOutlineNodesManager( SwDoc& i_rSwdoc ); - //typedef ::std::vector< const SwTxtNode* > tSortedOutlineNodeList; + //typedef ::std::vector< const SwTextNode* > tSortedOutlineNodeList; sal_Int32 getOutlineNodesCount() const SAL_OVERRIDE; @@ -43,8 +43,8 @@ public: OUString getOutlineText( const sal_Int32 nIdx, const bool bWithNumber = true, const bool bWithSpacesForLevel = false, - const bool bWithFtn = true ) const SAL_OVERRIDE; - SwTxtNode* getOutlineNode( const sal_Int32 nIdx ) const SAL_OVERRIDE; + const bool bWithFootnote = true ) const SAL_OVERRIDE; + SwTextNode* getOutlineNode( const sal_Int32 nIdx ) const SAL_OVERRIDE; void getOutlineNodes( IDocumentOutlineNodes::tSortedOutlineNodeList& orOutlineNodeList ) const SAL_OVERRIDE; virtual ~DocumentOutlineNodesManager(); diff --git a/sw/source/core/inc/DocumentRedlineManager.hxx b/sw/source/core/inc/DocumentRedlineManager.hxx index 9c405ea2475e..1fe968af74b6 100644 --- a/sw/source/core/inc/DocumentRedlineManager.hxx +++ b/sw/source/core/inc/DocumentRedlineManager.hxx @@ -44,11 +44,11 @@ public: virtual bool IsIgnoreRedline() const SAL_OVERRIDE; - virtual const SwRedlineTbl& GetRedlineTbl() const SAL_OVERRIDE; - virtual SwRedlineTbl& GetRedlineTbl() SAL_OVERRIDE; - virtual const SwExtraRedlineTbl& GetExtraRedlineTbl() const SAL_OVERRIDE; - virtual SwExtraRedlineTbl& GetExtraRedlineTbl() SAL_OVERRIDE; - virtual bool HasExtraRedlineTbl() const SAL_OVERRIDE; + virtual const SwRedlineTable& GetRedlineTable() const SAL_OVERRIDE; + virtual SwRedlineTable& GetRedlineTable() SAL_OVERRIDE; + virtual const SwExtraRedlineTable& GetExtraRedlineTable() const SAL_OVERRIDE; + virtual SwExtraRedlineTable& GetExtraRedlineTable() SAL_OVERRIDE; + virtual bool HasExtraRedlineTable() const SAL_OVERRIDE; virtual bool IsInRedlines(const SwNode& rNode) const SAL_OVERRIDE; @@ -116,7 +116,7 @@ public: /** Set comment-text for Redline. It then comes in via AppendRedLine. Used by AutoFormat. 0-pointer resets mode. Sequence number is for conjoining of Redlines by the UI. */ - void SetAutoFmtRedlineComment( const OUString* pTxt, sal_uInt16 nSeqNo = 0 ); + void SetAutoFormatRedlineComment( const OUString* pText, sal_uInt16 nSeqNo = 0 ); void checkRedlining(RedlineMode_t& _rReadlineMode); @@ -127,13 +127,13 @@ private: SwDoc& m_rDoc; RedlineMode_t meRedlineMode; //< Current Redline Mode. - SwRedlineTbl *mpRedlineTbl; //< List of all Ranged Redlines. - SwExtraRedlineTbl *mpExtraRedlineTbl; //< List of all Extra Redlines. - OUString *mpAutoFmtRedlnComment; //< Comment for Redlines inserted via AutoFormat. + SwRedlineTable *mpRedlineTable; //< List of all Ranged Redlines. + SwExtraRedlineTable *mpExtraRedlineTable; //< List of all Extra Redlines. + OUString *mpAutoFormatRedlnComment; //< Comment for Redlines inserted via AutoFormat. bool mbIsRedlineMove; //< true: Redlines are moved into to / out of the section. bool mbReadlineChecked; //< true: if the query was already shown - sal_uInt16 mnAutoFmtRedlnCommentNo; /**< SeqNo for conjoining of AutoFmt-Redlines. - by the UI. Managed by SwAutoFmt! */ + sal_uInt16 mnAutoFormatRedlnCommentNo; /**< SeqNo for conjoining of AutoFormat-Redlines. + by the UI. Managed by SwAutoFormat! */ ::com::sun::star::uno::Sequence <sal_Int8 > maRedlinePasswd; }; diff --git a/sw/source/core/inc/DocumentSettingManager.hxx b/sw/source/core/inc/DocumentSettingManager.hxx index 853ad75167bb..9ff978c40b04 100644 --- a/sw/source/core/inc/DocumentSettingManager.hxx +++ b/sw/source/core/inc/DocumentSettingManager.hxx @@ -31,7 +31,7 @@ class DocumentSettingManager : sal_uInt16 mnLinkUpdMode; //< UpdateMode for links. - SwFldUpdateFlags meFldUpdMode;//< Automatically Update Mode for fields/charts. + SwFieldUpdateFlags meFieldUpdMode;//< Automatically Update Mode for fields/charts. SwCharCompressType meChrCmprType;//< for ASIAN: compress punctuation/kana sal_uInt32 mn32DummyCompatibilityOptions1; @@ -167,8 +167,8 @@ public: virtual const rtl::Reference<SvxForbiddenCharactersTable>& getForbiddenCharacterTable() const SAL_OVERRIDE; virtual sal_uInt16 getLinkUpdateMode( /*[in]*/bool bGlobalSettings ) const SAL_OVERRIDE; virtual void setLinkUpdateMode( /*[in]*/ sal_uInt16 nMode ) SAL_OVERRIDE; - virtual SwFldUpdateFlags getFieldUpdateFlags( /*[in]*/bool bGlobalSettings ) const SAL_OVERRIDE; - virtual void setFieldUpdateFlags( /*[in]*/ SwFldUpdateFlags eMode ) SAL_OVERRIDE; + virtual SwFieldUpdateFlags getFieldUpdateFlags( /*[in]*/bool bGlobalSettings ) const SAL_OVERRIDE; + virtual void setFieldUpdateFlags( /*[in]*/ SwFieldUpdateFlags eMode ) SAL_OVERRIDE; virtual SwCharCompressType getCharacterCompressionType() const SAL_OVERRIDE; virtual void setCharacterCompressionType( /*[in]*/SwCharCompressType nType ) SAL_OVERRIDE; diff --git a/sw/source/core/inc/DocumentStateManager.hxx b/sw/source/core/inc/DocumentStateManager.hxx index 70f3a7332639..1d67a36d2949 100644 --- a/sw/source/core/inc/DocumentStateManager.hxx +++ b/sw/source/core/inc/DocumentStateManager.hxx @@ -40,12 +40,12 @@ public: bool IsModified() const SAL_OVERRIDE; bool IsInCallModified() const SAL_OVERRIDE; bool IsLoaded() const SAL_OVERRIDE; - bool IsUpdateExpFld() const SAL_OVERRIDE; + bool IsUpdateExpField() const SAL_OVERRIDE; bool IsNewDoc() const SAL_OVERRIDE; bool IsPageNums() const SAL_OVERRIDE; void SetPageNums(bool b) SAL_OVERRIDE; void SetNewDoc(bool b) SAL_OVERRIDE; - void SetUpdateExpFldStat(bool b) SAL_OVERRIDE; + void SetUpdateExpFieldStat(bool b) SAL_OVERRIDE; void SetLoaded(bool b) SAL_OVERRIDE; private: @@ -53,7 +53,7 @@ private: bool mbModified ; //< TRUE: document has changed. bool mbLoaded ; //< TRUE: Doc loaded. - bool mbUpdateExpFld ; //< TRUE: Update expression fields. + bool mbUpdateExpField ; //< TRUE: Update expression fields. bool mbNewDoc ; //< TRUE: new Doc. bool mbPageNums ; //< TRUE: There are virtual page numbers. bool mbInCallModified; //< TRUE: in Set/Reset-Modified link. diff --git a/sw/source/core/inc/DocumentStylePoolManager.hxx b/sw/source/core/inc/DocumentStylePoolManager.hxx index a18506b24f4d..f32c5955c3b1 100644 --- a/sw/source/core/inc/DocumentStylePoolManager.hxx +++ b/sw/source/core/inc/DocumentStylePoolManager.hxx @@ -35,14 +35,14 @@ public: DocumentStylePoolManager( SwDoc& i_rSwdoc ); - virtual SwTxtFmtColl* GetTxtCollFromPool( sal_uInt16 nId, bool bRegardLanguage = true ) SAL_OVERRIDE; - virtual SwFmt* GetFmtFromPool( sal_uInt16 nId ) SAL_OVERRIDE; - virtual SwFrmFmt* GetFrmFmtFromPool( sal_uInt16 nId ) SAL_OVERRIDE; - virtual SwCharFmt* GetCharFmtFromPool( sal_uInt16 nId ) SAL_OVERRIDE; + virtual SwTextFormatColl* GetTextCollFromPool( sal_uInt16 nId, bool bRegardLanguage = true ) SAL_OVERRIDE; + virtual SwFormat* GetFormatFromPool( sal_uInt16 nId ) SAL_OVERRIDE; + virtual SwFrameFormat* GetFrameFormatFromPool( sal_uInt16 nId ) SAL_OVERRIDE; + virtual SwCharFormat* GetCharFormatFromPool( sal_uInt16 nId ) SAL_OVERRIDE; virtual SwPageDesc* GetPageDescFromPool( sal_uInt16 nId, bool bRegardLanguage = true ) SAL_OVERRIDE; virtual SwNumRule* GetNumRuleFromPool( sal_uInt16 nId ) SAL_OVERRIDE; - virtual bool IsPoolTxtCollUsed( sal_uInt16 nId ) const SAL_OVERRIDE; - virtual bool IsPoolFmtUsed( sal_uInt16 nId ) const SAL_OVERRIDE; + virtual bool IsPoolTextCollUsed( sal_uInt16 nId ) const SAL_OVERRIDE; + virtual bool IsPoolFormatUsed( sal_uInt16 nId ) const SAL_OVERRIDE; virtual bool IsPoolPageDescUsed( sal_uInt16 nId ) const SAL_OVERRIDE; virtual ~DocumentStylePoolManager(); diff --git a/sw/source/core/inc/MarkManager.hxx b/sw/source/core/inc/MarkManager.hxx index dbc7e39f7541..50186fddaa53 100644 --- a/sw/source/core/inc/MarkManager.hxx +++ b/sw/source/core/inc/MarkManager.hxx @@ -44,7 +44,7 @@ namespace sw { const OUString& rName, const OUString& rType) SAL_OVERRIDE; - virtual ::sw::mark::IMark* getMarkForTxtNode(const SwTxtNode& rTxtNode, IDocumentMarkAccess::MarkType eMark) SAL_OVERRIDE; + virtual ::sw::mark::IMark* getMarkForTextNode(const SwTextNode& rTextNode, IDocumentMarkAccess::MarkType eMark) SAL_OVERRIDE; virtual sw::mark::IMark* makeAnnotationMark( const SwPaM& rPaM, diff --git a/sw/source/core/inc/SwPortionHandler.hxx b/sw/source/core/inc/SwPortionHandler.hxx index 7795a6c8131f..20cdc585b25e 100644 --- a/sw/source/core/inc/SwPortionHandler.hxx +++ b/sw/source/core/inc/SwPortionHandler.hxx @@ -34,10 +34,10 @@ class SwFont; * once at the end of every on-screen line. * * All parameters relate to the 'model string', which is the text string - * held by the corresponding SwTxtNode. + * held by the corresponding SwTextNode. * * The SwPortionHandler can be used with the - * SwTxtFrm::VisitPortions(...) method. + * SwTextFrm::VisitPortions(...) method. */ class SwPortionHandler { @@ -79,7 +79,7 @@ public: */ virtual void LineBreak(sal_Int32 nWidth) = 0; - /** skip characters. The SwTxtFrame may only display partially + /** skip characters. The SwTextFrame may only display partially * display a certain paragraph (e.g. when the paragraph is split * across multiple pages). In this case, the Skip() method must be * called to inform the portion handler to ignore a certain run of diff --git a/sw/source/core/inc/SwUndoFmt.hxx b/sw/source/core/inc/SwUndoFmt.hxx index cb20d7fa3003..48881f766d1c 100644 --- a/sw/source/core/inc/SwUndoFmt.hxx +++ b/sw/source/core/inc/SwUndoFmt.hxx @@ -25,188 +25,188 @@ #include <numrule.hxx> class SwDoc; -class SwTxtFmtColl; -class SwConditionTxtFmtColl; +class SwTextFormatColl; +class SwConditionTextFormatColl; class SwRewriter; class SfxItemSet; -class SwUndoFmtCreate : public SwUndo +class SwUndoFormatCreate : public SwUndo { protected: - SwFmt * pNew; + SwFormat * pNew; OUString sDerivedFrom; SwDoc * pDoc; mutable OUString sNewName; SfxItemSet * pNewSet; - sal_uInt16 nId; // FmtId related + sal_uInt16 nId; // FormatId related bool bAuto; public: - SwUndoFmtCreate(SwUndoId nUndoId, SwFmt * pNew, SwFmt * pDerivedFrom, + SwUndoFormatCreate(SwUndoId nUndoId, SwFormat * pNew, SwFormat * pDerivedFrom, SwDoc * pDoc); - virtual ~SwUndoFmtCreate(); + virtual ~SwUndoFormatCreate(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual SwRewriter GetRewriter() const SAL_OVERRIDE; - virtual SwFmt * Create(SwFmt * pDerivedFrom) = 0; + virtual SwFormat * Create(SwFormat * pDerivedFrom) = 0; virtual void Delete() = 0; - virtual SwFmt * Find(const OUString & rName) const = 0; + virtual SwFormat * Find(const OUString & rName) const = 0; }; -class SwUndoFmtDelete : public SwUndo +class SwUndoFormatDelete : public SwUndo { protected: OUString sDerivedFrom; SwDoc * pDoc; OUString sOldName; SfxItemSet aOldSet; - sal_uInt16 nId; // FmtId related + sal_uInt16 nId; // FormatId related bool bAuto; public: - SwUndoFmtDelete(SwUndoId nUndoId, SwFmt * pOld, SwDoc * pDoc); - virtual ~SwUndoFmtDelete(); + SwUndoFormatDelete(SwUndoId nUndoId, SwFormat * pOld, SwDoc * pDoc); + virtual ~SwUndoFormatDelete(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual SwRewriter GetRewriter() const SAL_OVERRIDE; - virtual SwFmt * Create(SwFmt * pDerivedFrom) = 0; - virtual void Delete(SwFmt * pFmt) = 0; - virtual SwFmt * Find(const OUString & rName) const = 0; + virtual SwFormat * Create(SwFormat * pDerivedFrom) = 0; + virtual void Delete(SwFormat * pFormat) = 0; + virtual SwFormat * Find(const OUString & rName) const = 0; }; -class SwUndoRenameFmt : public SwUndo +class SwUndoRenameFormat : public SwUndo { protected: OUString sOldName, sNewName; SwDoc * pDoc; public: - SwUndoRenameFmt(SwUndoId nUndoId, const OUString & sOldName, + SwUndoRenameFormat(SwUndoId nUndoId, const OUString & sOldName, const OUString & sNewName, SwDoc * pDoc); - virtual ~SwUndoRenameFmt(); + virtual ~SwUndoRenameFormat(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; SwRewriter GetRewriter() const SAL_OVERRIDE; - virtual SwFmt * Find(const OUString & rName) const = 0; + virtual SwFormat * Find(const OUString & rName) const = 0; }; -class SwUndoTxtFmtCollCreate : public SwUndoFmtCreate +class SwUndoTextFormatCollCreate : public SwUndoFormatCreate { public: - SwUndoTxtFmtCollCreate(SwTxtFmtColl * pNew, SwTxtFmtColl * pDerivedFrom, + SwUndoTextFormatCollCreate(SwTextFormatColl * pNew, SwTextFormatColl * pDerivedFrom, SwDoc * pDoc); - virtual SwFmt * Create(SwFmt * pDerivedFrom) SAL_OVERRIDE; + virtual SwFormat * Create(SwFormat * pDerivedFrom) SAL_OVERRIDE; virtual void Delete() SAL_OVERRIDE; - virtual SwFmt * Find(const OUString & rName) const SAL_OVERRIDE; + virtual SwFormat * Find(const OUString & rName) const SAL_OVERRIDE; }; -class SwUndoTxtFmtCollDelete : public SwUndoFmtDelete +class SwUndoTextFormatCollDelete : public SwUndoFormatDelete { public: - SwUndoTxtFmtCollDelete(SwTxtFmtColl * pOld, SwDoc * pDoc); + SwUndoTextFormatCollDelete(SwTextFormatColl * pOld, SwDoc * pDoc); - virtual SwFmt * Create(SwFmt * pDerivedFrom) SAL_OVERRIDE; - virtual void Delete(SwFmt * pFmt) SAL_OVERRIDE; - virtual SwFmt * Find(const OUString & rName) const SAL_OVERRIDE; + virtual SwFormat * Create(SwFormat * pDerivedFrom) SAL_OVERRIDE; + virtual void Delete(SwFormat * pFormat) SAL_OVERRIDE; + virtual SwFormat * Find(const OUString & rName) const SAL_OVERRIDE; }; -class SwUndoCondTxtFmtCollCreate : public SwUndoTxtFmtCollCreate +class SwUndoCondTextFormatCollCreate : public SwUndoTextFormatCollCreate { public: - SwUndoCondTxtFmtCollCreate(SwConditionTxtFmtColl * pNew, SwTxtFmtColl * pDerivedFrom, SwDoc * pDoc); - virtual SwFmt * Create(SwFmt * pDerivedFrom) SAL_OVERRIDE; + SwUndoCondTextFormatCollCreate(SwConditionTextFormatColl * pNew, SwTextFormatColl * pDerivedFrom, SwDoc * pDoc); + virtual SwFormat * Create(SwFormat * pDerivedFrom) SAL_OVERRIDE; }; -class SwUndoCondTxtFmtCollDelete : public SwUndoTxtFmtCollDelete +class SwUndoCondTextFormatCollDelete : public SwUndoTextFormatCollDelete { public: - SwUndoCondTxtFmtCollDelete(SwTxtFmtColl * pOld, SwDoc * pDoc); - virtual SwFmt * Create(SwFmt * pDerivedFrom) SAL_OVERRIDE; + SwUndoCondTextFormatCollDelete(SwTextFormatColl * pOld, SwDoc * pDoc); + virtual SwFormat * Create(SwFormat * pDerivedFrom) SAL_OVERRIDE; }; -class SwUndoRenameFmtColl : public SwUndoRenameFmt +class SwUndoRenameFormatColl : public SwUndoRenameFormat { public: - SwUndoRenameFmtColl(const OUString & sOldName, + SwUndoRenameFormatColl(const OUString & sOldName, const OUString & sNewName, SwDoc * pDoc); - virtual SwFmt * Find(const OUString & rName) const SAL_OVERRIDE; + virtual SwFormat * Find(const OUString & rName) const SAL_OVERRIDE; }; -class SwUndoCharFmtCreate : public SwUndoFmtCreate +class SwUndoCharFormatCreate : public SwUndoFormatCreate { public: - SwUndoCharFmtCreate(SwCharFmt * pNew, SwCharFmt * pDerivedFrom, + SwUndoCharFormatCreate(SwCharFormat * pNew, SwCharFormat * pDerivedFrom, SwDoc * pDoc); - virtual SwFmt * Create(SwFmt * pDerivedFrom) SAL_OVERRIDE; + virtual SwFormat * Create(SwFormat * pDerivedFrom) SAL_OVERRIDE; virtual void Delete() SAL_OVERRIDE; - virtual SwFmt * Find(const OUString & rName) const SAL_OVERRIDE; + virtual SwFormat * Find(const OUString & rName) const SAL_OVERRIDE; }; -class SwUndoCharFmtDelete : public SwUndoFmtDelete +class SwUndoCharFormatDelete : public SwUndoFormatDelete { public: - SwUndoCharFmtDelete(SwCharFmt * pOld, SwDoc * pDoc); + SwUndoCharFormatDelete(SwCharFormat * pOld, SwDoc * pDoc); - virtual SwFmt * Create(SwFmt * pDerivedFrom) SAL_OVERRIDE; - virtual void Delete(SwFmt * pFmt) SAL_OVERRIDE; - virtual SwFmt * Find(const OUString & rName) const SAL_OVERRIDE; + virtual SwFormat * Create(SwFormat * pDerivedFrom) SAL_OVERRIDE; + virtual void Delete(SwFormat * pFormat) SAL_OVERRIDE; + virtual SwFormat * Find(const OUString & rName) const SAL_OVERRIDE; }; -class SwUndoRenameCharFmt : public SwUndoRenameFmt +class SwUndoRenameCharFormat : public SwUndoRenameFormat { public: - SwUndoRenameCharFmt(const OUString & sOldName, + SwUndoRenameCharFormat(const OUString & sOldName, const OUString & sNewName, SwDoc * pDoc); - virtual SwFmt * Find(const OUString & rName) const SAL_OVERRIDE; + virtual SwFormat * Find(const OUString & rName) const SAL_OVERRIDE; }; -class SwUndoFrmFmtCreate : public SwUndoFmtCreate +class SwUndoFrameFormatCreate : public SwUndoFormatCreate { bool bAuto; public: - SwUndoFrmFmtCreate(SwFrmFmt * pNew, SwFrmFmt * pDerivedFrom, + SwUndoFrameFormatCreate(SwFrameFormat * pNew, SwFrameFormat * pDerivedFrom, SwDoc * pDoc); - virtual SwFmt * Create(SwFmt * pDerivedFrom) SAL_OVERRIDE; + virtual SwFormat * Create(SwFormat * pDerivedFrom) SAL_OVERRIDE; virtual void Delete() SAL_OVERRIDE; - virtual SwFmt * Find(const OUString & rName) const SAL_OVERRIDE; + virtual SwFormat * Find(const OUString & rName) const SAL_OVERRIDE; }; -class SwUndoFrmFmtDelete : public SwUndoFmtDelete +class SwUndoFrameFormatDelete : public SwUndoFormatDelete { public: - SwUndoFrmFmtDelete(SwFrmFmt * pOld, SwDoc * pDoc); + SwUndoFrameFormatDelete(SwFrameFormat * pOld, SwDoc * pDoc); - virtual SwFmt * Create(SwFmt * pDerivedFrom) SAL_OVERRIDE; - virtual void Delete(SwFmt * pFmt) SAL_OVERRIDE; - virtual SwFmt * Find(const OUString & rName) const SAL_OVERRIDE; + virtual SwFormat * Create(SwFormat * pDerivedFrom) SAL_OVERRIDE; + virtual void Delete(SwFormat * pFormat) SAL_OVERRIDE; + virtual SwFormat * Find(const OUString & rName) const SAL_OVERRIDE; }; -class SwUndoRenameFrmFmt : public SwUndoRenameFmt +class SwUndoRenameFrameFormat : public SwUndoRenameFormat { public: - SwUndoRenameFrmFmt(const OUString & sOldName, + SwUndoRenameFrameFormat(const OUString & sOldName, const OUString & sNewName, SwDoc * pDoc); - virtual SwFmt * Find(const OUString & rName) const SAL_OVERRIDE; + virtual SwFormat * Find(const OUString & rName) const SAL_OVERRIDE; }; class SwUndoNumruleCreate : public SwUndo diff --git a/sw/source/core/inc/SwXMLTextBlocks.hxx b/sw/source/core/inc/SwXMLTextBlocks.hxx index d2c8abc5d0bb..070335b41f15 100644 --- a/sw/source/core/inc/SwXMLTextBlocks.hxx +++ b/sw/source/core/inc/SwXMLTextBlocks.hxx @@ -52,8 +52,8 @@ public: short nCurBlk; SwXMLTextBlocks( const OUString& rFile ); SwXMLTextBlocks( const com::sun::star::uno::Reference < com::sun::star::embed::XStorage >&, const OUString& rFile ); - void AddName( const OUString&, const OUString&, const OUString&, bool bOnlyTxt = false ); - virtual void AddName( const OUString&, const OUString&, bool bOnlyTxt = false ) SAL_OVERRIDE; + void AddName( const OUString&, const OUString&, const OUString&, bool bOnlyText = false ); + virtual void AddName( const OUString&, const OUString&, bool bOnlyText = false ) SAL_OVERRIDE; static OUString GeneratePackageName ( const OUString& rShort ); virtual ~SwXMLTextBlocks(); virtual sal_uLong Delete( sal_uInt16 ) SAL_OVERRIDE; @@ -80,7 +80,7 @@ public: bool IsOnlyTextBlock( sal_uInt16 nIdx ) const; void SetIsTextOnly( const OUString& rShort, bool bNewValue ); - virtual sal_uLong GetMacroTable( sal_uInt16, SvxMacroTableDtor& rMacroTbl, + virtual sal_uLong GetMacroTable( sal_uInt16, SvxMacroTableDtor& rMacroTable, bool bFileAlreadyOpen = false ) SAL_OVERRIDE; virtual sal_uLong SetMacroTable( sal_uInt16 nIdx, const SvxMacroTableDtor& rMacroTable, diff --git a/sw/source/core/inc/UndoAttribute.hxx b/sw/source/core/inc/UndoAttribute.hxx index ec923ac2ae9c..a6ed6feed14c 100644 --- a/sw/source/core/inc/UndoAttribute.hxx +++ b/sw/source/core/inc/UndoAttribute.hxx @@ -29,8 +29,8 @@ #include <set> class SvxTabStopItem; -class SwFmt; -class SwFtnInfo; +class SwFormat; +class SwFootnoteInfo; class SwEndNoteInfo; class SwUndoAttr : public SwUndo, private SwUndRng @@ -54,7 +54,7 @@ public: virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RepeatImpl( ::sw::RepeatContext & ) SAL_OVERRIDE; - void SaveRedlineData( const SwPaM& rPam, bool bInsCntnt ); + void SaveRedlineData( const SwPaM& rPam, bool bInsContent ); SwHistory& GetHistory() { return *m_pHistory; } }; @@ -66,8 +66,8 @@ class SwUndoResetAttr : public SwUndo, private SwUndRng const sal_uInt16 m_nFormatId; // Format-Id for Redo public: - SwUndoResetAttr( const SwPaM&, sal_uInt16 nFmtId ); - SwUndoResetAttr( const SwPosition&, sal_uInt16 nFmtId ); + SwUndoResetAttr( const SwPaM&, sal_uInt16 nFormatId ); + SwUndoResetAttr( const SwPosition&, sal_uInt16 nFormatId ); virtual ~SwUndoResetAttr(); @@ -80,16 +80,16 @@ public: SwHistory& GetHistory() { return *m_pHistory; } }; -class SwUndoFmtAttr : public SwUndo +class SwUndoFormatAttr : public SwUndo { friend class SwUndoDefaultAttr; - SwFmt * m_pFmt; + SwFormat * m_pFormat; ::std::unique_ptr<SfxItemSet> m_pOldSet; // old attributes sal_uLong m_nNodeIndex; - const sal_uInt16 m_nFmtWhich; + const sal_uInt16 m_nFormatWhich; const bool m_bSaveDrawPt; - bool IsFmtInDoc( SwDoc* ); //is the attribute format still in the Doc? + bool IsFormatInDoc( SwDoc* ); //is the attribute format still in the Doc? void SaveFlyAnchor( bool bSaveDrawPt = false ); // #i35443# - Add return value, type <bool>. // Return value indicates, if anchor attribute is restored. @@ -106,14 +106,14 @@ class SwUndoFmtAttr : public SwUndo public: // register at the Format and save old attributes // --> OD 2008-02-27 #refactorlists# - removed <rNewSet> - SwUndoFmtAttr( const SfxItemSet& rOldSet, - SwFmt& rFmt, + SwUndoFormatAttr( const SfxItemSet& rOldSet, + SwFormat& rFormat, bool bSaveDrawPt = true ); - SwUndoFmtAttr( const SfxPoolItem& rItem, - SwFmt& rFmt, + SwUndoFormatAttr( const SfxPoolItem& rItem, + SwFormat& rFormat, bool bSaveDrawPt = true ); - virtual ~SwUndoFmtAttr(); + virtual ~SwUndoFormatAttr(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; @@ -122,36 +122,36 @@ public: virtual SwRewriter GetRewriter() const SAL_OVERRIDE; void PutAttr( const SfxPoolItem& rItem ); - SwFmt* GetFmt( SwDoc& rDoc ); // checks if it is still in the Doc! + SwFormat* GetFormat( SwDoc& rDoc ); // checks if it is still in the Doc! }; // --> OD 2008-02-12 #newlistlevelattrs# -class SwUndoFmtResetAttr : public SwUndo +class SwUndoFormatResetAttr : public SwUndo { public: - SwUndoFmtResetAttr( SwFmt& rChangedFormat, + SwUndoFormatResetAttr( SwFormat& rChangedFormat, const sal_uInt16 nWhichId ); - virtual ~SwUndoFmtResetAttr(); + virtual ~SwUndoFormatResetAttr(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; private: // format at which a certain attribute is reset. - SwFmt * const m_pChangedFormat; + SwFormat * const m_pChangedFormat; // which ID of the reset attribute const sal_uInt16 m_nWhichId; // old attribute which has been reset - needed for undo. ::std::unique_ptr<SfxPoolItem> m_pOldItem; }; -class SwUndoDontExpandFmt : public SwUndo +class SwUndoDontExpandFormat : public SwUndo { const sal_uLong m_nNodeIndex; const sal_Int32 m_nContentIndex; public: - SwUndoDontExpandFmt( const SwPosition& rPos ); + SwUndoDontExpandFormat( const SwPosition& rPos ); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; @@ -159,19 +159,19 @@ public: }; // helper class to receive changed attribute sets -class SwUndoFmtAttrHelper : public SwClient +class SwUndoFormatAttrHelper : public SwClient { - ::std::unique_ptr<SwUndoFmtAttr> m_pUndo; + ::std::unique_ptr<SwUndoFormatAttr> m_pUndo; const bool m_bSaveDrawPt; public: - SwUndoFmtAttrHelper( SwFmt& rFmt, bool bSaveDrawPt = true ); + SwUndoFormatAttrHelper( SwFormat& rFormat, bool bSaveDrawPt = true ); virtual void Modify( const SfxPoolItem*, const SfxPoolItem* ) SAL_OVERRIDE; - SwUndoFmtAttr* GetUndo() const { return m_pUndo.get(); } + SwUndoFormatAttr* GetUndo() const { return m_pUndo.get(); } // release the undo object (so it is not deleted here), and return it - SwUndoFmtAttr* ReleaseUndo() { return m_pUndo.release(); } + SwUndoFormatAttr* ReleaseUndo() { return m_pUndo.release(); } }; class SwUndoMoveLeftMargin : public SwUndo, private SwUndRng @@ -215,7 +215,7 @@ class SwUndoChangeFootNote : public SwUndo, private SwUndRng const bool m_bEndNote; public: - SwUndoChangeFootNote( const SwPaM& rRange, const OUString& rTxt, + SwUndoChangeFootNote( const SwPaM& rRange, const OUString& rText, sal_uInt16 nNum, bool bIsEndNote ); virtual ~SwUndoChangeFootNote(); @@ -228,10 +228,10 @@ public: class SwUndoFootNoteInfo : public SwUndo { - ::std::unique_ptr<SwFtnInfo> m_pFootNoteInfo; + ::std::unique_ptr<SwFootnoteInfo> m_pFootNoteInfo; public: - SwUndoFootNoteInfo( const SwFtnInfo &rInfo ); + SwUndoFootNoteInfo( const SwFootnoteInfo &rInfo ); virtual ~SwUndoFootNoteInfo(); diff --git a/sw/source/core/inc/UndoCore.hxx b/sw/source/core/inc/UndoCore.hxx index eff8a943ede1..5863bc32ba76 100644 --- a/sw/source/core/inc/UndoCore.hxx +++ b/sw/source/core/inc/UndoCore.hxx @@ -26,11 +26,11 @@ #include <redline.hxx> class SfxItemSet; -class SwFmtColl; -class SwFmtAnchor; +class SwFormatColl; +class SwFormatAnchor; class SdrMarkList; class SwUndoDelete; -class SwFmt; +class SwFormat; namespace sw { class UndoManager; @@ -84,7 +84,7 @@ public: UndoRedoContext(SwDoc & rDoc, IShellCursorSupplier & rCursorSupplier) : m_rDoc(rDoc) , m_rCursorSupplier(rCursorSupplier) - , m_pSelFmt(0) + , m_pSelFormat(0) , m_pMarkList(0) { } @@ -92,21 +92,21 @@ public: IShellCursorSupplier & GetCursorSupplier() { return m_rCursorSupplier; } - void SetSelections(SwFrmFmt *const pSelFmt, SdrMarkList *const pMarkList) + void SetSelections(SwFrameFormat *const pSelFormat, SdrMarkList *const pMarkList) { - m_pSelFmt = pSelFmt; + m_pSelFormat = pSelFormat; m_pMarkList = pMarkList; } - void GetSelections(SwFrmFmt *& o_rpSelFmt, SdrMarkList *& o_rpMarkList) + void GetSelections(SwFrameFormat *& o_rpSelFormat, SdrMarkList *& o_rpMarkList) { - o_rpSelFmt = m_pSelFmt; + o_rpSelFormat = m_pSelFormat; o_rpMarkList = m_pMarkList; } private: SwDoc & m_rDoc; IShellCursorSupplier & m_rCursorSupplier; - SwFrmFmt * m_pSelFmt; + SwFrameFormat * m_pSelFormat; SdrMarkList * m_pMarkList; }; @@ -138,11 +138,11 @@ private: } // namespace sw -class SwUndoFmtColl : public SwUndo, private SwUndRng +class SwUndoFormatColl : public SwUndo, private SwUndRng { - OUString aFmtName; + OUString aFormatName; SwHistory* pHistory; - SwFmtColl* pFmtColl; + SwFormatColl* pFormatColl; // for correct <ReDo(..)> and <Repeat(..)> // boolean, which indicates that the attributes are reseted at the nodes // before the format has been applied. @@ -151,13 +151,13 @@ class SwUndoFmtColl : public SwUndo, private SwUndRng // the nodes before the format has been applied. const bool mbResetListAttrs; - void DoSetFmtColl(SwDoc & rDoc, SwPaM & rPaM); + void DoSetFormatColl(SwDoc & rDoc, SwPaM & rPaM); public: - SwUndoFmtColl( const SwPaM&, SwFmtColl*, + SwUndoFormatColl( const SwPaM&, SwFormatColl*, const bool bReset, const bool bResetListAttrs ); - virtual ~SwUndoFmtColl(); + virtual ~SwUndoFormatColl(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; @@ -182,30 +182,30 @@ public: }; -class SwUndoSetFlyFmt : public SwUndo, public SwClient +class SwUndoSetFlyFormat : public SwUndo, public SwClient { - SwFrmFmt* pFrmFmt; // saved FlyFormat - SwFrmFmt* pOldFmt; - SwFrmFmt* pNewFmt; + SwFrameFormat* pFrameFormat; // saved FlyFormat + SwFrameFormat* pOldFormat; + SwFrameFormat* pNewFormat; SfxItemSet* pItemSet; // the re-/ set attributes sal_uLong nOldNode, nNewNode; - sal_Int32 nOldCntnt, nNewCntnt; + sal_Int32 nOldContent, nNewContent; sal_uInt16 nOldAnchorTyp, nNewAnchorTyp; bool bAnchorChgd; void PutAttr( sal_uInt16 nWhich, const SfxPoolItem* pItem ); void Modify( const SfxPoolItem*, const SfxPoolItem* ) SAL_OVERRIDE; - void GetAnchor( SwFmtAnchor& rAnhor, sal_uLong nNode, sal_Int32 nCntnt ); + void GetAnchor( SwFormatAnchor& rAnhor, sal_uLong nNode, sal_Int32 nContent ); public: - SwUndoSetFlyFmt( SwFrmFmt& rFlyFmt, SwFrmFmt& rNewFrmFmt ); - virtual ~SwUndoSetFlyFmt(); + SwUndoSetFlyFormat( SwFrameFormat& rFlyFormat, SwFrameFormat& rNewFrameFormat ); + virtual ~SwUndoSetFlyFormat(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual SwRewriter GetRewriter() const SAL_OVERRIDE; - void DeRegisterFromFormat( SwFmt& ); + void DeRegisterFromFormat( SwFormat& ); }; class SwUndoOutlineLeftRight : public SwUndo, private SwUndRng diff --git a/sw/source/core/inc/UndoDelete.hxx b/sw/source/core/inc/UndoDelete.hxx index 965bfe8d8897..7316cc9d7b85 100644 --- a/sw/source/core/inc/UndoDelete.hxx +++ b/sw/source/core/inc/UndoDelete.hxx @@ -25,7 +25,7 @@ #include <tools/mempool.hxx> class SwRedlineSaveDatas; -class SwTxtNode; +class SwTextNode; namespace sfx2 { class MetadatableUndo; @@ -34,7 +34,7 @@ namespace sfx2 { class SwUndoDelete : public SwUndo , private SwUndRng - , private SwUndoSaveCntnt + , private SwUndoSaveContent { SwNodeIndex* pMvStt; // Position of Nodes in UndoNodes-Array OUString *pSttStr, *pEndStr; @@ -54,20 +54,20 @@ class SwUndoDelete bool bGroup : 1; // TRUE: is already Grouped; see CanGrouping() bool bBackSp : 1; // TRUE: if Grouped and preceding content deleted bool bJoinNext: 1; // TRUE: if range is selected forwards - bool bTblDelLastNd : 1; // TRUE: TextNode following Table inserted/deleted + bool bTableDelLastNd : 1; // TRUE: TextNode following Table inserted/deleted bool bDelFullPara : 1; // TRUE: entire Nodes were deleted bool bResetPgDesc : 1; // TRUE: reset PgDsc on following node bool bResetPgBrk : 1; // TRUE: reset PgBreak on following node - bool bFromTableCopy : 1; // TRUE: called by SwUndoTblCpyTbl + bool bFromTableCopy : 1; // TRUE: called by SwUndoTableCpyTable - bool SaveCntnt( const SwPosition* pStt, const SwPosition* pEnd, - SwTxtNode* pSttTxtNd, SwTxtNode* pEndTxtNd ); + bool SaveContent( const SwPosition* pStt, const SwPosition* pEnd, + SwTextNode* pSttTextNd, SwTextNode* pEndTextNd ); public: SwUndoDelete( SwPaM&, bool bFullPara = false, - bool bCalledByTblCpy = false ); + bool bCalledByTableCpy = false ); virtual ~SwUndoDelete(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; @@ -88,7 +88,7 @@ public: bool CanGrouping( SwDoc*, const SwPaM& ); - void SetTblDelLastNd() { bTblDelLastNd = true; } + void SetTableDelLastNd() { bTableDelLastNd = true; } // for PageDesc/PageBreak Attributes of a table void SetPgBrkFlags( bool bPageBreak, bool bPageDesc ) @@ -96,7 +96,7 @@ public: void SetTableName(const OUString & rName); - // SwUndoTblCpyTbl needs this information: + // SwUndoTableCpyTable needs this information: bool IsDelFullPara() const { return bDelFullPara; } DECL_FIXEDMEMPOOL_NEWDEL(SwUndoDelete) diff --git a/sw/source/core/inc/UndoDraw.hxx b/sw/source/core/inc/UndoDraw.hxx index fcf5c11128e2..f1b8fa59d6f8 100644 --- a/sw/source/core/inc/UndoDraw.hxx +++ b/sw/source/core/inc/UndoDraw.hxx @@ -29,7 +29,7 @@ class SdrMarkList; class SdrObject; class SdrObjGroup; class SdrUndoAction; -class SwDrawFrmFmt; +class SwDrawFrameFormat; // Undo for Draw Objects class SwSdrUndo : public SwUndo @@ -52,7 +52,7 @@ class SwUndoDrawGroup : public SwUndo { SwUndoGroupObjImpl* pObjArr; sal_uInt16 nSize; - bool bDelFmt; + bool bDelFormat; public: SwUndoDrawGroup( sal_uInt16 nCnt ); @@ -62,13 +62,13 @@ public: virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; - void AddObj( sal_uInt16 nPos, SwDrawFrmFmt*, SdrObject* ); - void SetGroupFmt( SwDrawFrmFmt* ); + void AddObj( sal_uInt16 nPos, SwDrawFrameFormat*, SdrObject* ); + void SetGroupFormat( SwDrawFrameFormat* ); }; // Action "ungroup drawing object" is now splitted into three parts - see // method <SwDoc::UnGroupSelection(..)>: -// - creation for <SwDrawFrmFmt> instances for the group members of the +// - creation for <SwDrawFrameFormat> instances for the group members of the // selected group objects // - intrinsic ungroup of the selected group objects // - creation of <SwDrawContact> instances for the former group members and @@ -81,7 +81,7 @@ class SwUndoDrawUnGroup : public SwUndo { SwUndoGroupObjImpl* pObjArr; sal_uInt16 nSize; - bool bDelFmt; + bool bDelFormat; public: SwUndoDrawUnGroup( SdrObjGroup* ); @@ -91,13 +91,13 @@ public: virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; - void AddObj( sal_uInt16 nPos, SwDrawFrmFmt* ); + void AddObj( sal_uInt16 nPos, SwDrawFrameFormat* ); }; class SwUndoDrawUnGroupConnectToLayout : public SwUndo { private: - std::vector< std::pair< SwDrawFrmFmt*, SdrObject* > > aDrawFmtsAndObjs; + std::vector< std::pair< SwDrawFrameFormat*, SdrObject* > > aDrawFormatsAndObjs; public: SwUndoDrawUnGroupConnectToLayout(); @@ -107,7 +107,7 @@ public: virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; - void AddFmtAndObj( SwDrawFrmFmt* pDrawFrmFmt, + void AddFormatAndObj( SwDrawFrameFormat* pDrawFrameFormat, SdrObject* pDrawObject ); }; @@ -116,7 +116,7 @@ class SwUndoDrawDelete : public SwUndo SwUndoGroupObjImpl* pObjArr; SdrMarkList* pMarkLst; // MarkList for all selected SdrObjects sal_uInt16 nSize; - bool bDelFmt; + bool bDelFormat; public: SwUndoDrawDelete( sal_uInt16 nCnt ); @@ -126,7 +126,7 @@ public: virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; - void AddObj( sal_uInt16 nPos, SwDrawFrmFmt*, const SdrMark& ); + void AddObj( sal_uInt16 nPos, SwDrawFrameFormat*, const SdrMark& ); }; #endif // INCLUDED_SW_SOURCE_CORE_INC_UNDODRAW_HXX diff --git a/sw/source/core/inc/UndoInsert.hxx b/sw/source/core/inc/UndoInsert.hxx index 3c6eb85fb547..8ef9263f8d41 100644 --- a/sw/source/core/inc/UndoInsert.hxx +++ b/sw/source/core/inc/UndoInsert.hxx @@ -29,17 +29,17 @@ class Graphic; class SwGrfNode; class SwUndoDelete; -class SwUndoFmtAttr; +class SwUndoFormatAttr; namespace sw { class DocumentContentOperationsManager; } -class SwUndoInsert: public SwUndo, private SwUndoSaveCntnt +class SwUndoInsert: public SwUndo, private SwUndoSaveContent { /// start of Content in UndoNodes for Redo ::boost::scoped_ptr<SwNodeIndex> m_pUndoNodeIndex; - OUString *pTxt, *pUndoTxt; + OUString *pText, *pUndoText; SwRedlineData* pRedlData; sal_uLong nNode; - sal_Int32 nCntnt, nLen; + sal_Int32 nContent, nLen; bool bIsWordDelim : 1; bool bIsAppend : 1; bool m_bWithRsid : 1; @@ -53,10 +53,10 @@ class SwUndoInsert: public SwUndo, private SwUndoSaveCntnt SwDoc * pDoc; void Init(const SwNodeIndex & rNode); - OUString * GetTxtFromDoc() const; + OUString * GetTextFromDoc() const; public: - SwUndoInsert( const SwNodeIndex& rNode, sal_Int32 nCntnt, sal_Int32 nLen, + SwUndoInsert( const SwNodeIndex& rNode, sal_Int32 nContent, sal_Int32 nLen, const SwInsertFlags nInsertFlags, bool bWDelim = true ); SwUndoInsert( const SwNodeIndex& rNode ); @@ -152,12 +152,12 @@ class SwUndoInsertLabel : public SwUndo { union { struct { - // for NoTxtFrms - SwUndoInsLayFmt* pUndoFly; - SwUndoFmtAttr* pUndoAttr; + // for NoTextFrms + SwUndoInsLayFormat* pUndoFly; + SwUndoFormatAttr* pUndoAttr; } OBJECT; struct { - // for tables or TxtFrms + // for tables or TextFrms SwUndoDelete* pUndoInsNd; sal_uLong nNode; } NODE; @@ -169,7 +169,7 @@ class SwUndoInsertLabel : public SwUndo OUString sNumberSeparator; OUString sCharacterStyle; // #i26791# - re-store of drawing object position no longer needed - sal_uInt16 nFldId; + sal_uInt16 nFieldId; SwLabelType eType; sal_uInt8 nLayerId; // for character objects bool bBefore :1; @@ -208,7 +208,7 @@ public: { if( LTYPE_OBJECT != eType ) NODE.nNode = nNd; } void SetUndoKeep() { bUndoKeep = true; } - void SetFlys( SwFrmFmt& rOldFly, SfxItemSet& rChgSet, SwFrmFmt& rNewFly ); + void SetFlys( SwFrameFormat& rOldFly, SfxItemSet& rChgSet, SwFrameFormat& rNewFly ); void SetDrawObj( sal_uInt8 nLayerId ); }; diff --git a/sw/source/core/inc/UndoNumbering.hxx b/sw/source/core/inc/UndoNumbering.hxx index ee711373eaf2..7e3164a76768 100644 --- a/sw/source/core/inc/UndoNumbering.hxx +++ b/sw/source/core/inc/UndoNumbering.hxx @@ -78,7 +78,7 @@ public: virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RepeatImpl( ::sw::RepeatContext & ) SAL_OVERRIDE; - void AddNode( const SwTxtNode& rNd, bool bResetLRSpace ); + void AddNode( const SwTextNode& rNd, bool bResetLRSpace ); SwHistory* GetHistory() { return pHistory; } }; diff --git a/sw/source/core/inc/UndoOverwrite.hxx b/sw/source/core/inc/UndoOverwrite.hxx index 473224d4ca57..dabc8e1f452f 100644 --- a/sw/source/core/inc/UndoOverwrite.hxx +++ b/sw/source/core/inc/UndoOverwrite.hxx @@ -25,18 +25,18 @@ #include <undobj.hxx> class SwRedlineSaveDatas; -class SwTxtNode; +class SwTextNode; namespace utl { class TransliterationWrapper; } -class SwUndoOverwrite: public SwUndo, private SwUndoSaveCntnt +class SwUndoOverwrite: public SwUndo, private SwUndoSaveContent { OUString aDelStr, aInsStr; SwRedlineSaveDatas* pRedlSaveData; sal_uLong nSttNode; - sal_Int32 nSttCntnt; + sal_Int32 nSttContent; bool bInsChar : 1; // no Overwrite, but Insert bool bGroup : 1; // TRUE: is already grouped; evaluated in CanGrouping() @@ -83,7 +83,7 @@ public: virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RepeatImpl( ::sw::RepeatContext & ) SAL_OVERRIDE; - void AddChanges( SwTxtNode& rTNd, sal_Int32 nStart, sal_Int32 nLen, + void AddChanges( SwTextNode& rTNd, sal_Int32 nStart, sal_Int32 nLen, ::com::sun::star::uno::Sequence <sal_Int32>& rOffsets ); bool HasData() const { return aChanges.size() > 0; } }; diff --git a/sw/source/core/inc/UndoRedline.hxx b/sw/source/core/inc/UndoRedline.hxx index b67e066065d3..72684ff50420 100644 --- a/sw/source/core/inc/UndoRedline.hxx +++ b/sw/source/core/inc/UndoRedline.hxx @@ -64,16 +64,16 @@ public: bool CanGrouping( const SwUndoRedlineDelete& rPrev ); - // SwUndoTblCpyTbl needs this information: + // SwUndoTableCpyTable needs this information: long NodeDiff() const { return nSttNode - nEndNode; } - sal_Int32 ContentStart() const { return nSttCntnt; } + sal_Int32 ContentStart() const { return nSttContent; } }; class SwUndoRedlineSort : public SwUndoRedline { SwSortOptions* pOpt; sal_uLong nSaveEndNode, nOffset; - sal_Int32 nSaveEndCntnt; + sal_Int32 nSaveEndContent; virtual void UndoRedlineImpl(SwDoc & rDoc, SwPaM & rPam) SAL_OVERRIDE; virtual void RedoRedlineImpl(SwDoc & rDoc, SwPaM & rPam) SAL_OVERRIDE; diff --git a/sw/source/core/inc/UndoSection.hxx b/sw/source/core/inc/UndoSection.hxx index 8ba75624f5d7..16f1f1131c76 100644 --- a/sw/source/core/inc/UndoSection.hxx +++ b/sw/source/core/inc/UndoSection.hxx @@ -25,9 +25,9 @@ #include <swdllapi.h> class SfxItemSet; -class SwTxtNode; +class SwTextNode; class SwSectionData; -class SwSectionFmt; +class SwSectionFormat; class SwTOXBase; class SwUndoInsSection : public SwUndo, private SwUndRng @@ -42,7 +42,7 @@ private: sal_uLong m_nSectionNodePos; bool m_bSplitAtStart : 1; bool m_bSplitAtEnd : 1; - bool m_bUpdateFtn : 1; + bool m_bUpdateFootnote : 1; void Join( SwDoc& rDoc, sal_uLong nNode ); @@ -57,13 +57,13 @@ public: virtual void RepeatImpl( ::sw::RepeatContext & ) SAL_OVERRIDE; void SetSectNdPos(sal_uLong const nPos) { m_nSectionNodePos = nPos; } - void SaveSplitNode(SwTxtNode *const pTxtNd, bool const bAtStart); - void SetUpdtFtnFlag(bool const bFlag) { m_bUpdateFtn = bFlag; } + void SaveSplitNode(SwTextNode *const pTextNd, bool const bAtStart); + void SetUpdateFootnoteFlag(bool const bFlag) { m_bUpdateFootnote = bFlag; } }; -SwUndo * MakeUndoDelSection(SwSectionFmt const&); +SwUndo * MakeUndoDelSection(SwSectionFormat const&); -SwUndo * MakeUndoUpdateSection(SwSectionFmt const&, bool const); +SwUndo * MakeUndoUpdateSection(SwSectionFormat const&, bool const); #endif // INCLUDED_SW_SOURCE_CORE_INC_UNDOSECTION_HXX diff --git a/sw/source/core/inc/UndoSort.hxx b/sw/source/core/inc/UndoSort.hxx index f1be7738bbe6..56bb95d69fcf 100644 --- a/sw/source/core/inc/UndoSort.hxx +++ b/sw/source/core/inc/UndoSort.hxx @@ -26,7 +26,7 @@ struct SwSortOptions; class SwTableNode; -class SwUndoAttrTbl; +class SwUndoAttrTable; struct SwSortUndoElement { @@ -61,9 +61,9 @@ class SwUndoSort : public SwUndo, private SwUndRng { SwSortOptions* pSortOpt; SwSortList aSortList; - SwUndoAttrTbl* pUndoTblAttr; + SwUndoAttrTable* pUndoTableAttr; SwRedlineData* pRedlData; - sal_uLong nTblNd; + sal_uLong nTableNd; public: SwUndoSort( const SwPaM&, const SwSortOptions& ); diff --git a/sw/source/core/inc/UndoSplitMove.hxx b/sw/source/core/inc/UndoSplitMove.hxx index 9030f70838b5..dbe69d0fef5d 100644 --- a/sw/source/core/inc/UndoSplitMove.hxx +++ b/sw/source/core/inc/UndoSplitMove.hxx @@ -27,13 +27,13 @@ class SwUndoSplitNode: public SwUndo SwHistory* pHistory; SwRedlineData* pRedlData; sal_uLong nNode; - sal_Int32 nCntnt; - bool bTblFlag : 1; - bool bChkTblStt : 1; + sal_Int32 nContent; + bool bTableFlag : 1; + bool bChkTableStt : 1; sal_uInt32 nParRsid; public: - SwUndoSplitNode( SwDoc* pDoc, const SwPosition& rPos, bool bChkTbl ); + SwUndoSplitNode( SwDoc* pDoc, const SwPosition& rPos, bool bChkTable ); virtual ~SwUndoSplitNode(); @@ -41,18 +41,18 @@ public: virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RepeatImpl( ::sw::RepeatContext & ) SAL_OVERRIDE; - void SetTblFlag() { bTblFlag = true; } + void SetTableFlag() { bTableFlag = true; } }; -class SwUndoMove : public SwUndo, private SwUndRng, private SwUndoSaveCntnt +class SwUndoMove : public SwUndo, private SwUndRng, private SwUndoSaveContent { // nDest.. - destination range of move (after move!) // nIns.. - source Position of move (after move!) // nMv.. - destination position of move (before move!); for REDO sal_uLong nDestSttNode, nDestEndNode, nInsPosNode, nMvDestNode; - sal_Int32 nDestSttCntnt, nDestEndCntnt, nInsPosCntnt, nMvDestCntnt; + sal_Int32 nDestSttContent, nDestEndContent, nInsPosContent, nMvDestContent; - sal_uInt16 nFtnStt; // StartPos of Footnotes in History + sal_uInt16 nFootnoteStt; // StartPos of Footnotes in History bool bJoinNext : 1, bJoinPrev : 1, @@ -60,7 +60,7 @@ class SwUndoMove : public SwUndo, private SwUndRng, private SwUndoSaveCntnt bool bMoveRedlines; // use DOC_MOVEREDLINES when calling SwDoc::Move - void DelFtn( const SwPaM& ); + void DelFootnote( const SwPaM& ); public: SwUndoMove( const SwPaM&, const SwPosition& ); @@ -77,7 +77,7 @@ public: bool IsMoveRange() const { return bMoveRange; } sal_uLong GetEndNode() const { return nEndNode; } sal_uLong GetDestSttNode() const { return nDestSttNode; } - sal_Int32 GetDestSttCntnt() const { return nDestSttCntnt; } + sal_Int32 GetDestSttContent() const { return nDestSttContent; } void SetMoveRedlines( bool b ) { bMoveRedlines = b; } }; diff --git a/sw/source/core/inc/UndoTable.hxx b/sw/source/core/inc/UndoTable.hxx index 31a3502457a3..8a75054c3c4e 100644 --- a/sw/source/core/inc/UndoTable.hxx +++ b/sw/source/core/inc/UndoTable.hxx @@ -37,33 +37,33 @@ class SwUndoSaveSections; class SwUndoMoves; class SwUndoDelete; class SwSelBoxes; -class SwTblToTxtSaves; +class SwTableToTextSaves; class SwTable; class SwTableBox; class SwStartNode; class SwTableNode; -class SwTableAutoFmt; +class SwTableAutoFormat; class SwTableSortBoxes; -class SwUndoInsTbl : public SwUndo +class SwUndoInsTable : public SwUndo { - OUString sTblNm; - SwInsertTableOptions aInsTblOpts; - SwDDEFieldType* pDDEFldType; + OUString sTableNm; + SwInsertTableOptions aInsTableOpts; + SwDDEFieldType* pDDEFieldType; std::vector<sal_uInt16> *pColWidth; SwRedlineData* pRedlData; - SwTableAutoFmt* pAutoFmt; + SwTableAutoFormat* pAutoFormat; sal_uLong nSttNode; sal_uInt16 nRows, nCols; sal_uInt16 nAdjust; public: - SwUndoInsTbl( const SwPosition&, sal_uInt16 nCols, sal_uInt16 nRows, - sal_uInt16 eAdjust, const SwInsertTableOptions& rInsTblOpts, - const SwTableAutoFmt* pTAFmt, const std::vector<sal_uInt16> *pColArr, + SwUndoInsTable( const SwPosition&, sal_uInt16 nCols, sal_uInt16 nRows, + sal_uInt16 eAdjust, const SwInsertTableOptions& rInsTableOpts, + const SwTableAutoFormat* pTAFormat, const std::vector<sal_uInt16> *pColArr, const OUString & rName); - virtual ~SwUndoInsTbl(); + virtual ~SwUndoInsTable(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; @@ -72,23 +72,23 @@ public: virtual SwRewriter GetRewriter() const SAL_OVERRIDE; }; -class SwUndoTxtToTbl : public SwUndo, public SwUndRng +class SwUndoTextToTable : public SwUndo, public SwUndRng { - OUString sTblNm; - SwInsertTableOptions aInsTblOpts; + OUString sTableNm; + SwInsertTableOptions aInsTableOpts; std::vector<sal_uLong>* pDelBoxes; - SwTableAutoFmt* pAutoFmt; + SwTableAutoFormat* pAutoFormat; SwHistory* pHistory; sal_Unicode cTrenner; sal_uInt16 nAdjust; bool bSplitEnd : 1; public: - SwUndoTxtToTbl( const SwPaM&, const SwInsertTableOptions&, sal_Unicode, + SwUndoTextToTable( const SwPaM&, const SwInsertTableOptions&, sal_Unicode, sal_uInt16, - const SwTableAutoFmt* pAFmt ); + const SwTableAutoFormat* pAFormat ); - virtual ~SwUndoTxtToTbl(); + virtual ~SwUndoTextToTable(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; @@ -98,22 +98,22 @@ public: void AddFillBox( const SwTableBox& rBox ); }; -class SwUndoTblToTxt : public SwUndo +class SwUndoTableToText : public SwUndo { - OUString sTblNm; - SwDDEFieldType* pDDEFldType; - _SaveTable* pTblSave; - SwTblToTxtSaves* pBoxSaves; + OUString sTableNm; + SwDDEFieldType* pDDEFieldType; + _SaveTable* pTableSave; + SwTableToTextSaves* pBoxSaves; SwHistory* pHistory; sal_uLong nSttNd, nEndNd; sal_Unicode cTrenner; sal_uInt16 nHdlnRpt; - bool bCheckNumFmt : 1; + bool bCheckNumFormat : 1; public: - SwUndoTblToTxt( const SwTable& rTbl, sal_Unicode cCh ); + SwUndoTableToText( const SwTable& rTable, sal_Unicode cCh ); - virtual ~SwUndoTblToTxt(); + virtual ~SwUndoTableToText(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; @@ -121,50 +121,50 @@ public: void SetRange( const SwNodeRange& ); void AddBoxPos( SwDoc& rDoc, sal_uLong nNdIdx, sal_uLong nEndIdx, - sal_Int32 nCntntIdx = SAL_MAX_INT32); + sal_Int32 nContentIdx = SAL_MAX_INT32); }; -class SwUndoAttrTbl : public SwUndo +class SwUndoAttrTable : public SwUndo { sal_uLong nSttNode; - _SaveTable* pSaveTbl; + _SaveTable* pSaveTable; bool bClearTabCol : 1; public: - SwUndoAttrTbl( const SwTableNode& rTblNd, bool bClearTabCols = false ); + SwUndoAttrTable( const SwTableNode& rTableNd, bool bClearTabCols = false ); - virtual ~SwUndoAttrTbl(); + virtual ~SwUndoAttrTable(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; }; -class SwUndoTblNumFmt; +class SwUndoTableNumFormat; -class SwUndoTblAutoFmt : public SwUndo +class SwUndoTableAutoFormat : public SwUndo { sal_uLong nSttNode; - _SaveTable* pSaveTbl; - std::vector< std::shared_ptr<SwUndoTblNumFmt> > m_Undos; - bool bSaveCntntAttr; + _SaveTable* pSaveTable; + std::vector< std::shared_ptr<SwUndoTableNumFormat> > m_Undos; + bool bSaveContentAttr; sal_uInt16 m_nRepeatHeading; void UndoRedo(bool const bUndo, ::sw::UndoRedoContext & rContext); public: - SwUndoTblAutoFmt( const SwTableNode& rTblNd, const SwTableAutoFmt& ); + SwUndoTableAutoFormat( const SwTableNode& rTableNd, const SwTableAutoFormat& ); - virtual ~SwUndoTblAutoFmt(); + virtual ~SwUndoTableAutoFormat(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; - void SaveBoxCntnt( const SwTableBox& rBox ); + void SaveBoxContent( const SwTableBox& rBox ); }; -class SwUndoTblNdsChg : public SwUndo, private boost::noncopyable +class SwUndoTableNdsChg : public SwUndo, private boost::noncopyable { - _SaveTable* pSaveTbl; + _SaveTable* pSaveTable; std::set<sal_uLong> m_Boxes; struct _BoxMove { @@ -182,23 +182,23 @@ class SwUndoTblNdsChg : public SwUndo, private boost::noncopyable bool bSameHeight; // only used for SplitRow public: - SwUndoTblNdsChg( SwUndoId UndoId, + SwUndoTableNdsChg( SwUndoId UndoId, const SwSelBoxes& rBoxes, - const SwTableNode& rTblNd, + const SwTableNode& rTableNd, long nMn, long nMx, sal_uInt16 nCnt, bool bFlg, bool bSameHeight ); // for SetColWidth - SwUndoTblNdsChg( SwUndoId UndoId, const SwSelBoxes& rBoxes, - const SwTableNode& rTblNd ); + SwUndoTableNdsChg( SwUndoId UndoId, const SwSelBoxes& rBoxes, + const SwTableNode& rTableNd ); - virtual ~SwUndoTblNdsChg(); + virtual ~SwUndoTableNdsChg(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; - void SaveNewBoxes( const SwTableNode& rTblNd, const SwTableSortBoxes& rOld ); - void SaveNewBoxes( const SwTableNode& rTblNd, const SwTableSortBoxes& rOld, + void SaveNewBoxes( const SwTableNode& rTableNd, const SwTableSortBoxes& rOld ); + void SaveNewBoxes( const SwTableNode& rTableNd, const SwTableSortBoxes& rOld, const SwSelBoxes& rBoxes, const std::vector<sal_uLong> &rNodeCnts ); void SaveSection( SwStartNode* pSttNd ); void ReNewBoxes( const SwSelBoxes& rBoxes ); @@ -214,24 +214,24 @@ public: } }; -class SwUndoTblMerge : public SwUndo, private SwUndRng +class SwUndoTableMerge : public SwUndo, private SwUndRng { - sal_uLong nTblNode; - _SaveTable* pSaveTbl; + sal_uLong nTableNode; + _SaveTable* pSaveTable; std::set<sal_uLong> m_Boxes; std::vector<sal_uLong> aNewSttNds; SwUndoMoves* pMoves; SwHistory* pHistory; public: - SwUndoTblMerge( const SwPaM& rTblSel ); + SwUndoTableMerge( const SwPaM& rTableSel ); - virtual ~SwUndoTblMerge(); + virtual ~SwUndoTableMerge(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; - void MoveBoxCntnt( SwDoc* pDoc, SwNodeRange& rRg, SwNodeIndex& rPos ); + void MoveBoxContent( SwDoc* pDoc, SwNodeRange& rRg, SwNodeIndex& rPos ); void SetSelBoxes( const SwSelBoxes& rBoxes ); @@ -241,40 +241,40 @@ public: void SaveCollection( const SwTableBox& rBox ); }; -class SwUndoTblNumFmt : public SwUndo +class SwUndoTableNumFormat : public SwUndo { SfxItemSet *pBoxSet; SwHistory* pHistory; - OUString aStr, aNewFml; + OUString aStr, aNewFormula; - sal_uLong nFmtIdx, nNewFmtIdx; + sal_uLong nFormatIdx, nNewFormatIdx; double fNum, fNewNum; sal_uLong nNode; sal_uLong nNdPos; - bool bNewFmt : 1; - bool bNewFml : 1; + bool bNewFormat : 1; + bool bNewFormula : 1; bool bNewValue : 1; public: - SwUndoTblNumFmt( const SwTableBox& rBox, const SfxItemSet* pNewSet = 0 ); + SwUndoTableNumFormat( const SwTableBox& rBox, const SfxItemSet* pNewSet = 0 ); - virtual ~SwUndoTblNumFmt(); + virtual ~SwUndoTableNumFormat(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; - void SetNumFmt( sal_uLong nNewNumFmtIdx, const double& rNewNumber ) - { nFmtIdx = nNewNumFmtIdx; fNum = rNewNumber; } + void SetNumFormat( sal_uLong nNewNumFormatIdx, const double& rNewNumber ) + { nFormatIdx = nNewNumFormatIdx; fNum = rNewNumber; } void SetBox( const SwTableBox& rBox ); }; -class _UndoTblCpyTbl_Entries; +class _UndoTableCpyTable_Entries; -class SwUndoTblCpyTbl : public SwUndo +class SwUndoTableCpyTable : public SwUndo { - _UndoTblCpyTbl_Entries* pArr; - SwUndoTblNdsChg* pInsRowUndo; + _UndoTableCpyTable_Entries* pArr; + SwUndoTableNdsChg* pInsRowUndo; //b6341295: When redlining is active, PrepareRedline has to create the //redlining attributes for the new and the old table cell content @@ -282,75 +282,75 @@ class SwUndoTblCpyTbl : public SwUndo const SwPosition& rPos, bool& rJoin, bool bRedo ); public: - SwUndoTblCpyTbl(); + SwUndoTableCpyTable(); - virtual ~SwUndoTblCpyTbl(); + virtual ~SwUndoTableCpyTable(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; - void AddBoxBefore( const SwTableBox& rBox, bool bDelCntnt ); + void AddBoxBefore( const SwTableBox& rBox, bool bDelContent ); void AddBoxAfter( const SwTableBox& rBox, const SwNodeIndex& rIdx, - bool bDelCntnt ); + bool bDelContent ); bool IsEmpty() const; - bool InsertRow( SwTable& rTbl, const SwSelBoxes& rBoxes, sal_uInt16 nCnt ); + bool InsertRow( SwTable& rTable, const SwSelBoxes& rBoxes, sal_uInt16 nCnt ); }; -class SwUndoCpyTbl : public SwUndo +class SwUndoCpyTable : public SwUndo { SwUndoDelete* pDel; - sal_uLong nTblNode; + sal_uLong nTableNode; public: - SwUndoCpyTbl(); + SwUndoCpyTable(); - virtual ~SwUndoCpyTbl(); + virtual ~SwUndoCpyTable(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; - void SetTableSttIdx( sal_uLong nIdx ) { nTblNode = nIdx; } + void SetTableSttIdx( sal_uLong nIdx ) { nTableNode = nIdx; } }; -class SwUndoSplitTbl : public SwUndo +class SwUndoSplitTable : public SwUndo { - sal_uLong nTblNode, nOffset; + sal_uLong nTableNode, nOffset; SwSaveRowSpan* mpSaveRowSpan; // stores row span values at the splitting row - _SaveTable* pSavTbl; + _SaveTable* pSavTable; SwHistory* pHistory; - sal_uInt16 nMode, nFmlEnd; + sal_uInt16 nMode, nFormulaEnd; bool bCalcNewSize; public: - SwUndoSplitTbl( const SwTableNode& rTblNd, SwSaveRowSpan* pRowSp, + SwUndoSplitTable( const SwTableNode& rTableNd, SwSaveRowSpan* pRowSp, sal_uInt16 nMode, bool bCalcNewSize ); - virtual ~SwUndoSplitTbl(); + virtual ~SwUndoSplitTable(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RepeatImpl( ::sw::RepeatContext & ) SAL_OVERRIDE; - void SetTblNodeOffset( sal_uLong nIdx ) { nOffset = nIdx - nTblNode; } + void SetTableNodeOffset( sal_uLong nIdx ) { nOffset = nIdx - nTableNode; } SwHistory* GetHistory() { return pHistory; } void SaveFormula( SwHistory& rHistory ); }; -class SwUndoMergeTbl : public SwUndo +class SwUndoMergeTable : public SwUndo { OUString aName; - sal_uLong nTblNode; - _SaveTable* pSavTbl, *pSavHdl; + sal_uLong nTableNode; + _SaveTable* pSavTable, *pSavHdl; SwHistory* pHistory; sal_uInt16 nMode; bool bWithPrev; public: - SwUndoMergeTbl( const SwTableNode& rTblNd, const SwTableNode& rDelTblNd, + SwUndoMergeTable( const SwTableNode& rTableNd, const SwTableNode& rDelTableNd, bool bWithPrev, sal_uInt16 nMode ); - virtual ~SwUndoMergeTbl(); + virtual ~SwUndoMergeTable(); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; @@ -359,14 +359,14 @@ public: void SaveFormula( SwHistory& rHistory ); }; -class SwUndoTblHeadline : public SwUndo +class SwUndoTableHeadline : public SwUndo { - sal_uLong nTblNd; + sal_uLong nTableNd; sal_uInt16 nOldHeadline; sal_uInt16 nNewHeadline; public: - SwUndoTblHeadline( const SwTable&, sal_uInt16 nOldHdl, sal_uInt16 nNewHdl ); + SwUndoTableHeadline( const SwTable&, sal_uInt16 nOldHdl, sal_uInt16 nNewHdl ); virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE; diff --git a/sw/source/core/inc/acorrect.hxx b/sw/source/core/inc/acorrect.hxx index 47870f03196b..1f6001822e7f 100644 --- a/sw/source/core/inc/acorrect.hxx +++ b/sw/source/core/inc/acorrect.hxx @@ -58,9 +58,9 @@ public: virtual ~SwAutoCorrDoc(); virtual bool Delete( sal_Int32 nStt, sal_Int32 nEnd ) SAL_OVERRIDE; - virtual bool Insert( sal_Int32 nPos, const OUString& rTxt ) SAL_OVERRIDE; - virtual bool Replace( sal_Int32 nPos, const OUString& rTxt ) SAL_OVERRIDE; - virtual bool ReplaceRange( sal_Int32 nPos, sal_Int32 nLen, const OUString& rTxt ) SAL_OVERRIDE; + virtual bool Insert( sal_Int32 nPos, const OUString& rText ) SAL_OVERRIDE; + virtual bool Replace( sal_Int32 nPos, const OUString& rText ) SAL_OVERRIDE; + virtual bool ReplaceRange( sal_Int32 nPos, sal_Int32 nLen, const OUString& rText ) SAL_OVERRIDE; virtual bool SetAttr( sal_Int32 nStt, sal_Int32 nEnd, sal_uInt16 nSlotId, SfxPoolItem& ) SAL_OVERRIDE; diff --git a/sw/source/core/inc/anchoredobjectposition.hxx b/sw/source/core/inc/anchoredobjectposition.hxx index d10b3bca9125..ec9617aa769a 100644 --- a/sw/source/core/inc/anchoredobjectposition.hxx +++ b/sw/source/core/inc/anchoredobjectposition.hxx @@ -27,11 +27,11 @@ class SdrObject; class SwFrm; class SwFlyFrm; class SwContact; -class SwFrmFmt; +class SwFrameFormat; class SwRect; class SvxLRSpaceItem; class SvxULSpaceItem; -class SwFmtHoriOrient; +class SwFormatHoriOrient; class SwAnchoredObject; namespace objectpositioning @@ -53,7 +53,7 @@ namespace objectpositioning // contact object SwContact* mpContact; // frame format - const SwFrmFmt* mpFrmFmt; + const SwFrameFormat* mpFrameFormat; // #i62875# bool mbFollowTextFlow; // #i62875# @@ -63,7 +63,7 @@ namespace objectpositioning /** determine information about object member <mbIsObjFly>, <mpAnchoredObj>, <mpAnchorFrm>, <mpContact> - and <mpFrmFmt> are set + and <mpFrameFormat> are set */ void _GetInfoAboutObj(); @@ -104,9 +104,9 @@ namespace objectpositioning { return *mpContact; } - inline const SwFrmFmt& GetFrmFmt() const + inline const SwFrameFormat& GetFrameFormat() const { - return *mpFrmFmt; + return *mpFrameFormat; } // #i62875# inline bool DoesObjFollowsTextFlow() const @@ -240,7 +240,7 @@ namespace objectpositioning */ SwTwips _CalcRelPosX( const SwFrm& _rHoriOrientFrm, const SwEnvironmentOfAnchoredObject& _rEnvOfObj, - const SwFmtHoriOrient& _rHoriOrient, + const SwFormatHoriOrient& _rHoriOrient, const SvxLRSpaceItem& _rLRSpacing, const SvxULSpaceItem& _rULSpacing, const bool _bObjWrapThrough, diff --git a/sw/source/core/inc/annotationmark.hxx b/sw/source/core/inc/annotationmark.hxx index 948ced6b19a8..8dc5508ba55d 100644 --- a/sw/source/core/inc/annotationmark.hxx +++ b/sw/source/core/inc/annotationmark.hxx @@ -23,7 +23,7 @@ #include <bookmrk.hxx> #include <rtl/ustring.hxx> -class SwFmtFld; +class SwFormatField; namespace sw { namespace mark { @@ -38,7 +38,7 @@ namespace sw { namespace mark virtual void InitDoc(SwDoc* const io_Doc) SAL_OVERRIDE; - const SwFmtFld* GetAnnotationFmtFld() const; + const SwFormatField* GetAnnotationFormatField() const; }; }} #endif diff --git a/sw/source/core/inc/ascharanchoredobjectposition.hxx b/sw/source/core/inc/ascharanchoredobjectposition.hxx index 0e6abccaf553..fee7518d58cb 100644 --- a/sw/source/core/inc/ascharanchoredobjectposition.hxx +++ b/sw/source/core/inc/ascharanchoredobjectposition.hxx @@ -25,8 +25,8 @@ #include <swtypes.hxx> #include <swrect.hxx> -class SwTxtFrm; -class SwFmtVertOrient; +class SwTextFrm; +class SwFormatVertOrient; namespace objectpositioning { @@ -70,7 +70,7 @@ namespace objectpositioning sal_uInt8 mnLineAlignment; // method to cast <SwAnchoredObjectPosition::GetAnchorFrm()> - const SwTxtFrm& GetAnchorTxtFrm() const; + const SwTextFrm& GetAnchorTextFrm() const; /** determine the relative position to base line for object position @@ -84,7 +84,7 @@ namespace objectpositioning @return relative position to the base line */ SwTwips _GetRelPosToBase( const SwTwips _nObjBoundHeight, - const SwFmtVertOrient& _rVert ); + const SwFormatVertOrient& _rVert ); public: /** construtor; provided object to be positioned and needed data diff --git a/sw/source/core/inc/blink.hxx b/sw/source/core/inc/blink.hxx index 95316316ba1f..2c3a74e05099 100644 --- a/sw/source/core/inc/blink.hxx +++ b/sw/source/core/inc/blink.hxx @@ -22,7 +22,7 @@ class SwLinePortion; class SwRootFrm; -class SwTxtFrm; +class SwTextFrm; #include <vcl/timer.hxx> #include <tools/gen.hxx> @@ -76,7 +76,7 @@ public: DECL_LINK_TYPED( Blinker, Timer *, void ); void Insert( const Point& rPoint, const SwLinePortion* pPor, - const SwTxtFrm *pTxtFrm, sal_uInt16 nDir ); + const SwTextFrm *pTextFrm, sal_uInt16 nDir ); void Replace( const SwLinePortion* pOld, const SwLinePortion* pNew ); void Delete( const SwLinePortion* pPor ); void FrmDelete( const SwRootFrm* pRoot ); diff --git a/sw/source/core/inc/bodyfrm.hxx b/sw/source/core/inc/bodyfrm.hxx index da73d4f1dce1..5e3e0bee51e4 100644 --- a/sw/source/core/inc/bodyfrm.hxx +++ b/sw/source/core/inc/bodyfrm.hxx @@ -30,7 +30,7 @@ protected: virtual void Format( const SwBorderAttrs *pAttrs = 0 ) SAL_OVERRIDE; public: - SwBodyFrm( SwFrmFmt*, SwFrm* ); + SwBodyFrm( SwFrameFormat*, SwFrm* ); virtual void PaintSubsidiaryLines( const SwPageFrm*, const SwRect& ) const SAL_OVERRIDE; diff --git a/sw/source/core/inc/cntfrm.hxx b/sw/source/core/inc/cntfrm.hxx index ed32b8b13ac9..94a597a233ae 100644 --- a/sw/source/core/inc/cntfrm.hxx +++ b/sw/source/core/inc/cntfrm.hxx @@ -26,15 +26,15 @@ #include "node.hxx" class SwLayoutFrm; -class SwCntntNode; +class SwContentNode; class SwBorderAttrs; class SwAttrSetChg; -class SwTxtFrm; +class SwTextFrm; // implemented in cntfrm.cxx, used in cntfrm.cxx and crsrsh.cxx -extern bool GetFrmInPage( const SwCntntFrm*, SwWhichPage, SwPosPage, SwPaM* ); +extern bool GetFrmInPage( const SwContentFrm*, SwWhichPage, SwPosPage, SwPaM* ); -class SwCntntFrm: public SwFrm, public SwFlowFrm +class SwContentFrm: public SwFrm, public SwFlowFrm { friend void MakeNxt( SwFrm *pFrm, SwFrm *pNxt ); // calls MakePrtArea @@ -52,7 +52,7 @@ class SwCntntFrm: public SwFrm, public SwFlowFrm virtual bool ShouldBwdMoved( SwLayoutFrm *pNewUpper, bool, bool& ) SAL_OVERRIDE; - const SwCntntFrm* ImplGetNextCntntFrm( bool bFwd ) const; + const SwContentFrm* ImplGetNextContentFrm( bool bFwd ) const; protected: bool MakePrtArea( const SwBorderAttrs & ); @@ -61,10 +61,10 @@ protected: virtual SwTwips ShrinkFrm( SwTwips, bool bTst = false, bool bInfo = false ) SAL_OVERRIDE; virtual SwTwips GrowFrm ( SwTwips, bool bTst = false, bool bInfo = false ) SAL_OVERRIDE; - SwCntntFrm( SwCntntNode * const, SwFrm* ); + SwContentFrm( SwContentNode * const, SwFrm* ); virtual void DestroyImpl() SAL_OVERRIDE; - virtual ~SwCntntFrm(); + virtual ~SwContentFrm(); public: TYPEINFO_OVERRIDE(); // already in base class @@ -72,15 +72,15 @@ public: virtual void Cut() SAL_OVERRIDE; virtual void Paste( SwFrm* pParent, SwFrm* pSibling = 0 ) SAL_OVERRIDE; - inline const SwCntntNode *GetNode() const; - inline SwCntntNode *GetNode(); + inline const SwContentNode *GetNode() const; + inline SwContentNode *GetNode(); sal_uInt16 GetSectionLevel(); - inline const SwCntntFrm *GetFollow() const; - inline SwCntntFrm *GetFollow(); - inline const SwCntntFrm *GetPrecede() const; - inline SwCntntFrm *GetPrecede(); - SwTxtFrm* FindMaster() const; + inline const SwContentFrm *GetFollow() const; + inline SwContentFrm *GetFollow(); + inline const SwContentFrm *GetPrecede() const; + inline SwContentFrm *GetPrecede(); + SwTextFrm* FindMaster() const; // layout dependent cursor travelling virtual bool LeftMargin( SwPaM * ) const; @@ -101,55 +101,55 @@ public: // bTst indicates that we are currently doing a test formatting virtual bool WouldFit( SwTwips &nMaxHeight, bool &bSplit, bool bTst ); - bool MoveFtnCntFwd( bool, SwFtnBossFrm* ); // called by MoveFwd if content + bool MoveFootnoteCntFwd( bool, SwFootnoteBossFrm* ); // called by MoveFwd if content - inline SwCntntFrm* GetNextCntntFrm() const; - inline SwCntntFrm* GetPrevCntntFrm() const; + inline SwContentFrm* GetNextContentFrm() const; + inline SwContentFrm* GetPrevContentFrm() const; static bool CalcLowers( SwLayoutFrm* pLay, const SwLayoutFrm* pDontLeave, long nBottom, bool bSkipRowSpanCells ); - void RegisterToNode( SwCntntNode& ); + void RegisterToNode( SwContentNode& ); }; -inline SwCntntFrm* SwCntntFrm::GetNextCntntFrm() const +inline SwContentFrm* SwContentFrm::GetNextContentFrm() const { - if ( GetNext() && GetNext()->IsCntntFrm() ) - return const_cast<SwCntntFrm*>(static_cast<const SwCntntFrm*>(GetNext())); + if ( GetNext() && GetNext()->IsContentFrm() ) + return const_cast<SwContentFrm*>(static_cast<const SwContentFrm*>(GetNext())); else - return const_cast<SwCntntFrm*>(ImplGetNextCntntFrm( true )); + return const_cast<SwContentFrm*>(ImplGetNextContentFrm( true )); } -inline SwCntntFrm* SwCntntFrm::GetPrevCntntFrm() const +inline SwContentFrm* SwContentFrm::GetPrevContentFrm() const { - if ( GetPrev() && GetPrev()->IsCntntFrm() ) - return const_cast<SwCntntFrm*>(static_cast<const SwCntntFrm*>(GetPrev())); + if ( GetPrev() && GetPrev()->IsContentFrm() ) + return const_cast<SwContentFrm*>(static_cast<const SwContentFrm*>(GetPrev())); else - return const_cast<SwCntntFrm*>(ImplGetNextCntntFrm( false )); + return const_cast<SwContentFrm*>(ImplGetNextContentFrm( false )); } -inline SwCntntNode *SwCntntFrm::GetNode() +inline SwContentNode *SwContentFrm::GetNode() { - return static_cast< SwCntntNode* >( GetDep() ); + return static_cast< SwContentNode* >( GetDep() ); } -inline const SwCntntNode *SwCntntFrm::GetNode() const +inline const SwContentNode *SwContentFrm::GetNode() const { - return static_cast< const SwCntntNode* >( GetDep() ); + return static_cast< const SwContentNode* >( GetDep() ); } -inline const SwCntntFrm *SwCntntFrm::GetFollow() const +inline const SwContentFrm *SwContentFrm::GetFollow() const { - return static_cast<const SwCntntFrm*>(SwFlowFrm::GetFollow()); + return static_cast<const SwContentFrm*>(SwFlowFrm::GetFollow()); } -inline SwCntntFrm *SwCntntFrm::GetFollow() +inline SwContentFrm *SwContentFrm::GetFollow() { - return static_cast<SwCntntFrm*>(SwFlowFrm::GetFollow()); + return static_cast<SwContentFrm*>(SwFlowFrm::GetFollow()); } -inline const SwCntntFrm *SwCntntFrm::GetPrecede() const +inline const SwContentFrm *SwContentFrm::GetPrecede() const { - return static_cast<const SwCntntFrm*>(SwFlowFrm::GetPrecede()); + return static_cast<const SwContentFrm*>(SwFlowFrm::GetPrecede()); } -inline SwCntntFrm *SwCntntFrm::GetPrecede() +inline SwContentFrm *SwContentFrm::GetPrecede() { - return static_cast<SwCntntFrm*>(SwFlowFrm::GetPrecede()); + return static_cast<SwContentFrm*>(SwFlowFrm::GetPrecede()); } #endif diff --git a/sw/source/core/inc/colfrm.hxx b/sw/source/core/inc/colfrm.hxx index 33036ba16a9e..1a22e394e16c 100644 --- a/sw/source/core/inc/colfrm.hxx +++ b/sw/source/core/inc/colfrm.hxx @@ -23,14 +23,14 @@ #include <tools/mempool.hxx> #include "ftnboss.hxx" -class SwColumnFrm: public SwFtnBossFrm +class SwColumnFrm: public SwFootnoteBossFrm { private: virtual void DestroyImpl() SAL_OVERRIDE; virtual ~SwColumnFrm(); public: - SwColumnFrm( SwFrmFmt*, SwFrm* ); + SwColumnFrm( SwFrameFormat*, SwFrm* ); virtual void PaintBreak() const SAL_OVERRIDE; virtual void PaintSubsidiaryLines( const SwPageFrm*, const SwRect& ) const SAL_OVERRIDE; diff --git a/sw/source/core/inc/dflyobj.hxx b/sw/source/core/inc/dflyobj.hxx index b1695955eb39..5a2c0d635ec0 100644 --- a/sw/source/core/inc/dflyobj.hxx +++ b/sw/source/core/inc/dflyobj.hxx @@ -24,7 +24,7 @@ #include <svx/svdovirt.hxx> class SwFlyFrm; -class SwFrmFmt; +class SwFrameFormat; class SdrObjMacroHitRec; const sal_uInt32 SWGInventor = sal_uInt32('S')*0x00000001 + @@ -108,8 +108,8 @@ public: virtual void Crop(const Point& rRef, const Fraction& xFact, const Fraction& yFact) SAL_OVERRIDE; virtual void addCropHandles(SdrHdlList& rTarget) const SAL_OVERRIDE; - const SwFrmFmt *GetFmt() const; - SwFrmFmt *GetFmt(); + const SwFrameFormat *GetFormat() const; + SwFrameFormat *GetFormat(); // methods to get pointers for the Fly SwFlyFrm* GetFlyFrm() { return pFlyFrm; } diff --git a/sw/source/core/inc/docedt.hxx b/sw/source/core/inc/docedt.hxx index 53ebea10c54c..6d88abb37cbd 100644 --- a/sw/source/core/inc/docedt.hxx +++ b/sw/source/core/inc/docedt.hxx @@ -22,7 +22,7 @@ bool sw_JoinText( SwPaM& rPam, bool bJoinPrev ); -void sw_GetJoinFlags( SwPaM& rPam, bool& rJoinTxt, bool& rJoinPrev ); +void sw_GetJoinFlags( SwPaM& rPam, bool& rJoinText, bool& rJoinPrev ); #endif diff --git a/sw/source/core/inc/docfld.hxx b/sw/source/core/inc/docfld.hxx index 1ac37eabae4e..b0bd4c3d0396 100644 --- a/sw/source/core/inc/docfld.hxx +++ b/sw/source/core/inc/docfld.hxx @@ -25,92 +25,92 @@ #include <IDocumentTimerAccess.hxx> #include <o3tl/sorted_vector.hxx> -class SwTxtFld; +class SwTextField; class SwIndex; class SwNodeIndex; -class SwCntntFrm; +class SwContentFrm; class SwSectionNode; class SwSection; -class SwTxtTOXMark; +class SwTextTOXMark; class SwTableBox; -class SwTxtINetFmt; -class SwFlyFrmFmt; +class SwTextINetFormat; +class SwFlyFrameFormat; class SwDoc; class SwNode; struct SwPosition; // Update expression fields -class _SetGetExpFld +class _SetGetExpField { sal_uLong nNode; - sal_Int32 nCntnt; + sal_Int32 nContent; union { - const SwTxtFld* pTxtFld; + const SwTextField* pTextField; const SwSection* pSection; const SwPosition* pPos; - const SwTxtTOXMark* pTxtTOX; + const SwTextTOXMark* pTextTOX; const SwTableBox* pTBox; - const SwTxtINetFmt* pTxtINet; - const SwFlyFrmFmt* pFlyFmt; + const SwTextINetFormat* pTextINet; + const SwFlyFrameFormat* pFlyFormat; } CNTNT; - enum _SetGetExpFldType + enum _SetGetExpFieldType { TEXTFIELD, TEXTTOXMARK, SECTIONNODE, CRSRPOS, TABLEBOX, TEXTINET, FLYFRAME - } eSetGetExpFldType; + } eSetGetExpFieldType; public: - _SetGetExpFld( const SwNodeIndex& rNdIdx, const SwTxtFld* pFld = 0, + _SetGetExpField( const SwNodeIndex& rNdIdx, const SwTextField* pField = 0, const SwIndex* pIdx = 0 ); - _SetGetExpFld( const SwNodeIndex& rNdIdx, const SwTxtINetFmt& rINet, + _SetGetExpField( const SwNodeIndex& rNdIdx, const SwTextINetFormat& rINet, const SwIndex* pIdx = 0 ); - _SetGetExpFld( const SwSectionNode& rSectNode, + _SetGetExpField( const SwSectionNode& rSectNode, const SwPosition* pPos = 0 ); - _SetGetExpFld( const SwTableBox& rTableBox, + _SetGetExpField( const SwTableBox& rTableBox, const SwPosition* pPos = 0 ); - _SetGetExpFld( const SwNodeIndex& rNdIdx, const SwTxtTOXMark& rTOX, + _SetGetExpField( const SwNodeIndex& rNdIdx, const SwTextTOXMark& rTOX, const SwIndex* pIdx ); - _SetGetExpFld( const SwPosition& rPos ); + _SetGetExpField( const SwPosition& rPos ); - _SetGetExpFld( const SwFlyFrmFmt& rFlyFmt, const SwPosition* pPos = 0 ); + _SetGetExpField( const SwFlyFrameFormat& rFlyFormat, const SwPosition* pPos = 0 ); - bool operator==( const _SetGetExpFld& rFld ) const; - bool operator<( const _SetGetExpFld& rFld ) const; + bool operator==( const _SetGetExpField& rField ) const; + bool operator<( const _SetGetExpField& rField ) const; - const SwTxtFld* GetTxtFld() const - { return TEXTFIELD == eSetGetExpFldType ? CNTNT.pTxtFld : 0; } - const SwTxtTOXMark* GetTOX() const - { return TEXTTOXMARK == eSetGetExpFldType ? CNTNT.pTxtTOX : 0; } + const SwTextField* GetTextField() const + { return TEXTFIELD == eSetGetExpFieldType ? CNTNT.pTextField : 0; } + const SwTextTOXMark* GetTOX() const + { return TEXTTOXMARK == eSetGetExpFieldType ? CNTNT.pTextTOX : 0; } const SwSection* GetSection() const - { return SECTIONNODE == eSetGetExpFldType ? CNTNT.pSection : 0; } + { return SECTIONNODE == eSetGetExpFieldType ? CNTNT.pSection : 0; } const SwTableBox* GetTableBox() const - { return TABLEBOX == eSetGetExpFldType ? CNTNT.pTBox : 0; } - const SwTxtINetFmt* GetINetFmt() const - { return TEXTINET == eSetGetExpFldType ? CNTNT.pTxtINet : 0; } - const SwFlyFrmFmt* GetFlyFmt() const - { return FLYFRAME == eSetGetExpFldType ? CNTNT.pFlyFmt : 0; } + { return TABLEBOX == eSetGetExpFieldType ? CNTNT.pTBox : 0; } + const SwTextINetFormat* GetINetFormat() const + { return TEXTINET == eSetGetExpFieldType ? CNTNT.pTextINet : 0; } + const SwFlyFrameFormat* GetFlyFormat() const + { return FLYFRAME == eSetGetExpFieldType ? CNTNT.pFlyFormat : 0; } sal_uLong GetNode() const { return nNode; } - sal_Int32 GetCntnt() const { return nCntnt; } - const void* GetPointer() const { return CNTNT.pTxtFld; } + sal_Int32 GetContent() const { return nContent; } + const void* GetPointer() const { return CNTNT.pTextField; } void GetPosOfContent( SwPosition& rPos ) const; - const SwNode* GetNodeFromCntnt() const; - sal_Int32 GetCntPosFromCntnt() const; + const SwNode* GetNodeFromContent() const; + sal_Int32 GetCntPosFromContent() const; - void SetBodyPos( const SwCntntFrm& rFrm ); + void SetBodyPos( const SwContentFrm& rFrm ); }; -class _SetGetExpFlds : public o3tl::sorted_vector<_SetGetExpFld*, o3tl::less_ptr_to<_SetGetExpFld> > +class _SetGetExpFields : public o3tl::sorted_vector<_SetGetExpField*, o3tl::less_ptr_to<_SetGetExpField> > { public: - ~_SetGetExpFlds() { DeleteAndDestroyAll(); } + ~_SetGetExpFields() { DeleteAndDestroyAll(); } }; // struct for saving strings from the SetExp's string fields @@ -120,59 +120,59 @@ struct _HashStr : public SwHash _HashStr( const OUString& rName, const OUString& rText, _HashStr* = 0 ); }; -struct SwCalcFldType : public SwHash +struct SwCalcFieldType : public SwHash { - const SwFieldType* pFldType; + const SwFieldType* pFieldType; - SwCalcFldType( const OUString& rStr, const SwFieldType* pFldTyp ) - : SwHash( rStr ), pFldType( pFldTyp ) + SwCalcFieldType( const OUString& rStr, const SwFieldType* pFieldTyp ) + : SwHash( rStr ), pFieldType( pFieldTyp ) {} }; // search for the string that was saved under rName in the hash table -OUString LookString( SwHash** ppTbl, sal_uInt16 nSize, const OUString& rName, +OUString LookString( SwHash** ppTable, sal_uInt16 nSize, const OUString& rName, sal_uInt16* pPos = 0 ); const int GETFLD_ALL = 3; // combine flags via OR const int GETFLD_CALC = 1; const int GETFLD_EXPAND = 2; -class SwDocUpdtFld +class SwDocUpdateField { - _SetGetExpFlds* pFldSortLst; // current field list for calculation - SwCalcFldType* aFldTypeTable[ TBLSZ ]; + _SetGetExpFields* pFieldSortLst; // current field list for calculation + SwCalcFieldType* aFieldTypeTable[ TBLSZ ]; sal_uLong nNodes; // if the node count is different - sal_uInt8 nFldLstGetMode; + sal_uInt8 nFieldLstGetMode; SwDoc* pDocument; - bool bInUpdateFlds : 1; // currently there is an UpdateFlds - bool bFldsDirty : 1; // some fields are invalid + bool bInUpdateFields : 1; // currently there is an UpdateFields + bool bFieldsDirty : 1; // some fields are invalid - void _MakeFldList( SwDoc& pDoc, int eGetMode ); - void GetBodyNode( const SwTxtFld& , sal_uInt16 nFldWhich ); + void _MakeFieldList( SwDoc& pDoc, int eGetMode ); + void GetBodyNode( const SwTextField& , sal_uInt16 nFieldWhich ); void GetBodyNode( const SwSectionNode&); public: - SwDocUpdtFld(SwDoc* pDocument); - ~SwDocUpdtFld(); + SwDocUpdateField(SwDoc* pDocument); + ~SwDocUpdateField(); - const _SetGetExpFlds* GetSortLst() const { return pFldSortLst; } + const _SetGetExpFields* GetSortLst() const { return pFieldSortLst; } - void MakeFldList( SwDoc& rDoc, bool bAll, int eGetMode ); + void MakeFieldList( SwDoc& rDoc, bool bAll, int eGetMode ); - void InsDelFldInFldLst( bool bIns, const SwTxtFld& rFld ); + void InsDelFieldInFieldLst( bool bIns, const SwTextField& rField ); - void InsertFldType( const SwFieldType& rType ); - void RemoveFldType( const SwFieldType& rType ); + void InsertFieldType( const SwFieldType& rType ); + void RemoveFieldType( const SwFieldType& rType ); - bool IsInUpdateFlds() const { return bInUpdateFlds; } - void SetInUpdateFlds( bool b ) { bInUpdateFlds = b; } + bool IsInUpdateFields() const { return bInUpdateFields; } + void SetInUpdateFields( bool b ) { bInUpdateFields = b; } - bool IsFieldsDirty() const { return bFldsDirty; } + bool IsFieldsDirty() const { return bFieldsDirty; } void SetFieldsDirty( bool b ) { - bFldsDirty = b; + bFieldsDirty = b; if (b) { @@ -180,7 +180,7 @@ public: } } - SwHash* const * GetFldTypeTable() const { return reinterpret_cast<SwHash* const *>(aFldTypeTable); } + SwHash* const * GetFieldTypeTable() const { return reinterpret_cast<SwHash* const *>(aFieldTypeTable); } }; #endif diff --git a/sw/source/core/inc/docsort.hxx b/sw/source/core/inc/docsort.hxx index b4e4ef338735..1dc937f72c90 100644 --- a/sw/source/core/inc/docsort.hxx +++ b/sw/source/core/inc/docsort.hxx @@ -91,13 +91,13 @@ private: }; // sort text -struct SwSortTxtElement : public SwSortElement +struct SwSortTextElement : public SwSortElement { sal_uLong nOrg; SwNodeIndex aPos; - SwSortTxtElement( const SwNodeIndex& rPos ); - virtual ~SwSortTxtElement(); + SwSortTextElement( const SwNodeIndex& rPos ); + virtual ~SwSortTextElement(); virtual OUString GetKey( sal_uInt16 nKey ) const SAL_OVERRIDE; }; diff --git a/sw/source/core/inc/doctxm.hxx b/sw/source/core/inc/doctxm.hxx index 158299734db3..e73764432ec0 100644 --- a/sw/source/core/inc/doctxm.hxx +++ b/sw/source/core/inc/doctxm.hxx @@ -26,8 +26,8 @@ class SwTOXInternational; class SwPageDesc; -class SwTxtNode; -class SwTxtFmtColl; +class SwTextNode; +class SwTextFormatColl; struct SwPosition; struct SwTOXSortTabBase; @@ -38,13 +38,13 @@ class SwTOXBaseSection : public SwTOXBase, public SwSection SwTOXSortTabBases aSortArr; void UpdateMarks( const SwTOXInternational& rIntl, - const SwTxtNode* pOwnChapterNode ); - void UpdateOutline( const SwTxtNode* pOwnChapterNode ); - void UpdateTemplate( const SwTxtNode* pOwnChapterNode ); - void UpdateCntnt( SwTOXElement eType, - const SwTxtNode* pOwnChapterNode ); - void UpdateTable( const SwTxtNode* pOwnChapterNode ); - void UpdateSequence( const SwTxtNode* pOwnChapterNode ); + const SwTextNode* pOwnChapterNode ); + void UpdateOutline( const SwTextNode* pOwnChapterNode ); + void UpdateTemplate( const SwTextNode* pOwnChapterNode ); + void UpdateContent( SwTOXElement eType, + const SwTextNode* pOwnChapterNode ); + void UpdateTable( const SwTextNode* pOwnChapterNode ); + void UpdateSequence( const SwTextNode* pOwnChapterNode ); void UpdateAuthorities( const SwTOXInternational& rIntl ); void UpdateAll(); @@ -61,7 +61,7 @@ class SwTOXBaseSection : public SwTOXBase, public SwSection const SwPageDesc* _pDefaultPageDesc ); // replace page num placeholder with actual page number - void _UpdatePageNum( SwTxtNode* pNd, + void _UpdatePageNum( SwTextNode* pNd, const std::vector<sal_uInt16>& rNums, const std::vector<SwPageDesc*>& rDescs, const std::vector<sal_uInt16>* pMainEntryNums, @@ -73,10 +73,10 @@ class SwTOXBaseSection : public SwTOXBase, public SwSection const Range& rRange ); // return text collection via name/ from format pool - SwTxtFmtColl* GetTxtFmtColl( sal_uInt16 nLevel ); + SwTextFormatColl* GetTextFormatColl( sal_uInt16 nLevel ); public: - SwTOXBaseSection(SwTOXBase const& rBase, SwSectionFmt & rFmt); + SwTOXBaseSection(SwTOXBase const& rBase, SwSectionFormat & rFormat); virtual ~SwTOXBaseSection(); // <_bNewTOX> : distinguish between the creation of a new table-of-content @@ -97,7 +97,7 @@ struct SwDefTOXBase_Impl SwTOXBase* pContBase; SwTOXBase* pIdxBase; SwTOXBase* pUserBase; - SwTOXBase* pTblBase; + SwTOXBase* pTableBase; SwTOXBase* pObjBase; SwTOXBase* pIllBase; SwTOXBase* pAuthBase; @@ -107,7 +107,7 @@ struct SwDefTOXBase_Impl pContBase(0), pIdxBase(0), pUserBase(0), - pTblBase(0), + pTableBase(0), pObjBase(0), pIllBase(0), pAuthBase(0), @@ -119,7 +119,7 @@ struct SwDefTOXBase_Impl delete pContBase; delete pIdxBase; delete pUserBase; - delete pTblBase; + delete pTableBase; delete pObjBase; delete pIllBase; delete pAuthBase; diff --git a/sw/source/core/inc/drawfont.hxx b/sw/source/core/inc/drawfont.hxx index 7b7c57b17caf..83bf4d661d4e 100644 --- a/sw/source/core/inc/drawfont.hxx +++ b/sw/source/core/inc/drawfont.hxx @@ -25,7 +25,7 @@ #include <vcl/vclptr.hxx> #include <vcl/outdev.hxx> -class SwTxtFrm; +class SwTextFrm; class SwViewShell; class SwScriptInfo; class Point; @@ -42,7 +42,7 @@ class SwUnderlineFont; // encapsulates information for drawing text class SwDrawTextInfo { - const SwTxtFrm* pFrm; + const SwTextFrm* pFrm; VclPtr<OutputDevice> pOut; SwViewShell const * pSh; const SwScriptInfo* pScriptInfo; @@ -162,12 +162,12 @@ public: #endif } - const SwTxtFrm* GetFrm() const + const SwTextFrm* GetFrm() const { return pFrm; } - void SetFrm( const SwTxtFrm* pNewFrm ) + void SetFrm( const SwTextFrm* pNewFrm ) { pFrm = pNewFrm; } diff --git a/sw/source/core/inc/flowfrm.hxx b/sw/source/core/inc/flowfrm.hxx index 4d2791095f87..6421a9efc6bd 100644 --- a/sw/source/core/inc/flowfrm.hxx +++ b/sw/source/core/inc/flowfrm.hxx @@ -28,11 +28,11 @@ class SwBorderAttrs; class SwDoc; class SwNodeIndex; // #i44049# -class SwObjectFormatterTxtFrm; +class SwObjectFormatterTextFrm; /** Base class that provides the general functionalities for frames that are allowed at page breaks (flow) and shall continue on the next page (can be - split), e.g. paragraphs (CntntFrm) or tables (TabFrm). + split), e.g. paragraphs (ContentFrm) or tables (TabFrm). Some parts of these functionalities are implemented in FlowFrm while the specific ones are done in the corresponding Frm classes. The FlowFrm has to @@ -43,7 +43,7 @@ class SwObjectFormatterTxtFrm; FlowFrm that is virtually inherited from SwFrm and that works with its own member data. Further classes would need to inherit from FlowFrm and (via multiple base classes since the class tree splits exactly at the branch - from SwFrm to SwCntntFrm and SwLayoutFrm) also virtually from SwFrm as + from SwFrm to SwContentFrm and SwLayoutFrm) also virtually from SwFrm as well. Unfortunately, this leads - besides problems with compilers and debugging programs - to high additional costs, that we IMHO are not able to afford nowadays. @@ -61,10 +61,10 @@ class SwFlowFrm friend inline void TableSplitRecalcLock( SwFlowFrm * ); friend inline void TableSplitRecalcUnlock( SwFlowFrm * ); // #i44049# - friend class SwObjectFormatterTxtFrm; + friend class SwObjectFormatterTextFrm; friend class FlowFrmJoinLockGuard; - // TblSel is allowed to reset the follow-bit + // TableSel is allowed to reset the follow-bit friend inline void UnsetFollow( SwFlowFrm *pFlow ); friend void MakeFrms( SwDoc *, const SwNodeIndex &, const SwNodeIndex & ); @@ -121,8 +121,8 @@ protected: // checks if forward flow makes sense to prevent infinite moves inline bool IsFwdMoveAllowed(); - // #i44049# - method <CalcCntnt(..)> has to check this property. - friend void CalcCntnt( SwLayoutFrm *pLay, bool bNoColl, bool bNoCalcFollow ); + // #i44049# - method <CalcContent(..)> has to check this property. + friend void CalcContent( SwLayoutFrm *pLay, bool bNoColl, bool bNoCalcFollow ); bool IsKeepFwdMoveAllowed(); // like above, forward flow for Keep. /** method to determine overlapping of an object that requests floating diff --git a/sw/source/core/inc/flyfrm.hxx b/sw/source/core/inc/flyfrm.hxx index 27ccaa423727..df2edc411cad 100644 --- a/sw/source/core/inc/flyfrm.hxx +++ b/sw/source/core/inc/flyfrm.hxx @@ -25,15 +25,15 @@ #include "frmfmt.hxx" class SwPageFrm; -class SwFmtFrmSize; +class SwFormatFrmSize; struct SwCrsrMoveState; class SwBorderAttrs; class SwVirtFlyDrawObj; -class SwFrmFmts; +class SwFrameFormats; class SwAttrSetChg; namespace tools { class PolyPolygon; } class SwFlyDrawContact; -class SwFmt; +class SwFormat; #include <anchoredobject.hxx> @@ -44,7 +44,7 @@ class SwFmt; implemented in layout/flycnt.cxx */ -const SwCntntFrm *FindAnchor( const SwFrm *pOldAnch, const Point &rNew, +const SwContentFrm *FindAnchor( const SwFrm *pOldAnch, const Point &rNew, const bool bBody = false ); /** calculate rectangle in that the object can be moved or rather be resized */ @@ -57,7 +57,7 @@ bool CalcClipRect( const SdrObject *pSdrObj, SwRect &rRect, bool bMove = true ); class SwFlyFrm : public SwLayoutFrm, public SwAnchoredObject { // is allowed to lock, implemented in frmtool.cxx - friend void AppendObjs ( const SwFrmFmts *, sal_uLong, SwFrm *, SwPageFrm *, SwDoc* ); + friend void AppendObjs ( const SwFrameFormats *, sal_uLong, SwFrm *, SwPageFrm *, SwDoc* ); friend void Notify( SwFlyFrm *, SwPageFrm *pOld, const SwRect &rOld, const SwRect* pOldPrt ); @@ -77,7 +77,7 @@ protected: SwFlyFrm *pPrevLink, *pNextLink; private: - // It must be possible to block Cntnt-bound flys so that they will be not + // It must be possible to block Content-bound flys so that they will be not // formatted; in this case MakeAll() returns immediately. This is necessary // for page changes during formattting. In addition, it is needed during // the constructor call of the root object since otherwise the anchor will @@ -116,7 +116,7 @@ protected: // is moved to an invisible layer. bool bLockDeleteContent :1; - friend class SwNoTxtFrm; // is allowed to call NotifyBackground + friend class SwNoTextFrm; // is allowed to call NotifyBackground Point m_aContentPos; // content area's position relatively to Frm bool m_bValidContentPos; @@ -131,10 +131,10 @@ protected: void SetMinHeight() { bMinHeight = true; } void ResetMinHeight(){ bMinHeight = false; } - Size CalcRel( const SwFmtFrmSize &rSz ) const; + Size CalcRel( const SwFormatFrmSize &rSz ) const; SwTwips CalcAutoWidth() const; - SwFlyFrm( SwFlyFrmFmt*, SwFrm*, SwFrm *pAnchor ); + SwFlyFrm( SwFlyFrameFormat*, SwFrm*, SwFrm *pAnchor ); virtual void DestroyImpl() SAL_OVERRIDE; virtual ~SwFlyFrm(); @@ -178,7 +178,7 @@ public: SwTwips _Grow ( SwTwips, bool bTst ); void _Invalidate( SwPageFrm *pPage = 0 ); - bool FrmSizeChg( const SwFmtFrmSize & ); + bool FrmSizeChg( const SwFormatFrmSize & ); SwFlyFrm *GetPrevLink() const { return pPrevLink; } SwFlyFrm *GetNextLink() const { return pNextLink; } @@ -186,7 +186,7 @@ public: static void ChainFrames( SwFlyFrm *pMaster, SwFlyFrm *pFollow ); static void UnchainFrames( SwFlyFrm *pMaster, SwFlyFrm *pFollow ); - SwFlyFrm *FindChainNeighbour( SwFrmFmt &rFmt, SwFrm *pAnch = 0 ); + SwFlyFrm *FindChainNeighbour( SwFrameFormat &rFormat, SwFrm *pAnch = 0 ); // #i26791# const SwVirtFlyDrawObj* GetVirtDrawObj() const; @@ -255,8 +255,8 @@ public: virtual void MakeObjPos() SAL_OVERRIDE; virtual void InvalidateObjPos() SAL_OVERRIDE; - virtual SwFrmFmt& GetFrmFmt() SAL_OVERRIDE; - virtual const SwFrmFmt& GetFrmFmt() const SAL_OVERRIDE; + virtual SwFrameFormat& GetFrameFormat() SAL_OVERRIDE; + virtual const SwFrameFormat& GetFrameFormat() const SAL_OVERRIDE; virtual const SwRect GetObjRect() const SAL_OVERRIDE; @@ -268,13 +268,13 @@ public: format isn't possible, if Writer fly frame is locked resp. col-locked. */ virtual bool IsFormatPossible() const SAL_OVERRIDE; - static void GetAnchoredObjects( std::list<SwAnchoredObject*>&, const SwFmt& rFmt ); + static void GetAnchoredObjects( std::list<SwAnchoredObject*>&, const SwFormat& rFormat ); - // overwriting "SwFrmFmt *SwLayoutFrm::GetFmt" to provide the correct derived return type. + // overwriting "SwFrameFormat *SwLayoutFrm::GetFormat" to provide the correct derived return type. // (This is in order to skip on the otherwise necessary casting of the result to - // 'SwFlyFrmFmt *' after calls to this function. The casting is now done in this function.) - virtual const SwFlyFrmFmt *GetFmt() const SAL_OVERRIDE; - virtual SwFlyFrmFmt *GetFmt() SAL_OVERRIDE; + // 'SwFlyFrameFormat *' after calls to this function. The casting is now done in this function.) + virtual const SwFlyFrameFormat *GetFormat() const SAL_OVERRIDE; + virtual SwFlyFrameFormat *GetFormat() SAL_OVERRIDE; virtual void dumpAsXml( xmlTextWriterPtr writer ) const SAL_OVERRIDE { SwLayoutFrm::dumpAsXml( writer ); }; diff --git a/sw/source/core/inc/flyfrms.hxx b/sw/source/core/inc/flyfrms.hxx index 5a49cfb411c2..73dda04b1029 100644 --- a/sw/source/core/inc/flyfrms.hxx +++ b/sw/source/core/inc/flyfrms.hxx @@ -27,7 +27,7 @@ class SwFlyAtCntFrm; // Base class for those Flys that can "move freely" or better that are not -// bound in Cntnt. +// bound in Content. class SwFlyFreeFrm : public SwFlyFrm { SwPageFrm *pPage; // page where the Fly is registered @@ -42,7 +42,7 @@ class SwFlyFreeFrm : public SwFlyFrm SwRect maUnclippedFrm; - void CheckClip( const SwFmtFrmSize &rSz ); //'Emergency' Clipping. + void CheckClip( const SwFormatFrmSize &rSz ); //'Emergency' Clipping. /** determines, if direct environment of fly frame has 'auto' size @@ -62,7 +62,7 @@ protected: friend class SwFlyNotify; virtual void NotifyBackground( SwPageFrm *pPage, const SwRect& rRect, PrepareHint eHint) SAL_OVERRIDE; - SwFlyFreeFrm( SwFlyFrmFmt*, SwFrm*, SwFrm *pAnchor ); + SwFlyFreeFrm( SwFlyFrameFormat*, SwFrm*, SwFrm *pAnchor ); virtual void DestroyImpl() SAL_OVERRIDE; virtual ~SwFlyFreeFrm(); @@ -121,20 +121,20 @@ public: virtual bool IsFormatPossible() const SAL_OVERRIDE; }; -// Flys that are bound to LayoutFrms and not to Cntnt +// Flys that are bound to LayoutFrms and not to Content class SwFlyLayFrm : public SwFlyFreeFrm { public: // #i28701# TYPEINFO_OVERRIDE(); - SwFlyLayFrm( SwFlyFrmFmt*, SwFrm*, SwFrm *pAnchor ); + SwFlyLayFrm( SwFlyFrameFormat*, SwFrm*, SwFrm *pAnchor ); protected: virtual void Modify( const SfxPoolItem*, const SfxPoolItem* ) SAL_OVERRIDE; }; -// Flys that are bound to Cntnt but not in Cntnt +// Flys that are bound to Content but not in Content class SwFlyAtCntFrm : public SwFlyFreeFrm { protected: @@ -155,7 +155,7 @@ public: // #i28701# TYPEINFO_OVERRIDE(); - SwFlyAtCntFrm( SwFlyFrmFmt*, SwFrm*, SwFrm *pAnchor ); + SwFlyAtCntFrm( SwFlyFrameFormat*, SwFrm*, SwFrm *pAnchor ); void SetAbsPos( const Point &rNew ); @@ -172,13 +172,13 @@ public: virtual bool IsFormatPossible() const SAL_OVERRIDE; }; -// Flys that are bound to a character in Cntnt +// Flys that are bound to a character in Content class SwFlyInCntFrm : public SwFlyFrm { Point aRef; // relative to this point AbsPos is being calculated bool bInvalidLayout :1; - bool bInvalidCntnt :1; + bool bInvalidContent :1; virtual void DestroyImpl() SAL_OVERRIDE; virtual ~SwFlyInCntFrm(); @@ -193,7 +193,7 @@ public: // #i28701# TYPEINFO_OVERRIDE(); - SwFlyInCntFrm( SwFlyFrmFmt*, SwFrm*, SwFrm *pAnchor ); + SwFlyInCntFrm( SwFlyFrameFormat*, SwFrm*, SwFrm *pAnchor ); virtual void Format( const SwBorderAttrs *pAttrs = 0 ) SAL_OVERRIDE; @@ -203,12 +203,12 @@ public: const Point GetRelPos() const; inline void InvalidateLayout() const; - inline void InvalidateCntnt() const; + inline void InvalidateContent() const; inline void ValidateLayout() const; - inline void ValidateCntnt() const; - bool IsInvalid() const { return (bInvalidLayout || bInvalidCntnt); } + inline void ValidateContent() const; + bool IsInvalid() const { return (bInvalidLayout || bInvalidContent); } bool IsInvalidLayout() const { return bInvalidLayout; } - bool IsInvalidCntnt() const { return bInvalidCntnt; } + bool IsInvalidContent() const { return bInvalidContent; } // (26.11.93, see tabfrm.hxx, but might also be valid for others) // For creation of a Fly after a FlyCnt was created _and_ inserted. @@ -232,18 +232,18 @@ inline void SwFlyInCntFrm::InvalidateLayout() const { const_cast<SwFlyInCntFrm*>(this)->bInvalidLayout = true; } -inline void SwFlyInCntFrm::InvalidateCntnt() const +inline void SwFlyInCntFrm::InvalidateContent() const { - const_cast<SwFlyInCntFrm*>(this)->bInvalidCntnt = true; + const_cast<SwFlyInCntFrm*>(this)->bInvalidContent = true; } inline void SwFlyInCntFrm::ValidateLayout() const { const_cast<SwFlyInCntFrm*>(this)->bInvalidLayout = false; } -inline void SwFlyInCntFrm::ValidateCntnt() const +inline void SwFlyInCntFrm::ValidateContent() const { - const_cast<SwFlyInCntFrm*>(this)->bInvalidCntnt = false; + const_cast<SwFlyInCntFrm*>(this)->bInvalidContent = false; } #endif diff --git a/sw/source/core/inc/frame.hxx b/sw/source/core/inc/frame.hxx index 165a94e4ed21..0a23c88acc24 100644 --- a/sw/source/core/inc/frame.hxx +++ b/sw/source/core/inc/frame.hxx @@ -37,12 +37,12 @@ class SwRootFrm; class SwPageFrm; class SwFlyFrm; class SwSectionFrm; -class SwFtnFrm; -class SwFtnBossFrm; +class SwFootnoteFrm; +class SwFootnoteBossFrm; class SwTabFrm; class SwRowFrm; class SwFlowFrm; -class SwCntntFrm; +class SwContentFrm; class SfxPoolItem; class SwAttrSet; class SwViewShell; @@ -55,7 +55,7 @@ class XFillGradientItem; class SwSelectionList; struct SwPosition; struct SwCrsrMoveState; -class SwFmt; +class SwFormat; class SwPrintData; class SwSortedObjs; class SwAnchoredObject; @@ -221,18 +221,18 @@ class SwFrm: public SwClient, public SfxBroadcaster friend class SwLooping; // voids lower during creation of a column - friend SwFrm *SaveCntnt( SwLayoutFrm *, SwFrm* pStart ); - friend void RestoreCntnt( SwFrm *, SwLayoutFrm *, SwFrm *pSibling, bool bGrow ); + friend SwFrm *SaveContent( SwLayoutFrm *, SwFrm* pStart ); + friend void RestoreContent( SwFrm *, SwLayoutFrm *, SwFrm *pSibling, bool bGrow ); #ifdef DBG_UTIL // remove empty SwSectionFrms from a chain friend SwFrm* SwClearDummies( SwFrm* pFrm ); #endif - // for validating a mistakenly invalidated one in SwCntntFrm::MakeAll + // for validating a mistakenly invalidated one in SwContentFrm::MakeAll friend void ValidateSz( SwFrm *pFrm ); - // implemented in text/txtftn.cxx, prevents Ftn oscillation - friend void ValidateTxt( SwFrm *pFrm ); + // implemented in text/txtftn.cxx, prevents Footnote oscillation + friend void ValidateText( SwFrm *pFrm ); friend void MakeNxt( SwFrm *pFrm, SwFrm *pNxt ); @@ -269,20 +269,20 @@ class SwFrm: public SwClient, public SfxBroadcaster - Each group of linked fly frames - All footnotes - All document body frames - #i27138# - adding parameter <_bInSameFtn> + #i27138# - adding parameter <_bInSameFootnote> Its default value is <false>. If its value is <true>, the environment 'All footnotes' is no longer treated. Instead each footnote is treated as an own environment. - @param _bInSameFtn + @param _bInSameFootnote input parameter - boolean indicating, that the found next content frame has to be in the same footnote frame. This parameter is only relevant for flow frames in footnotes. - @return SwCntntFrm* + @return SwContentFrm* pointer to the found next content frame. It's NULL, if none exists. */ - SwCntntFrm* _FindNextCnt( const bool _bInSameFtn = false ); + SwContentFrm* _FindNextCnt( const bool _bInSameFootnote = false ); /** method to determine previous content frame in the same environment for a flow frame (content frame, table frame, section frame) @@ -298,20 +298,20 @@ class SwFrm: public SwClient, public SfxBroadcaster - Each group of linked fly frames - All footnotes - All document body frames - #i27138# - adding parameter <_bInSameFtn> + #i27138# - adding parameter <_bInSameFootnote> Its default value is <false>. If its value is <true>, the environment 'All footnotes' is no longer treated. Instead each footnote is treated as an own environment. - @param _bInSameFtn + @param _bInSameFootnote input parameter - boolean indicating, that the found previous content frame has to be in the same footnote frame. This parameter is only relevant for flow frames in footnotes. - @return SwCntntFrm* + @return SwContentFrm* pointer to the found previous content frame. It's NULL, if none exists. */ - SwCntntFrm* _FindPrevCnt( const bool _bInSameFtn = false ); + SwContentFrm* _FindPrevCnt( const bool _bInSameFootnote = false ); void _UpdateAttrFrm( const SfxPoolItem*, const SfxPoolItem*, sal_uInt8 & ); SwFrm* _GetIndNext(); @@ -344,7 +344,7 @@ protected: bool mbValidLineNum : 1; bool mbFixSize : 1; // if true, frame will be painted completely even content was changed - // only partially. For CntntFrms a border (from Action) will exclusively + // only partially. For ContentFrms a border (from Action) will exclusively // painted if <mbCompletePaint> is true. bool mbCompletePaint : 1; bool mbRetouche : 1; // frame is responsible for retouching @@ -353,7 +353,7 @@ protected: bool mbInfBody : 1; // Frm is in document body bool mbInfTab : 1; // Frm is in a table bool mbInfFly : 1; // Frm is in a Fly - bool mbInfFtn : 1; // Frm is in a footnote + bool mbInfFootnote : 1; // Frm is in a footnote bool mbInfSct : 1; // Frm is in a section bool mbColLocked : 1; // lock Grow/Shrink for column-wise section // or fly frames, will be set in Format @@ -369,14 +369,14 @@ protected: // Only used by SwRootFrm Ctor to get 'this' into mpRoot... void setRootFrm( SwRootFrm* pRoot ) { mpRoot = pRoot; } - SwPageFrm *InsertPage( SwPageFrm *pSibling, bool bFtn ); + SwPageFrm *InsertPage( SwPageFrm *pSibling, bool bFootnote ); void PrepareMake(); void OptPrepareMake(); void MakePos(); // Format next frame of table frame to assure keeping attributes. // In case of nested tables method <SwFrm::MakeAll()> is called to // avoid formatting of superior table frame. - friend SwFrm* sw_FormatNextCntntForKeep( SwTabFrm* pTabFrm ); + friend SwFrm* sw_FormatNextContentForKeep( SwTabFrm* pTabFrm ); virtual void MakeAll() = 0; // adjust frames of a page @@ -454,13 +454,13 @@ public: // Does special treatment for _Get[Next|Prev]Leaf() (for tables). SwLayoutFrm *GetLeaf( MakePageType eMakePage, bool bFwd ); SwLayoutFrm *GetNextLeaf ( MakePageType eMakePage ); - SwLayoutFrm *GetNextFtnLeaf( MakePageType eMakePage ); + SwLayoutFrm *GetNextFootnoteLeaf( MakePageType eMakePage ); SwLayoutFrm *GetNextSctLeaf( MakePageType eMakePage ); SwLayoutFrm *GetNextCellLeaf( MakePageType eMakePage ); - SwLayoutFrm *GetPrevLeaf ( MakePageType eMakeFtn = MAKEPAGE_FTN ); - SwLayoutFrm *GetPrevFtnLeaf( MakePageType eMakeFtn = MAKEPAGE_FTN ); - SwLayoutFrm *GetPrevSctLeaf( MakePageType eMakeFtn = MAKEPAGE_FTN ); - SwLayoutFrm *GetPrevCellLeaf( MakePageType eMakeFtn = MAKEPAGE_FTN ); + SwLayoutFrm *GetPrevLeaf ( MakePageType eMakeFootnote = MAKEPAGE_FTN ); + SwLayoutFrm *GetPrevFootnoteLeaf( MakePageType eMakeFootnote = MAKEPAGE_FTN ); + SwLayoutFrm *GetPrevSctLeaf( MakePageType eMakeFootnote = MAKEPAGE_FTN ); + SwLayoutFrm *GetPrevCellLeaf( MakePageType eMakeFootnote = MAKEPAGE_FTN ); const SwLayoutFrm *GetLeaf ( MakePageType eMakePage, bool bFwd, const SwFrm *pAnch ) const; @@ -482,12 +482,12 @@ public: virtual void PaintBorder( const SwRect&, const SwPageFrm *pPage, const SwBorderAttrs & ) const; void PaintBaBo( const SwRect&, const SwPageFrm *pPage = 0, - const bool bLowerBorder = false, const bool bOnlyTxtBackground = false ) const; + const bool bLowerBorder = false, const bool bOnlyTextBackground = false ) const; void PaintBackground( const SwRect&, const SwPageFrm *pPage, const SwBorderAttrs &, const bool bLowerMode = false, const bool bLowerBorder = false, - const bool bOnlyTxtBackground = false ) const; + const bool bOnlyTextBackground = false ) const; void PaintBorderLine( const SwRect&, const SwRect&, const SwPageFrm*, const Color *pColor, const editeng::SvxBorderStyle = ::com::sun::star::table::BorderLineStyle::SOLID ) const; @@ -517,7 +517,7 @@ public: void SetInfFlags(); inline void InvalidateInfFlags() { mbInfInvalid = true; } inline bool IsInDocBody() const; // use InfoFlags, determine flags - inline bool IsInFtn() const; // if necessary + inline bool IsInFootnote() const; // if necessary inline bool IsInTab() const; inline bool IsInFly() const; inline bool IsInSct() const; @@ -569,9 +569,9 @@ public: */ bool IsMoveable( const SwLayoutFrm* _pLayoutFrm = 0L ) const; - // Is it permitted for the (Txt)Frm to add a footnote in the current + // Is it permitted for the (Text)Frm to add a footnote in the current // environment (not e.g. for repeating table headlines) - bool IsFtnAllowed() const; + bool IsFootnoteAllowed() const; virtual void Format( const SwBorderAttrs *pAttrs = 0 ); @@ -595,9 +595,9 @@ public: SwPageFrm *FindPageFrm(); SwFrm *FindColFrm(); SwRowFrm *FindRowFrm(); - SwFtnBossFrm *FindFtnBossFrm( bool bFootnotes = false ); + SwFootnoteBossFrm *FindFootnoteBossFrm( bool bFootnotes = false ); SwTabFrm *ImplFindTabFrm(); - SwFtnFrm *ImplFindFtnFrm(); + SwFootnoteFrm *ImplFindFootnoteFrm(); SwFlyFrm *ImplFindFlyFrm(); SwSectionFrm *ImplFindSctFrm(); SwFrm *FindFooterOrHeader(); @@ -607,30 +607,30 @@ public: const SwLayoutFrm *GetUpper() const { return mpUpper; } const SwRootFrm *getRootFrm() const { return mpRoot; } inline SwTabFrm *FindTabFrm(); - inline SwFtnFrm *FindFtnFrm(); + inline SwFootnoteFrm *FindFootnoteFrm(); inline SwFlyFrm *FindFlyFrm(); inline SwSectionFrm *FindSctFrm(); inline SwFrm *FindNext(); - // #i27138# - add parameter <_bInSameFtn> - SwCntntFrm* FindNextCnt( const bool _bInSameFtn = false ); + // #i27138# - add parameter <_bInSameFootnote> + SwContentFrm* FindNextCnt( const bool _bInSameFootnote = false ); inline SwFrm *FindPrev(); inline const SwPageFrm *FindPageFrm() const; - inline const SwFtnBossFrm *FindFtnBossFrm( bool bFtn = false ) const; + inline const SwFootnoteBossFrm *FindFootnoteBossFrm( bool bFootnote = false ) const; inline const SwFrm *FindColFrm() const; inline const SwFrm *FindFooterOrHeader() const; inline const SwTabFrm *FindTabFrm() const; - inline const SwFtnFrm *FindFtnFrm() const; + inline const SwFootnoteFrm *FindFootnoteFrm() const; inline const SwFlyFrm *FindFlyFrm() const; inline const SwSectionFrm *FindSctFrm() const; inline const SwFrm *FindNext() const; - // #i27138# - add parameter <_bInSameFtn> - const SwCntntFrm* FindNextCnt( const bool _bInSameFtn = false ) const; + // #i27138# - add parameter <_bInSameFootnote> + const SwContentFrm* FindNextCnt( const bool _bInSameFootnote = false ) const; inline const SwFrm *FindPrev() const; const SwFrm *GetLower() const; - SwCntntFrm* FindPrevCnt( const bool _bInSameFtn = false ); + SwContentFrm* FindPrevCnt( const bool _bInSameFootnote = false ); - const SwCntntFrm* FindPrevCnt( const bool _bInSameFtn = false ) const; + const SwContentFrm* FindPrevCnt( const bool _bInSameFootnote = false ) const; // #i79774# SwFrm* _GetIndPrev() const; @@ -748,8 +748,8 @@ public: void ImplInvalidatePos(); void ImplInvalidateLineNum(); - inline void InvalidateNextPos( bool bNoFtn = false ); - void ImplInvalidateNextPos( bool bNoFtn = false ); + inline void InvalidateNextPos( bool bNoFootnote = false ); + void ImplInvalidateNextPos( bool bNoFootnote = false ); /** method to invalidate printing area of next frame #i11859# @@ -778,11 +778,11 @@ public: inline bool IsRootFrm() const; inline bool IsPageFrm() const; inline bool IsColumnFrm() const; - inline bool IsFtnBossFrm() const; // footnote bosses might be PageFrms or ColumnFrms + inline bool IsFootnoteBossFrm() const; // footnote bosses might be PageFrms or ColumnFrms inline bool IsHeaderFrm() const; inline bool IsFooterFrm() const; - inline bool IsFtnContFrm() const; - inline bool IsFtnFrm() const; + inline bool IsFootnoteContFrm() const; + inline bool IsFootnoteFrm() const; inline bool IsBodyFrm() const; inline bool IsColBodyFrm() const; // implemented in layfrm.hxx, BodyFrm above ColumnFrm inline bool IsPageBodyFrm() const; // implemented in layfrm.hxx, BodyFrm above PageFrm @@ -791,9 +791,9 @@ public: inline bool IsTabFrm() const; inline bool IsRowFrm() const; inline bool IsCellFrm() const; - inline bool IsCntntFrm() const; - inline bool IsTxtFrm() const; - inline bool IsNoTxtFrm() const; + inline bool IsContentFrm() const; + inline bool IsTextFrm() const; + inline bool IsNoTextFrm() const; // Frms where its PrtArea depends on their neighbors and that are // positioned in the content flow inline bool IsFlowFrm() const; @@ -856,8 +856,8 @@ public: bool IsInCoveredCell() const; // #i81146# new loop control - bool KnowsFormat( const SwFmt& rFmt ) const; - void RegisterToFormat( SwFmt& rFmt ); + bool KnowsFormat( const SwFormat& rFormat ) const; + void RegisterToFormat( SwFormat& rFormat ); void ValidateThisAndAllLowers( const sal_uInt16 nStage ); void ForbidDelete() { mbForbidDelete = true; } @@ -882,11 +882,11 @@ inline bool SwFrm::IsInDocBody() const const_cast<SwFrm*>(this)->SetInfFlags(); return mbInfBody; } -inline bool SwFrm::IsInFtn() const +inline bool SwFrm::IsInFootnote() const { if ( mbInfInvalid ) const_cast<SwFrm*>(this)->SetInfFlags(); - return mbInfFtn; + return mbInfFootnote; } inline bool SwFrm::IsInTab() const { @@ -990,12 +990,12 @@ inline void SwFrm::InvalidateAll() _ActionOnInvalidation( INVALID_ALL ); } } -inline void SwFrm::InvalidateNextPos( bool bNoFtn ) +inline void SwFrm::InvalidateNextPos( bool bNoFootnote ) { if ( mpNext && !mpNext->IsSctFrm() ) mpNext->InvalidatePos(); else - ImplInvalidateNextPos( bNoFtn ); + ImplInvalidateNextPos( bNoFootnote ); } inline void SwFrm::Calc() const @@ -1024,13 +1024,13 @@ inline SwTabFrm *SwFrm::FindTabFrm() { return IsInTab() ? ImplFindTabFrm() : 0; } -inline const SwFtnBossFrm *SwFrm::FindFtnBossFrm( bool bFtn ) const +inline const SwFootnoteBossFrm *SwFrm::FindFootnoteBossFrm( bool bFootnote ) const { - return const_cast<SwFrm*>(this)->FindFtnBossFrm( bFtn ); + return const_cast<SwFrm*>(this)->FindFootnoteBossFrm( bFootnote ); } -inline SwFtnFrm *SwFrm::FindFtnFrm() +inline SwFootnoteFrm *SwFrm::FindFootnoteFrm() { - return IsInFtn() ? ImplFindFtnFrm() : 0; + return IsInFootnote() ? ImplFindFootnoteFrm() : 0; } inline SwFlyFrm *SwFrm::FindFlyFrm() { @@ -1045,9 +1045,9 @@ inline const SwTabFrm *SwFrm::FindTabFrm() const { return IsInTab() ? const_cast<SwFrm*>(this)->ImplFindTabFrm() : 0; } -inline const SwFtnFrm *SwFrm::FindFtnFrm() const +inline const SwFootnoteFrm *SwFrm::FindFootnoteFrm() const { - return IsInFtn() ? const_cast<SwFrm*>(this)->ImplFindFtnFrm() : 0; + return IsInFootnote() ? const_cast<SwFrm*>(this)->ImplFindFootnoteFrm() : 0; } inline const SwFlyFrm *SwFrm::FindFlyFrm() const { @@ -1102,7 +1102,7 @@ inline bool SwFrm::IsColumnFrm() const { return mnFrmType == FRM_COLUMN; } -inline bool SwFrm::IsFtnBossFrm() const +inline bool SwFrm::IsFootnoteBossFrm() const { return (GetType() & FRM_FTNBOSS) != 0; } @@ -1114,11 +1114,11 @@ inline bool SwFrm::IsFooterFrm() const { return mnFrmType == FRM_FOOTER; } -inline bool SwFrm::IsFtnContFrm() const +inline bool SwFrm::IsFootnoteContFrm() const { return mnFrmType == FRM_FTNCONT; } -inline bool SwFrm::IsFtnFrm() const +inline bool SwFrm::IsFootnoteFrm() const { return mnFrmType == FRM_FTN; } @@ -1146,15 +1146,15 @@ inline bool SwFrm::IsCellFrm() const { return mnFrmType == FRM_CELL; } -inline bool SwFrm::IsCntntFrm() const +inline bool SwFrm::IsContentFrm() const { return (GetType() & FRM_CNTNT) != 0; } -inline bool SwFrm::IsTxtFrm() const +inline bool SwFrm::IsTextFrm() const { return mnFrmType == FRM_TXT; } -inline bool SwFrm::IsNoTxtFrm() const +inline bool SwFrm::IsNoTextFrm() const { return mnFrmType == FRM_NOTXT; } diff --git a/sw/source/core/inc/frminf.hxx b/sw/source/core/inc/frminf.hxx index 15aa7e908d93..13930343eb13 100644 --- a/sw/source/core/inc/frminf.hxx +++ b/sw/source/core/inc/frminf.hxx @@ -22,19 +22,19 @@ #include "swtypes.hxx" -class SwTxtFrm; +class SwTextFrm; class SwPaM; -class SwTxtCursor; +class SwTextCursor; -class SwTxtFrmInfo +class SwTextFrmInfo { - const SwTxtFrm *pFrm; + const SwTextFrm *pFrm; // Where does the text (w/o whitespaces) start (document is global!)? - static SwTwips GetLineStart( const SwTxtCursor &rLine ); + static SwTwips GetLineStart( const SwTextCursor &rLine ); public: - inline SwTxtFrmInfo( const SwTxtFrm *pTxtFrm ) : pFrm(pTxtFrm) { } + inline SwTextFrmInfo( const SwTextFrm *pTextFrm ) : pFrm(pTextFrm) { } // Does the paragraph fit into a single line? bool IsOneLine() const; @@ -52,18 +52,18 @@ public: void GetSpaces( SwPaM &rPam, bool bWithLineBreak ) const; // Is a bullet point/symbol/etc. at the first text position? - bool IsBullet( sal_Int32 nTxtPos ) const; + bool IsBullet( sal_Int32 nTextPos ) const; // determine intentation for first line SwTwips GetFirstIndent() const; - const SwTxtFrm* GetFrm() const { return pFrm; } - SwTxtFrmInfo& SetFrm( const SwTxtFrm* pNew ) + const SwTextFrm* GetFrm() const { return pFrm; } + SwTextFrmInfo& SetFrm( const SwTextFrm* pNew ) { pFrm = pNew; return *this; } // Is it a comparison? Returns position in frame. sal_Int32 GetBigIndent( sal_Int32& rFndPos, - const SwTxtFrm *pNextFrm = 0 ) const; + const SwTextFrm *pNextFrm = 0 ) const; }; #endif diff --git a/sw/source/core/inc/frmtool.hxx b/sw/source/core/inc/frmtool.hxx index f621acf6b524..cc86fdc6ebbc 100644 --- a/sw/source/core/inc/frmtool.hxx +++ b/sw/source/core/inc/frmtool.hxx @@ -30,7 +30,7 @@ class SwPageFrm; class SwFlyFrm; -class SwCntntFrm; +class SwContentFrm; class SwRootFrm; class SwDoc; class SwAttrSet; @@ -44,7 +44,7 @@ class OutputDevice; class GraphicObject; class GraphicAttr; class SwPageDesc; -class SwFrmFmts; +class SwFrameFormats; class SwRegionRects; #define FAR_AWAY LONG_MAX - 20000 // initial position of a Fly @@ -53,7 +53,7 @@ class SwRegionRects; #define GRFNUM_YES 1 #define GRFNUM_REPLACE 2 -void AppendObjs( const SwFrmFmts *pTbl, sal_uLong nIndex, +void AppendObjs( const SwFrameFormats *pTable, sal_uLong nIndex, SwFrm *pFrm, SwPageFrm *pPage, SwDoc* doc ); // draw background with brush or graphics @@ -102,10 +102,10 @@ void PaintCharacterBorder( // Implementation in feshview.cxx SwFlyFrm *GetFlyFromMarked( const SdrMarkList *pLst, SwViewShell *pSh ); -SwFrm *SaveCntnt( SwLayoutFrm *pLay, SwFrm *pStart = NULL ); -void RestoreCntnt( SwFrm *pSav, SwLayoutFrm *pParent, SwFrm *pSibling, bool bGrow ); +SwFrm *SaveContent( SwLayoutFrm *pLay, SwFrm *pStart = NULL ); +void RestoreContent( SwFrm *pSav, SwLayoutFrm *pParent, SwFrm *pSibling, bool bGrow ); -// Get CntntNodes, create CntntFrms, and add them to LayFrm. +// Get ContentNodes, create ContentFrms, and add them to LayFrm. void _InsertCnt( SwLayoutFrm *pLay, SwDoc *pDoc, sal_uLong nIndex, bool bPages = false, sal_uLong nEndIndex = 0, SwFrm *pPrv = 0 ); @@ -125,7 +125,7 @@ long CalcRowRstHeight( SwLayoutFrm *pRow ); long CalcHeightWithFlys( const SwFrm *pFrm ); SwPageFrm *InsertNewPage( SwPageDesc &rDesc, SwFrm *pUpper, - bool bOdd, bool bFirst, bool bInsertEmpty, bool bFtn, + bool bOdd, bool bFirst, bool bInsertEmpty, bool bFootnote, SwFrm *pSibling ); // connect Flys with page @@ -152,7 +152,7 @@ bool IsFrmInSameKontext( const SwFrm *pInnerFrm, const SwFrm *pFrm ); const SwFrm * FindPage( const SwRect &rRect, const SwFrm *pPage ); -// used by SwCntntNode::GetFrm and SwFlyFrm::GetFrm +// used by SwContentNode::GetFrm and SwFlyFrm::GetFrm SwFrm* GetFrmOfModify( const SwRootFrm* pLayout, SwModify const&, sal_uInt16 const nFrmType, @@ -163,8 +163,8 @@ SwFrm* GetFrmOfModify( const SwRootFrm* pLayout, // Should extra data (redline stroke, line numbers) be painted? bool IsExtraData( const SwDoc *pDoc ); -// #i11760# - method declaration <CalcCntnt(..)> -void CalcCntnt( SwLayoutFrm *pLay, +// #i11760# - method declaration <CalcContent(..)> +void CalcContent( SwLayoutFrm *pLay, bool bNoColl = false, bool bNoCalcFollow = false ); @@ -225,7 +225,7 @@ public: SwPageFrm *GetOldPage() const { return pOldPage; } }; -class SwCntntNotify : public SwFrmNotify +class SwContentNotify : public SwFrmNotify { private: // #i11859# @@ -236,11 +236,11 @@ private: bool mbInvalidatePrevPrtArea; bool mbBordersJoinedWithPrev; - SwCntntFrm *GetCnt(); + SwContentFrm *GetCnt(); public: - SwCntntNotify( SwCntntFrm *pCntFrm ); - ~SwCntntNotify(); + SwContentNotify( SwContentFrm *pCntFrm ); + ~SwContentNotify(); // #i25029# void SetInvalidatePrevPrtArea() @@ -545,7 +545,7 @@ void GetSpacingValuesOfFrm( const SwFrm& rFrm, pointer to the found content frame or 0 */ -const SwCntntFrm* GetCellCntnt( const SwLayoutFrm& rCell_ ); +const SwContentFrm* GetCellContent( const SwLayoutFrm& rCell_ ); /** helper class to check if a frame has been deleted during an operation * WARNING! This should only be used as a last and desperate means to make the diff --git a/sw/source/core/inc/ftnboss.hxx b/sw/source/core/inc/ftnboss.hxx index c8edcc2424b9..b5dcd15cbad6 100644 --- a/sw/source/core/inc/ftnboss.hxx +++ b/sw/source/core/inc/ftnboss.hxx @@ -22,21 +22,21 @@ #include "layfrm.hxx" -class SwFtnBossFrm; -class SwFtnContFrm; -class SwFtnFrm; -class SwTxtFtn; +class SwFootnoteBossFrm; +class SwFootnoteContFrm; +class SwFootnoteFrm; +class SwTextFootnote; // Set max. footnote area. // Restoration of the old value in DTor. Implementation in ftnfrm.cxx -class SwSaveFtnHeight +class SwSaveFootnoteHeight { - SwFtnBossFrm *pBoss; + SwFootnoteBossFrm *pBoss; const SwTwips nOldHeight; SwTwips nNewHeight; public: - SwSaveFtnHeight( SwFtnBossFrm *pBs, const SwTwips nDeadLine ); - ~SwSaveFtnHeight(); + SwSaveFootnoteHeight( SwFootnoteBossFrm *pBs, const SwTwips nDeadLine ); + ~SwSaveFootnoteHeight(); }; #define NA_ONLY_ADJUST 0 @@ -44,93 +44,93 @@ public: #define NA_GROW_ADJUST 2 #define NA_ADJUST_GROW 3 -typedef std::vector<SwFtnFrm*> SwFtnFrms; +typedef std::vector<SwFootnoteFrm*> SwFootnoteFrms; -class SwFtnBossFrm: public SwLayoutFrm +class SwFootnoteBossFrm: public SwLayoutFrm { // for private footnote operations friend class SwFrm; - friend class SwSaveFtnHeight; - friend class SwPageFrm; // for setting of MaxFtnHeight + friend class SwSaveFootnoteHeight; + friend class SwPageFrm; // for setting of MaxFootnoteHeight // max. height of the footnote container on this page - SwTwips nMaxFtnHeight; + SwTwips nMaxFootnoteHeight; - SwFtnContFrm *MakeFtnCont(); - SwFtnFrm *FindFirstFtn(); + SwFootnoteContFrm *MakeFootnoteCont(); + SwFootnoteFrm *FindFirstFootnote(); sal_uInt8 _NeighbourhoodAdjustment( const SwFrm* pFrm ) const; protected: - void InsertFtn( SwFtnFrm * ); - static void ResetFtn( const SwFtnFrm *pAssumed ); + void InsertFootnote( SwFootnoteFrm * ); + static void ResetFootnote( const SwFootnoteFrm *pAssumed ); public: - inline SwFtnBossFrm( SwFrmFmt* pFmt, SwFrm* pSib ) - : SwLayoutFrm( pFmt, pSib ) - , nMaxFtnHeight(0) + inline SwFootnoteBossFrm( SwFrameFormat* pFormat, SwFrm* pSib ) + : SwLayoutFrm( pFormat, pSib ) + , nMaxFootnoteHeight(0) {} SwLayoutFrm *FindBodyCont(); inline const SwLayoutFrm *FindBodyCont() const; - inline void SetMaxFtnHeight( const SwTwips nNewMax ) { nMaxFtnHeight = nNewMax; } + inline void SetMaxFootnoteHeight( const SwTwips nNewMax ) { nMaxFootnoteHeight = nNewMax; } // footnote interface - void AppendFtn( SwCntntFrm *, SwTxtFtn * ); - void RemoveFtn( const SwCntntFrm *, const SwTxtFtn *, bool bPrep = true ); - static SwFtnFrm *FindFtn( const SwCntntFrm *, const SwTxtFtn * ); - SwFtnContFrm *FindFtnCont(); - inline const SwFtnContFrm *FindFtnCont() const; - const SwFtnFrm *FindFirstFtn( SwCntntFrm* ) const; - SwFtnContFrm *FindNearestFtnCont( bool bDontLeave = false ); - - static void ChangeFtnRef( const SwCntntFrm *pOld, const SwTxtFtn *, - SwCntntFrm *pNew ); - void RearrangeFtns( const SwTwips nDeadLine, const bool bLock = false, - const SwTxtFtn *pAttr = 0 ); + void AppendFootnote( SwContentFrm *, SwTextFootnote * ); + void RemoveFootnote( const SwContentFrm *, const SwTextFootnote *, bool bPrep = true ); + static SwFootnoteFrm *FindFootnote( const SwContentFrm *, const SwTextFootnote * ); + SwFootnoteContFrm *FindFootnoteCont(); + inline const SwFootnoteContFrm *FindFootnoteCont() const; + const SwFootnoteFrm *FindFirstFootnote( SwContentFrm* ) const; + SwFootnoteContFrm *FindNearestFootnoteCont( bool bDontLeave = false ); + + static void ChangeFootnoteRef( const SwContentFrm *pOld, const SwTextFootnote *, + SwContentFrm *pNew ); + void RearrangeFootnotes( const SwTwips nDeadLine, const bool bLock = false, + const SwTextFootnote *pAttr = 0 ); // Set DeadLine (in document coordinates) so that the text formatter can // temporarily limit footnote height. - void SetFtnDeadLine( const SwTwips nDeadLine ); - SwTwips GetMaxFtnHeight() const { return nMaxFtnHeight; } + void SetFootnoteDeadLine( const SwTwips nDeadLine ); + SwTwips GetMaxFootnoteHeight() const { return nMaxFootnoteHeight; } // returns value for remaining space until the body reaches minimal height SwTwips GetVarSpace() const; // methods needed for layouting - // The parameters <_bCollectOnlyPreviousFtns> and <_pRefFtnBossFrm> control + // The parameters <_bCollectOnlyPreviousFootnotes> and <_pRefFootnoteBossFrm> control // if only footnotes that are positioned before the given reference // footnote boss-frame have to be collected. - // Note: if parameter <_bCollectOnlyPreviousFtns> is true, then parameter - // <_pRefFtnBossFrm> has to be referenced by an object. - static void _CollectFtns( const SwCntntFrm* _pRef, - SwFtnFrm* _pFtn, - SwFtnFrms& _rFtnArr, - const bool _bCollectOnlyPreviousFtns = false, - const SwFtnBossFrm* _pRefFtnBossFrm = NULL); - // The parameter <_bCollectOnlyPreviousFtns> controls if only footnotes + // Note: if parameter <_bCollectOnlyPreviousFootnotes> is true, then parameter + // <_pRefFootnoteBossFrm> has to be referenced by an object. + static void _CollectFootnotes( const SwContentFrm* _pRef, + SwFootnoteFrm* _pFootnote, + SwFootnoteFrms& _rFootnoteArr, + const bool _bCollectOnlyPreviousFootnotes = false, + const SwFootnoteBossFrm* _pRefFootnoteBossFrm = NULL); + // The parameter <_bCollectOnlyPreviousFootnotes> controls if only footnotes // that are positioned before the footnote boss-frame <this> have to be // collected. - void CollectFtns( const SwCntntFrm* _pRef, - SwFtnBossFrm* _pOld, - SwFtnFrms& _rFtnArr, - const bool _bCollectOnlyPreviousFtns = false ); - void _MoveFtns( SwFtnFrms &rFtnArr, bool bCalc = false ); - void MoveFtns( const SwCntntFrm *pSrc, SwCntntFrm *pDest, - SwTxtFtn *pAttr ); + void CollectFootnotes( const SwContentFrm* _pRef, + SwFootnoteBossFrm* _pOld, + SwFootnoteFrms& _rFootnoteArr, + const bool _bCollectOnlyPreviousFootnotes = false ); + void _MoveFootnotes( SwFootnoteFrms &rFootnoteArr, bool bCalc = false ); + void MoveFootnotes( const SwContentFrm *pSrc, SwContentFrm *pDest, + SwTextFootnote *pAttr ); // should AdjustNeighbourhood be called (or Grow/Shrink)? sal_uInt8 NeighbourhoodAdjustment( const SwFrm* pFrm ) const { return IsPageFrm() ? NA_ONLY_ADJUST : _NeighbourhoodAdjustment( pFrm ); } }; -inline const SwLayoutFrm *SwFtnBossFrm::FindBodyCont() const +inline const SwLayoutFrm *SwFootnoteBossFrm::FindBodyCont() const { - return const_cast<SwFtnBossFrm*>(this)->FindBodyCont(); + return const_cast<SwFootnoteBossFrm*>(this)->FindBodyCont(); } -inline const SwFtnContFrm *SwFtnBossFrm::FindFtnCont() const +inline const SwFootnoteContFrm *SwFootnoteBossFrm::FindFootnoteCont() const { - return const_cast<SwFtnBossFrm*>(this)->FindFtnCont(); + return const_cast<SwFootnoteBossFrm*>(this)->FindFootnoteCont(); } #endif diff --git a/sw/source/core/inc/ftnfrm.hxx b/sw/source/core/inc/ftnfrm.hxx index f50ffdc6fdb8..e9b2d3cb23f0 100644 --- a/sw/source/core/inc/ftnfrm.hxx +++ b/sw/source/core/inc/ftnfrm.hxx @@ -22,23 +22,23 @@ #include "layfrm.hxx" -class SwCntntFrm; -class SwTxtFtn; +class SwContentFrm; +class SwTextFootnote; class SwBorderAttrs; -class SwFtnFrm; +class SwFootnoteFrm; -void sw_RemoveFtns( SwFtnBossFrm* pBoss, bool bPageOnly, bool bEndNotes ); +void sw_RemoveFootnotes( SwFootnoteBossFrm* pBoss, bool bPageOnly, bool bEndNotes ); // There exists a special section on a page for footnotes. It's called -// SwFtnContFrm. Each footnote is separated by a SwFtnFrm which contains -// the paragraphs of a footnote. SwFtnFrm can be splitted and will then +// SwFootnoteContFrm. Each footnote is separated by a SwFootnoteFrm which contains +// the paragraphs of a footnote. SwFootnoteFrm can be splitted and will then // continue on another page. -class SwFtnContFrm: public SwLayoutFrm +class SwFootnoteContFrm: public SwLayoutFrm { public: - SwFtnContFrm( SwFrmFmt*, SwFrm* ); + SwFootnoteContFrm( SwFrameFormat*, SwFrm* ); - const SwFtnFrm* FindFootNote() const; + const SwFootnoteFrm* FindFootNote() const; virtual SwTwips ShrinkFrm( SwTwips, bool bTst = false, bool bInfo = false ) SAL_OVERRIDE; virtual SwTwips GrowFrm ( SwTwips, bool bTst = false, bool bInfo = false ) SAL_OVERRIDE; @@ -49,16 +49,16 @@ public: void PaintLine( const SwRect &, const SwPageFrm * ) const; }; -class SwFtnFrm: public SwLayoutFrm +class SwFootnoteFrm: public SwLayoutFrm { - // Pointer to FtnFrm in which the footnote will be continued: + // Pointer to FootnoteFrm in which the footnote will be continued: // - 0 no following existent // - this for the last one - // - otherwise the following FtnFrm - SwFtnFrm *pFollow; - SwFtnFrm *pMaster; // FtnFrm from which I am the following - SwCntntFrm *pRef; // in this CntntFrm is the footnote reference - SwTxtFtn *pAttr; // footnote attribute (for recognition) + // - otherwise the following FootnoteFrm + SwFootnoteFrm *pFollow; + SwFootnoteFrm *pMaster; // FootnoteFrm from which I am the following + SwContentFrm *pRef; // in this ContentFrm is the footnote reference + SwTextFootnote *pAttr; // footnote attribute (for recognition) // if true paragraphs in this footnote are NOT permitted to flow backwards bool bBackMoveLocked : 1; @@ -71,45 +71,45 @@ protected: #endif public: - SwFtnFrm( SwFrmFmt*, SwFrm*, SwCntntFrm*, SwTxtFtn* ); + SwFootnoteFrm( SwFrameFormat*, SwFrm*, SwContentFrm*, SwTextFootnote* ); virtual void Cut() SAL_OVERRIDE; virtual void Paste( SwFrm* pParent, SwFrm* pSibling = 0 ) SAL_OVERRIDE; virtual void PaintSubsidiaryLines( const SwPageFrm*, const SwRect& ) const SAL_OVERRIDE; - bool operator<( const SwTxtFtn* pTxtFtn ) const; + bool operator<( const SwTextFootnote* pTextFootnote ) const; #ifdef DBG_UTIL - const SwCntntFrm *GetRef() const; - SwCntntFrm *GetRef(); + const SwContentFrm *GetRef() const; + SwContentFrm *GetRef(); #else - const SwCntntFrm *GetRef() const { return pRef; } - SwCntntFrm *GetRef() { return pRef; } + const SwContentFrm *GetRef() const { return pRef; } + SwContentFrm *GetRef() { return pRef; } #endif - const SwCntntFrm *GetRefFromAttr() const; - SwCntntFrm *GetRefFromAttr(); + const SwContentFrm *GetRefFromAttr() const; + SwContentFrm *GetRefFromAttr(); - const SwFtnFrm *GetFollow() const { return pFollow; } - SwFtnFrm *GetFollow() { return pFollow; } + const SwFootnoteFrm *GetFollow() const { return pFollow; } + SwFootnoteFrm *GetFollow() { return pFollow; } - const SwFtnFrm *GetMaster() const { return pMaster; } - SwFtnFrm *GetMaster() { return pMaster; } + const SwFootnoteFrm *GetMaster() const { return pMaster; } + SwFootnoteFrm *GetMaster() { return pMaster; } - const SwTxtFtn *GetAttr() const { return pAttr; } - SwTxtFtn *GetAttr() { return pAttr; } + const SwTextFootnote *GetAttr() const { return pAttr; } + SwTextFootnote *GetAttr() { return pAttr; } - void SetFollow( SwFtnFrm *pNew ) { pFollow = pNew; } - void SetMaster( SwFtnFrm *pNew ) { pMaster = pNew; } - void SetRef ( SwCntntFrm *pNew ) { pRef = pNew; } + void SetFollow( SwFootnoteFrm *pNew ) { pFollow = pNew; } + void SetMaster( SwFootnoteFrm *pNew ) { pMaster = pNew; } + void SetRef ( SwContentFrm *pNew ) { pRef = pNew; } - void InvalidateNxtFtnCnts( SwPageFrm* pPage ); + void InvalidateNxtFootnoteCnts( SwPageFrm* pPage ); void LockBackMove() { bBackMoveLocked = true; } void UnlockBackMove() { bBackMoveLocked = false;} bool IsBackMoveLocked() { return bBackMoveLocked; } - // prevents that the last content deletes the SwFtnFrm as well (Cut()) + // prevents that the last content deletes the SwFootnoteFrm as well (Cut()) inline void ColLock() { mbColLocked = true; } inline void ColUnlock() { mbColLocked = false; } @@ -131,10 +131,10 @@ public: OD 2005-12-02 #i27138# - @return SwCntntFrm* + @return SwContentFrm* pointer to found last content frame. NULL, if none is found. */ - SwCntntFrm* FindLastCntnt(); + SwContentFrm* FindLastContent(); }; #endif diff --git a/sw/source/core/inc/hffrm.hxx b/sw/source/core/inc/hffrm.hxx index e9e30969ccd8..093c4666588e 100644 --- a/sw/source/core/inc/hffrm.hxx +++ b/sw/source/core/inc/hffrm.hxx @@ -31,7 +31,7 @@ protected: inline bool GetEatSpacing() const; // in hffrm.cxx public: - SwHeadFootFrm(SwFrmFmt * pFrm, SwFrm*, sal_uInt16 aType); + SwHeadFootFrm(SwFrameFormat * pFrm, SwFrm*, sal_uInt16 aType); virtual void Format( const SwBorderAttrs *pAttrs = 0 ) SAL_OVERRIDE; virtual SwTwips GrowFrm( SwTwips, bool bTst = false, bool bInfo = false ) SAL_OVERRIDE; @@ -44,7 +44,7 @@ public: class SwHeaderFrm: public SwHeadFootFrm { public: - SwHeaderFrm( SwFrmFmt* pFrm, SwFrm* pSib ) : SwHeadFootFrm(pFrm, pSib, FRM_HEADER) {}; + SwHeaderFrm( SwFrameFormat* pFrm, SwFrm* pSib ) : SwHeadFootFrm(pFrm, pSib, FRM_HEADER) {}; DECL_FIXEDMEMPOOL_NEWDEL(SwHeaderFrm) }; @@ -53,7 +53,7 @@ public: class SwFooterFrm: public SwHeadFootFrm { public: - SwFooterFrm( SwFrmFmt* pFrm, SwFrm* pSib ) : SwHeadFootFrm(pFrm, pSib, FRM_FOOTER) {}; + SwFooterFrm( SwFrameFormat* pFrm, SwFrm* pSib ) : SwHeadFootFrm(pFrm, pSib, FRM_FOOTER) {}; DECL_FIXEDMEMPOOL_NEWDEL(SwFooterFrm) }; diff --git a/sw/source/core/inc/layact.hxx b/sw/source/core/inc/layact.hxx index a08fec3dbdd4..697762729625 100644 --- a/sw/source/core/inc/layact.hxx +++ b/sw/source/core/inc/layact.hxx @@ -30,10 +30,10 @@ class SwRootFrm; class SwLayoutFrm; class SwPageFrm; class SwFlyFrm; -class SwCntntFrm; +class SwContentFrm; class SwTabFrm; class SwViewShellImp; -class SwCntntNode; +class SwContentNode; class SwWait; /** @@ -56,7 +56,7 @@ class SwLayAction // For the sake of optimization, so that the tables stick a bit better to // the Crsr when hitting return/backspace in front of one. // The first TabFrm that paints itself (per page) adds itself to the pointer. - // The CntntFrms beneath the page do not need to deregister at the Shell for + // The ContentFrms beneath the page do not need to deregister at the Shell for // painting. const SwTabFrm *pOptTab; @@ -84,31 +84,31 @@ class SwLayAction bool bIdle; // True if the LayAction was triggered by the Idler bool bReschedule; // Call Reschedule depending on Progress? bool bCheckPages; // Run CheckPageDescs() or delay it - bool bUpdateExpFlds; // Is set if, after Formatting, we need to do another round for ExpFld + bool bUpdateExpFields; // Is set if, after Formatting, we need to do another round for ExpField bool bBrowseActionStop; // Terminate Action early (as per bInput) and leave the rest to the Idler bool bWaitAllowed; // Waitcursor allowed? bool bPaintExtraData; // Painting line numbers (or similar) enabled? bool bActionInProgress; // Is set in Action() at the beginning and deleted at the end // OD 14.04.2003 #106346# - new flag for content formatting on interrupt. - bool mbFormatCntntOnInterrupt; + bool mbFormatContentOnInterrupt; - void PaintCntnt( const SwCntntFrm *, const SwPageFrm *, + void PaintContent( const SwContentFrm *, const SwPageFrm *, const SwRect &rOldRect, long nOldBottom ); - bool PaintWithoutFlys( const SwRect &, const SwCntntFrm *, + bool PaintWithoutFlys( const SwRect &, const SwContentFrm *, const SwPageFrm * ); - inline bool _PaintCntnt( const SwCntntFrm *, const SwPageFrm *, + inline bool _PaintContent( const SwContentFrm *, const SwPageFrm *, const SwRect & ); bool FormatLayout( SwLayoutFrm *, bool bAddRect = true ); bool FormatLayoutTab( SwTabFrm *, bool bAddRect = true ); - bool FormatCntnt( const SwPageFrm* pPage ); - void _FormatCntnt( const SwCntntFrm* pCntnt, + bool FormatContent( const SwPageFrm* pPage ); + void _FormatContent( const SwContentFrm* pContent, const SwPageFrm* pPage ); bool IsShortCut( SwPageFrm *& ); bool TurboAction(); - bool _TurboAction( const SwCntntFrm * ); + bool _TurboAction( const SwContentFrm * ); void InternalAction(); static SwPageFrm *CheckFirstVisPage( SwPageFrm *pPage ); @@ -149,7 +149,7 @@ public: void SetWaitAllowed ( bool bNew ) { bWaitAllowed = bNew; } void SetAgain() { bAgain = true; } - void SetUpdateExpFlds() {bUpdateExpFlds = true; } + void SetUpdateExpFields() {bUpdateExpFields = true; } inline void SetCheckPageNum( sal_uInt16 nNew ); inline void SetCheckPageNumDirect( sal_uInt16 nNew ) { nCheckPageNum = nNew; } @@ -159,7 +159,7 @@ public: bool IsAgain() const { return bAgain; } bool IsComplete() const { return bComplete; } - bool IsExpFlds() const { return bUpdateExpFlds; } + bool IsExpFields() const { return bUpdateExpFields; } bool IsCalcLayout() const { return bCalcLayout; } bool IsCheckPages() const { return bCheckPages; } bool IsBrowseActionStop() const { return bBrowseActionStop; } @@ -174,7 +174,7 @@ public: // delete 2nd parameter, because its not used; bool FormatLayoutFly( SwFlyFrm * ); // #i28701# - method is now public - bool _FormatFlyCntnt( const SwFlyFrm * ); + bool _FormatFlyContent( const SwFlyFrm * ); }; @@ -183,8 +183,8 @@ class SwLayIdle SwRootFrm *pRoot; SwViewShellImp *pImp; // The Idler registers and deregisters here - SwCntntNode *pCntntNode; // The current cursor position is saved here - sal_Int32 nTxtPos; + SwContentNode *pContentNode; // The current cursor position is saved here + sal_Int32 nTextPos; bool bPageValid; // Were we able to evaluate everything on the whole page? bool bAllValid; // Were we able to evaluate everything? @@ -197,7 +197,7 @@ class SwLayIdle #endif enum IdleJobType{ ONLINE_SPELLING, AUTOCOMPLETE_WORDS, WORD_COUNT, SMART_TAGS }; - bool _DoIdleJob( const SwCntntFrm*, IdleJobType ); + bool _DoIdleJob( const SwContentFrm*, IdleJobType ); bool DoIdleJob( IdleJobType, bool bVisAreaOnly ); public: diff --git a/sw/source/core/inc/layfrm.hxx b/sw/source/core/inc/layfrm.hxx index 599925f189f8..e61fbf718a69 100644 --- a/sw/source/core/inc/layfrm.hxx +++ b/sw/source/core/inc/layfrm.hxx @@ -22,13 +22,13 @@ #include "frame.hxx" class SwAnchoredObject; -class SwCntntFrm; +class SwContentFrm; class SwFlowFrm; -class SwFmtCol; +class SwFormatCol; struct SwCrsrMoveState; -class SwFrmFmt; +class SwFrameFormat; class SwBorderAttrs; -class SwFmtFrmSize; +class SwFormatFrmSize; class SwCellFrm; class SwLayoutFrm: public SwFrm @@ -38,8 +38,8 @@ class SwLayoutFrm: public SwFrm friend class SwFrm; // Releases the Lower while restructuring columns - friend SwFrm* SaveCntnt( SwLayoutFrm *, SwFrm * ); - friend void RestoreCntnt( SwFrm *, SwLayoutFrm *, SwFrm *pSibling, bool bGrow ); + friend SwFrm* SaveContent( SwLayoutFrm *, SwFrm * ); + friend void RestoreContent( SwFrm *, SwLayoutFrm *, SwFrm *pSibling, bool bGrow ); #ifdef DBG_UTIL //removes empty SwSectionFrms from a chain @@ -62,7 +62,7 @@ protected: virtual SwTwips ShrinkFrm( SwTwips, bool bTst = false, bool bInfo = false ) SAL_OVERRIDE; virtual SwTwips GrowFrm ( SwTwips, bool bTst = false, bool bInfo = false ) SAL_OVERRIDE; - long CalcRel( const SwFmtFrmSize &rSz, bool bWidth ) const; + long CalcRel( const SwFormatFrmSize &rSz, bool bWidth ) const; public: // --> #i28701# @@ -75,13 +75,13 @@ public: /// Change size of lowers proportionally void ChgLowersProp( const Size& rOldSize ); - void AdjustColumns( const SwFmtCol *pCol, bool bAdjustAttributes ); + void AdjustColumns( const SwFormatCol *pCol, bool bAdjustAttributes ); - void ChgColumns( const SwFmtCol &rOld, const SwFmtCol &rNew, - const bool bChgFtn = false ); + void ChgColumns( const SwFormatCol &rOld, const SwFormatCol &rNew, + const bool bChgFootnote = false ); /// Paints the column separation line for the inner columns - void PaintColLines( const SwRect &, const SwFmtCol &, + void PaintColLines( const SwRect &, const SwFormatCol &, const SwPageFrm * ) const; virtual bool FillSelection( SwSelectionList& rList, const SwRect& rRect ) const SAL_OVERRIDE; @@ -93,49 +93,49 @@ public: virtual void Paste( SwFrm* pParent, SwFrm* pSibling = 0 ) SAL_OVERRIDE; /** - * Finds the closest Cntnt for the SPoint + * Finds the closest Content for the SPoint * Is used for Pages, Flys and Cells if GetCrsrOfst failed */ - const SwCntntFrm* GetCntntPos( Point &rPoint, const bool bDontLeave, + const SwContentFrm* GetContentPos( Point &rPoint, const bool bDontLeave, const bool bBodyOnly = false, const bool bCalc = false, const SwCrsrMoveState *pCMS = 0, const bool bDefaultExpand = true ) const; - SwLayoutFrm( SwFrmFmt*, SwFrm* ); + SwLayoutFrm( SwFrameFormat*, SwFrm* ); virtual void Paint( SwRect const&, SwPrintData const*const pPrintData = NULL ) const SAL_OVERRIDE; const SwFrm *Lower() const { return m_pLower; } SwFrm *Lower() { return m_pLower; } - const SwCntntFrm *ContainsCntnt() const; - inline SwCntntFrm *ContainsCntnt(); + const SwContentFrm *ContainsContent() const; + inline SwContentFrm *ContainsContent(); const SwCellFrm *FirstCell() const; inline SwCellFrm *FirstCell(); /** * Method <ContainsAny()> doesn't investigate content of footnotes by default. * But under certain circumstances this investigation is intended. - * Thus, introduce new optional parameter <_bInvestigateFtnForSections>. + * Thus, introduce new optional parameter <_bInvestigateFootnoteForSections>. * It's default is <false>, still indicating that content of footnotes isn't * investigated for sections. */ - const SwFrm *ContainsAny( const bool _bInvestigateFtnForSections = false ) const; - inline SwFrm *ContainsAny( const bool _bInvestigateFtnForSections = false ); + const SwFrm *ContainsAny( const bool _bInvestigateFootnoteForSections = false ) const; + inline SwFrm *ContainsAny( const bool _bInvestigateFootnoteForSections = false ); bool IsAnLower( const SwFrm * ) const; - virtual const SwFrmFmt *GetFmt() const; - virtual SwFrmFmt *GetFmt(); - void SetFrmFmt( SwFrmFmt* ); + virtual const SwFrameFormat *GetFormat() const; + virtual SwFrameFormat *GetFormat(); + void SetFrameFormat( SwFrameFormat* ); /** - * Moving the Ftns of all Lowers - starting from StartCntnt + * Moving the Footnotes of all Lowers - starting from StartContent * - * @returns true if at least one Ftn was moved - * Calls the page number update if bFtnNums is set + * @returns true if at least one Footnote was moved + * Calls the page number update if bFootnoteNums is set */ - bool MoveLowerFtns( SwCntntFrm *pStart, SwFtnBossFrm *pOldBoss, - SwFtnBossFrm *pNewBoss, const bool bFtnNums ); + bool MoveLowerFootnotes( SwContentFrm *pStart, SwFootnoteBossFrm *pOldBoss, + SwFootnoteBossFrm *pNewBoss, const bool bFootnoteNums ); // --> #i28701# - change purpose of method and its name // --> #i44016# - add parameter <_bUnlockPosOfObjs> to @@ -196,9 +196,9 @@ public: * In order to save us from duplicating implementations, we cast here * a little. */ -inline SwCntntFrm* SwLayoutFrm::ContainsCntnt() +inline SwContentFrm* SwLayoutFrm::ContainsContent() { - return const_cast<SwCntntFrm*>(static_cast<const SwLayoutFrm*>(this)->ContainsCntnt()); + return const_cast<SwContentFrm*>(static_cast<const SwLayoutFrm*>(this)->ContainsContent()); } inline SwCellFrm* SwLayoutFrm::FirstCell() @@ -206,9 +206,9 @@ inline SwCellFrm* SwLayoutFrm::FirstCell() return const_cast<SwCellFrm*>(static_cast<const SwLayoutFrm*>(this)->FirstCell()); } -inline SwFrm* SwLayoutFrm::ContainsAny( const bool _bInvestigateFtnForSections ) +inline SwFrm* SwLayoutFrm::ContainsAny( const bool _bInvestigateFootnoteForSections ) { - return const_cast<SwFrm*>(static_cast<const SwLayoutFrm*>(this)->ContainsAny( _bInvestigateFtnForSections )); + return const_cast<SwFrm*>(static_cast<const SwLayoutFrm*>(this)->ContainsAny( _bInvestigateFootnoteForSections )); } /** diff --git a/sw/source/core/inc/layouter.hxx b/sw/source/core/inc/layouter.hxx index 54def9bac371..8fd42289273b 100644 --- a/sw/source/core/inc/layouter.hxx +++ b/sw/source/core/inc/layouter.hxx @@ -25,12 +25,12 @@ class SwEndnoter; class SwDoc; class SwSectionFrm; -class SwFtnFrm; +class SwFootnoteFrm; class SwPageFrm; class SwLooping; class SwMovedFwdFrmsByObjPos; -class SwTxtFrm; +class SwTextFrm; class SwRowFrm; class SwObjsMarkedAsTmpConsiderWrapInfluence; class SwAnchoredObject; @@ -96,28 +96,28 @@ public: SwLayouter(); ~SwLayouter(); void InsertEndnotes( SwSectionFrm* pSect ); - void CollectEndnote( SwFtnFrm* pFtn ); + void CollectEndnote( SwFootnoteFrm* pFootnote ); bool HasEndnotes() const; void LoopControl( SwPageFrm* pPage, sal_uInt8 nLoop ); void EndLoopControl(); - void LoopingLouieLight( const SwDoc& rDoc, const SwTxtFrm& rFrm ); + void LoopingLouieLight( const SwDoc& rDoc, const SwTextFrm& rFrm ); static void CollectEndnotes( SwDoc* pDoc, SwSectionFrm* pSect ); - static bool Collecting( SwDoc* pDoc, SwSectionFrm* pSect, SwFtnFrm* pFtn ); + static bool Collecting( SwDoc* pDoc, SwSectionFrm* pSect, SwFootnoteFrm* pFootnote ); static bool StartLoopControl( SwDoc* pDoc, SwPageFrm *pPage ); // --> #i28701# static void ClearMovedFwdFrms( const SwDoc& _rDoc ); static void InsertMovedFwdFrm( const SwDoc& _rDoc, - const SwTxtFrm& _rMovedFwdFrmByObjPos, + const SwTextFrm& _rMovedFwdFrmByObjPos, const sal_uInt32 _nToPageNum ); static bool FrmMovedFwdByObjPos( const SwDoc& _rDoc, - const SwTxtFrm& _rTxtFrm, + const SwTextFrm& _rTextFrm, sal_uInt32& _ornToPageNum ); // --> #i40155# - ummark given frame as to be moved forward. static void RemoveMovedFwdFrm( const SwDoc& _rDoc, - const SwTxtFrm& _rTxtFrm ); + const SwTextFrm& _rTextFrm ); // --> #i26945# static bool DoesRowContainMovedFwdFrm( const SwDoc& _rDoc, const SwRowFrm& _rRowFrm ); @@ -134,7 +134,7 @@ public: static void ClearMoveBwdLayoutInfo( const SwDoc& p_rDoc ); }; -extern void LOOPING_LOUIE_LIGHT( bool bCondition, const SwTxtFrm& rTxtFrm ); +extern void LOOPING_LOUIE_LIGHT( bool bCondition, const SwTextFrm& rTextFrm ); #endif // INCLUDED_SW_SOURCE_CORE_INC_LAYOUTER_HXX diff --git a/sw/source/core/inc/movedfwdfrmsbyobjpos.hxx b/sw/source/core/inc/movedfwdfrmsbyobjpos.hxx index c1d83d9f9e20..86b5afe70ced 100644 --- a/sw/source/core/inc/movedfwdfrmsbyobjpos.hxx +++ b/sw/source/core/inc/movedfwdfrmsbyobjpos.hxx @@ -22,13 +22,13 @@ #include <map> #include <sal/types.h> -class SwTxtNode; -class SwTxtFrm; +class SwTextNode; +class SwTextFrm; // --> #i26945# class SwRowFrm; -typedef std::map< const SwTxtNode*, const sal_uInt32 > NodeMap; -typedef std::map< const SwTxtNode*, const sal_uInt32 >::const_iterator NodeMapIter; +typedef std::map< const SwTextNode*, const sal_uInt32 > NodeMap; +typedef std::map< const SwTextNode*, const sal_uInt32 >::const_iterator NodeMapIter; typedef NodeMap::value_type NodeMapEntry; class SwMovedFwdFrmsByObjPos @@ -40,13 +40,13 @@ class SwMovedFwdFrmsByObjPos SwMovedFwdFrmsByObjPos(); ~SwMovedFwdFrmsByObjPos(); - void Insert( const SwTxtFrm& _rMovedFwdFrmByObjPos, + void Insert( const SwTextFrm& _rMovedFwdFrmByObjPos, const sal_uInt32 _nToPageNum ); // --> #i40155# - void Remove( const SwTxtFrm& _rTxtFrm ); + void Remove( const SwTextFrm& _rTextFrm ); - bool FrmMovedFwdByObjPos( const SwTxtFrm& _rTxtFrm, + bool FrmMovedFwdByObjPos( const SwTextFrm& _rTextFrm, sal_uInt32& _ornToPageNum ) const; // --> #i26945# diff --git a/sw/source/core/inc/mvsave.hxx b/sw/source/core/inc/mvsave.hxx index 412f2902852d..09d09ec1f737 100644 --- a/sw/source/core/inc/mvsave.hxx +++ b/sw/source/core/inc/mvsave.hxx @@ -30,8 +30,8 @@ namespace sfx2 { class SvNumberFormatter; class SwDoc; -class SwFmtAnchor; -class SwFrmFmt; +class SwFormatAnchor; +class SwFrameFormat; class SwIndex; class SwNodeIndex; class SwNodeRange; @@ -66,22 +66,22 @@ namespace sw { namespace mark IDocumentMarkAccess::MarkType m_eOrigBkmType; sal_uLong m_nNode1; sal_uLong m_nNode2; - sal_Int32 m_nCntnt1; - sal_Int32 m_nCntnt2; + sal_Int32 m_nContent1; + sal_Int32 m_nContent2; std::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndo; }; - /// Takes care of storing relevant attributes of an SwTxtNode before split, then restore them on the new node. - class CntntIdxStore + /// Takes care of storing relevant attributes of an SwTextNode before split, then restore them on the new node. + class ContentIdxStore { public: virtual void Clear() =0; virtual bool Empty() =0; - virtual void Save(SwDoc* pDoc, sal_uLong nNode, sal_Int32 nCntnt, bool bSaveFlySplit=false) =0; + virtual void Save(SwDoc* pDoc, sal_uLong nNode, sal_Int32 nContent, bool bSaveFlySplit=false) =0; virtual void Restore(SwDoc* pDoc, sal_uLong nNode, sal_Int32 nOffset=0, bool bAuto = false) =0; virtual void Restore(SwNode& rNd, sal_Int32 nLen, sal_Int32 nCorrLen) =0; - virtual ~CntntIdxStore() {}; - static std::shared_ptr<CntntIdxStore> Create(); + virtual ~ContentIdxStore() {}; + static std::shared_ptr<ContentIdxStore> Create(); }; }} @@ -96,11 +96,11 @@ void _DelBookmarks(const SwNodeIndex& rStt, struct _SaveFly { sal_uLong nNdDiff; /// relative node difference - SwFrmFmt* pFrmFmt; /// the fly's frame format + SwFrameFormat* pFrameFormat; /// the fly's frame format bool bInsertPosition; /// if true, anchor _at_ insert position - _SaveFly( sal_uLong nNodeDiff, SwFrmFmt* pFmt, bool bInsert ) - : nNdDiff( nNodeDiff ), pFrmFmt( pFmt ), bInsertPosition( bInsert ) + _SaveFly( sal_uLong nNodeDiff, SwFrameFormat* pFormat, bool bInsert ) + : nNdDiff( nNodeDiff ), pFrameFormat( pFormat ), bInsertPosition( bInsert ) { } }; @@ -121,7 +121,7 @@ class SwDataChanged const SwPosition* pPos; SwDoc* pDoc; sal_uLong nNode; - sal_Int32 nCntnt; + sal_Int32 nContent; public: SwDataChanged( const SwPaM& rPam ); @@ -129,7 +129,7 @@ public: ~SwDataChanged(); sal_uLong GetNode() const { return nNode; } - sal_Int32 GetCntnt() const { return nCntnt; } + sal_Int32 GetContent() const { return nContent; } }; /** @@ -151,16 +151,16 @@ void PaMCorrRel( const SwNodeIndex &rOldNode, */ class _ZSortFly { - const SwFrmFmt* pFmt; - const SwFmtAnchor* pAnchor; + const SwFrameFormat* pFormat; + const SwFormatAnchor* pAnchor; sal_uInt32 nOrdNum; public: - _ZSortFly( const SwFrmFmt* pFrmFmt, const SwFmtAnchor* pFlyAnchor, + _ZSortFly( const SwFrameFormat* pFrameFormat, const SwFormatAnchor* pFlyAnchor, sal_uInt32 nArrOrdNum ); _ZSortFly& operator=( const _ZSortFly& rCpy ) { - pFmt = rCpy.pFmt, pAnchor = rCpy.pAnchor, nOrdNum = rCpy.nOrdNum; + pFormat = rCpy.pFormat, pAnchor = rCpy.pAnchor, nOrdNum = rCpy.nOrdNum; return *this; } @@ -168,27 +168,27 @@ public: bool operator<( const _ZSortFly& rCmp ) const { return nOrdNum < rCmp.nOrdNum; } - const SwFrmFmt* GetFmt() const { return pFmt; } - const SwFmtAnchor* GetAnchor() const { return pAnchor; } + const SwFrameFormat* GetFormat() const { return pFormat; } + const SwFormatAnchor* GetAnchor() const { return pAnchor; } }; -class SwTblNumFmtMerge +class SwTableNumFormatMerge { - SvNumberFormatter* pNFmt; + SvNumberFormatter* pNFormat; public: - SwTblNumFmtMerge( const SwDoc& rSrc, SwDoc& rDest ); - ~SwTblNumFmtMerge(); + SwTableNumFormatMerge( const SwDoc& rSrc, SwDoc& rDest ); + ~SwTableNumFormatMerge(); }; class _SaveRedlEndPosForRestore { std::vector<SwPosition*>* pSavArr; SwNodeIndex* pSavIdx; - sal_Int32 nSavCntnt; + sal_Int32 nSavContent; void _Restore(); public: - _SaveRedlEndPosForRestore( const SwNodeIndex& rInsIdx, sal_Int32 nCntnt ); + _SaveRedlEndPosForRestore( const SwNodeIndex& rInsIdx, sal_Int32 nContent ); ~_SaveRedlEndPosForRestore(); void Restore() { if( pSavArr ) _Restore(); } }; diff --git a/sw/source/core/inc/notxtfrm.hxx b/sw/source/core/inc/notxtfrm.hxx index 04a670897aaa..12a91dd8f917 100644 --- a/sw/source/core/inc/notxtfrm.hxx +++ b/sw/source/core/inc/notxtfrm.hxx @@ -21,12 +21,12 @@ #include <cntfrm.hxx> -class SwNoTxtNode; +class SwNoTextNode; class OutputDevice; class SwBorderAttrs; struct SwCrsrMoveState; -class SwNoTxtFrm: public SwCntntFrm +class SwNoTextFrm: public SwContentFrm { friend void _FrmFinit(); @@ -38,13 +38,13 @@ class SwNoTxtFrm: public SwCntntFrm void PaintPicture( vcl::RenderContext*, const SwRect& ) const; virtual void DestroyImpl() SAL_OVERRIDE; - virtual ~SwNoTxtFrm(); + virtual ~SwNoTextFrm(); protected: virtual void MakeAll() SAL_OVERRIDE; virtual void Modify( const SfxPoolItem*, const SfxPoolItem* ) SAL_OVERRIDE; public: - SwNoTxtFrm( SwNoTxtNode * const, SwFrm* ); + SwNoTextFrm( SwNoTextNode * const, SwFrm* ); virtual void Paint( SwRect const&, SwPrintData const*const pPrintData = NULL ) const SAL_OVERRIDE; diff --git a/sw/source/core/inc/objectformatter.hxx b/sw/source/core/inc/objectformatter.hxx index f6967599f2c4..8580719d1ca4 100644 --- a/sw/source/core/inc/objectformatter.hxx +++ b/sw/source/core/inc/objectformatter.hxx @@ -23,7 +23,7 @@ class SwFrm; // #i26945# -class SwTxtFrm; +class SwTextFrm; class SwLayoutFrm; class SwPageFrm; class SwAnchoredObject; @@ -73,7 +73,7 @@ class SwObjectFormatter #i28701# */ - void _FormatObjCntnt( SwAnchoredObject& _rAnchoredObj ); + void _FormatObjContent( SwAnchoredObject& _rAnchoredObj ); protected: SwObjectFormatter( const SwPageFrm& _rPageFrm, @@ -129,10 +129,10 @@ class SwObjectFormatter Thus, the objects, whose anchor character is inside the follow text frame can be formatted. - @param _pMasterTxtFrm + @param _pMasterTextFrm input parameter - pointer to 'master' text frame. default value: NULL */ - bool _FormatObjsAtFrm( SwTxtFrm* _pMasterTxtFrm = 0L ); + bool _FormatObjsAtFrm( SwTextFrm* _pMasterTextFrm = 0L ); /** accessor to collected anchored object diff --git a/sw/source/core/inc/pagefrm.hxx b/sw/source/core/inc/pagefrm.hxx index 1f19ce7f6e44..1023beea9ac4 100644 --- a/sw/source/core/inc/pagefrm.hxx +++ b/sw/source/core/inc/pagefrm.hxx @@ -26,9 +26,9 @@ #include <SidebarWindowsTypes.hxx> class SwFlyFrm; -class SwFlyFrmFmt; +class SwFlyFrameFormat; class SwPageDesc; -class SwCntntFrm; +class SwContentFrm; struct SwPosition; struct SwCrsrMoveState; class SwAttrSetChg; @@ -44,7 +44,7 @@ enum SwPageChg }; /// A page of the document layout. -class SwPageFrm: public SwFtnBossFrm +class SwPageFrm: public SwFootnoteBossFrm { friend class SwFrm; @@ -54,12 +54,12 @@ class SwPageFrm: public SwFtnBossFrm sal_uInt16 nPhyPageNum; // Physical page number - bool bInvalidCntnt :1; + bool bInvalidContent :1; bool bInvalidLayout :1; - bool bInvalidFlyCntnt :1; + bool bInvalidFlyContent :1; bool bInvalidFlyLayout :1; bool bInvalidFlyInCnt :1; - bool bFtnPage :1; // This Page is for document end footnotes + bool bFootnotePage :1; // This Page is for document end footnotes bool bEmptyPage :1; // This Page is an explicitly empty page bool bEndNotePage :1; // 'Footnote page' for end notes bool bInvalidSpelling :1; // We need online spelling @@ -74,7 +74,7 @@ class SwPageFrm: public SwFtnBossFrm SwAttrSetChg *pa = 0, SwAttrSetChg *pb = 0 ); /// Adapt the max. footnote height in each single column - void SetColMaxFtnHeight(); + void SetColMaxFootnoteHeight(); /** determine rectangle for horizontal page shadow @@ -112,7 +112,7 @@ protected: public: DECL_FIXEDMEMPOOL_NEWDEL(SwPageFrm) - SwPageFrm( SwFrmFmt*, SwFrm*, SwPageDesc* ); + SwPageFrm( SwFrameFormat*, SwFrm*, SwPageDesc* ); /// Make this public, so that the SwViewShell can access it when switching from browse mode /// Add/remove header/footer @@ -129,28 +129,28 @@ public: void RemoveFlyFromPage( SwFlyFrm *pToRemove ); void MoveFly( SwFlyFrm *pToMove, SwPageFrm *pDest ); // Optimized Remove/Append - void SetPageDesc( SwPageDesc *, SwFrmFmt * ); + void SetPageDesc( SwPageDesc *, SwFrameFormat * ); SwPageDesc *GetPageDesc() { return pDesc; } const SwPageDesc *GetPageDesc() const { return pDesc; } SwPageDesc *FindPageDesc(); - SwCntntFrm *FindLastBodyCntnt(); - inline SwCntntFrm *FindFirstBodyCntnt(); - inline const SwCntntFrm *FindFirstBodyCntnt() const; - inline const SwCntntFrm *FindLastBodyCntnt() const; + SwContentFrm *FindLastBodyContent(); + inline SwContentFrm *FindFirstBodyContent(); + inline const SwContentFrm *FindFirstBodyContent() const; + inline const SwContentFrm *FindLastBodyContent() const; SwRect GetBoundRect() const; - // Specialized GetCntntPos() for Field in Frames - void GetCntntPosition( const Point &rPt, SwPosition &rPos ) const; + // Specialized GetContentPos() for Field in Frames + void GetContentPosition( const Point &rPt, SwPosition &rPos ) const; bool IsEmptyPage() const { return bEmptyPage; } // Explicitly empty page - void UpdateFtnNum(); + void UpdateFootnoteNum(); /// Always call after Paste /// Creates the page-bound frames and formats the generic content - void PreparePage( bool bFtn ); + void PreparePage( bool bFootnote ); // Sends a Prepare() to all ContentFrames caused by a changed register template void PrepareRegisterChg(); @@ -158,10 +158,10 @@ public: // Appends a fly frame - the given one or a new one - at the page frame. // Needed for <Modify> and <MakeFrms> // - return value not needed any more - // - second parameter is of type <SwFlyFrmFmt*> + // - second parameter is of type <SwFlyFrameFormat*> // - third parameter only needed for assertion, but calling method assures // this assertion. Thus, delete it. - void PlaceFly( SwFlyFrm* pFly, SwFlyFrmFmt* pFmt ); + void PlaceFly( SwFlyFrm* pFly, SwFlyFrameFormat* pFormat ); virtual bool GetCrsrOfst( SwPosition *, Point&, SwCrsrMoveState* = 0, bool bTestBackground = false ) const SAL_OVERRIDE; @@ -186,9 +186,9 @@ public: void RefreshSubsidiary( const SwRect& ) const; /// Foot note interface - bool IsFtnPage() const { return bFtnPage; } + bool IsFootnotePage() const { return bFootnotePage; } bool IsEndNotePage() const { return bEndNotePage; } - void SetFtnPage( bool b ) { bFtnPage = b; } + void SetFootnotePage( bool b ) { bFootnotePage = b; } void SetEndNotePage( bool b ) { bEndNotePage = b; } inline sal_uInt16 GetPhyPageNum() const { return nPhyPageNum;} @@ -197,21 +197,21 @@ public: inline void IncrPhyPageNum() { ++nPhyPageNum; } /// Validate, invalidate and query the Page status - /// Layout/Cntnt and Fly/non-Fly respectively are inspected separately + /// Layout/Content and Fly/non-Fly respectively are inspected separately inline void InvalidateFlyLayout() const; - inline void InvalidateFlyCntnt() const; + inline void InvalidateFlyContent() const; inline void InvalidateFlyInCnt() const; inline void InvalidateLayout() const; - inline void InvalidateCntnt() const; + inline void InvalidateContent() const; inline void InvalidateSpelling() const; inline void InvalidateSmartTags() const; inline void InvalidateAutoCompleteWords() const; inline void InvalidateWordCount() const; inline void ValidateFlyLayout() const; - inline void ValidateFlyCntnt() const; + inline void ValidateFlyContent() const; inline void ValidateFlyInCnt() const; inline void ValidateLayout() const; - inline void ValidateCntnt() const; + inline void ValidateContent() const; inline void ValidateSpelling() const; inline void ValidateSmartTags() const; inline void ValidateAutoCompleteWords() const; @@ -221,10 +221,10 @@ public: bool IsRightShadowNeeded() const; bool IsLeftShadowNeeded() const; bool IsInvalidFlyLayout() const { return bInvalidFlyLayout; } - bool IsInvalidFlyCntnt() const { return bInvalidFlyCntnt; } + bool IsInvalidFlyContent() const { return bInvalidFlyContent; } bool IsInvalidFlyInCnt() const { return bInvalidFlyInCnt; } bool IsInvalidLayout() const { return bInvalidLayout; } - bool IsInvalidCntnt() const { return (bInvalidCntnt || bInvalidFlyInCnt); } + bool IsInvalidContent() const { return (bInvalidContent || bInvalidFlyInCnt); } bool IsInvalidSpelling() const { return bInvalidSpelling; } bool IsInvalidSmartTags() const { return bInvalidSmartTags; } bool IsInvalidAutoCompleteWords() const { return bInvalidAutoCmplWrds; } @@ -335,27 +335,27 @@ public: static SwTwips GetSidebarBorderWidth( const SwViewShell* ); }; -inline SwCntntFrm *SwPageFrm::FindFirstBodyCntnt() +inline SwContentFrm *SwPageFrm::FindFirstBodyContent() { SwLayoutFrm *pBody = FindBodyCont(); - return pBody ? pBody->ContainsCntnt() : 0; + return pBody ? pBody->ContainsContent() : 0; } -inline const SwCntntFrm *SwPageFrm::FindFirstBodyCntnt() const +inline const SwContentFrm *SwPageFrm::FindFirstBodyContent() const { const SwLayoutFrm *pBody = FindBodyCont(); - return pBody ? pBody->ContainsCntnt() : 0; + return pBody ? pBody->ContainsContent() : 0; } -inline const SwCntntFrm *SwPageFrm::FindLastBodyCntnt() const +inline const SwContentFrm *SwPageFrm::FindLastBodyContent() const { - return const_cast<SwPageFrm*>(this)->FindLastBodyCntnt(); + return const_cast<SwPageFrm*>(this)->FindLastBodyContent(); } inline void SwPageFrm::InvalidateFlyLayout() const { const_cast<SwPageFrm*>(this)->bInvalidFlyLayout = true; } -inline void SwPageFrm::InvalidateFlyCntnt() const +inline void SwPageFrm::InvalidateFlyContent() const { - const_cast<SwPageFrm*>(this)->bInvalidFlyCntnt = true; + const_cast<SwPageFrm*>(this)->bInvalidFlyContent = true; } inline void SwPageFrm::InvalidateFlyInCnt() const { @@ -365,9 +365,9 @@ inline void SwPageFrm::InvalidateLayout() const { const_cast<SwPageFrm*>(this)->bInvalidLayout = true; } -inline void SwPageFrm::InvalidateCntnt() const +inline void SwPageFrm::InvalidateContent() const { - const_cast<SwPageFrm*>(this)->bInvalidCntnt = true; + const_cast<SwPageFrm*>(this)->bInvalidContent = true; } inline void SwPageFrm::InvalidateSpelling() const { @@ -390,9 +390,9 @@ inline void SwPageFrm::ValidateFlyLayout() const { const_cast<SwPageFrm*>(this)->bInvalidFlyLayout = false; } -inline void SwPageFrm::ValidateFlyCntnt() const +inline void SwPageFrm::ValidateFlyContent() const { - const_cast<SwPageFrm*>(this)->bInvalidFlyCntnt = false; + const_cast<SwPageFrm*>(this)->bInvalidFlyContent = false; } inline void SwPageFrm::ValidateFlyInCnt() const { @@ -402,9 +402,9 @@ inline void SwPageFrm::ValidateLayout() const { const_cast<SwPageFrm*>(this)->bInvalidLayout = false; } -inline void SwPageFrm::ValidateCntnt() const +inline void SwPageFrm::ValidateContent() const { - const_cast<SwPageFrm*>(this)->bInvalidCntnt = false; + const_cast<SwPageFrm*>(this)->bInvalidContent = false; } inline void SwPageFrm::ValidateSpelling() const { @@ -426,11 +426,11 @@ inline void SwPageFrm::ValidateWordCount() const inline bool SwPageFrm::IsInvalid() const { - return (bInvalidCntnt || bInvalidLayout || bInvalidFlyInCnt); + return (bInvalidContent || bInvalidLayout || bInvalidFlyInCnt); } inline bool SwPageFrm::IsInvalidFly() const { - return bInvalidFlyLayout || bInvalidFlyCntnt; + return bInvalidFlyLayout || bInvalidFlyContent; } diff --git a/sw/source/core/inc/pamtyp.hxx b/sw/source/core/inc/pamtyp.hxx index 68f0ddf9be3f..784b4284281c 100644 --- a/sw/source/core/inc/pamtyp.hxx +++ b/sw/source/core/inc/pamtyp.hxx @@ -26,7 +26,7 @@ class SwpHints; struct SwPosition; class SwPaM; -class SwTxtAttr; +class SwTextAttr; // Funktions-Deklarationen fuer die Move/Find-Methoden vom SwPaM @@ -37,17 +37,17 @@ void GoEndSection( SwPosition*); bool GoInDoc( SwPaM&, SwMoveFn); bool GoInSection( SwPaM&, SwMoveFn); bool GoInNode( SwPaM&, SwMoveFn); -bool GoInCntnt( SwPaM&, SwMoveFn); -bool GoInCntntCells( SwPaM&, SwMoveFn); -bool GoInCntntSkipHidden( SwPaM&, SwMoveFn); -bool GoInCntntCellsSkipHidden( SwPaM&, SwMoveFn); -const SwTxtAttr* GetFrwrdTxtHint( const SwpHints&, sal_uInt16&, sal_Int32 ); -const SwTxtAttr* GetBkwrdTxtHint( const SwpHints&, sal_uInt16&, sal_Int32 ); +bool GoInContent( SwPaM&, SwMoveFn); +bool GoInContentCells( SwPaM&, SwMoveFn); +bool GoInContentSkipHidden( SwPaM&, SwMoveFn); +bool GoInContentCellsSkipHidden( SwPaM&, SwMoveFn); +const SwTextAttr* GetFrwrdTextHint( const SwpHints&, sal_uInt16&, sal_Int32 ); +const SwTextAttr* GetBkwrdTextHint( const SwpHints&, sal_uInt16&, sal_Int32 ); bool GoNext(SwNode* pNd, SwIndex * pIdx, sal_uInt16 nMode ); bool GoPrevious(SwNode* pNd, SwIndex * pIdx, sal_uInt16 nMode ); -SW_DLLPUBLIC SwCntntNode* GoNextNds( SwNodeIndex * pIdx, bool ); -SwCntntNode* GoPreviousNds( SwNodeIndex * pIdx, bool ); +SW_DLLPUBLIC SwContentNode* GoNextNds( SwNodeIndex * pIdx, bool ); +SwContentNode* GoPreviousNds( SwNodeIndex * pIdx, bool ); // Funktionsdefinitionen fuer die SwCrsrShell bool GoPrevPara( SwPaM&, SwPosPara); @@ -59,12 +59,12 @@ bool GoNextSection( SwPaM&, SwPosSection); // Typedefiniton fuer Funktionen typedef bool (*GoNd)( SwNode*, SwIndex*, sal_uInt16 ); -typedef SwCntntNode* (*GoNds)( SwNodeIndex*, bool ); +typedef SwContentNode* (*GoNds)( SwNodeIndex*, bool ); typedef void (*GoDoc)( SwPosition* ); typedef void (*GoSection)( SwPosition* ); typedef bool (SwPosition:: *CmpOp)( const SwPosition& ) const; -typedef const SwTxtAttr* (*GetHint)( const SwpHints&, sal_uInt16&, sal_Int32 ); -typedef bool (utl::TextSearch:: *SearchTxt)( const OUString&, sal_Int32*, +typedef const SwTextAttr* (*GetHint)( const SwpHints&, sal_uInt16&, sal_Int32 ); +typedef bool (utl::TextSearch:: *SearchText)( const OUString&, sal_Int32*, sal_Int32*, ::com::sun::star::util::SearchResult* ); typedef void (*MvSection)( SwNodeIndex * ); @@ -76,12 +76,12 @@ struct SwMoveFnCollection GoSection fnSections; CmpOp fnCmpOp; GetHint fnGetHint; - SearchTxt fnSearch; + SearchText fnSearch; MvSection fnSection; }; // Funktionsdefinitionen fuers Suchen -SwCntntNode* GetNode( SwPaM&, bool&, SwMoveFn, bool bInReadOnly = false ); +SwContentNode* GetNode( SwPaM&, bool&, SwMoveFn, bool bInReadOnly = false ); #endif diff --git a/sw/source/core/inc/rolbck.hxx b/sw/source/core/inc/rolbck.hxx index c26665e9c136..6d4ca2f1f6b6 100644 --- a/sw/source/core/inc/rolbck.hxx +++ b/sw/source/core/inc/rolbck.hxx @@ -31,24 +31,24 @@ namespace sfx2 { } class SwDoc; -class SwFmtColl; +class SwFormatColl; class SwHistoryHint; -class SwTxtAttr; +class SwTextAttr; class SfxPoolItem; class SwUndoSaveSection; -class SwTxtFtn; -class SwUndoDelLayFmt; -class SwFlyFrmFmt; -class SwFmtFld; -class SwTxtFld; +class SwTextFootnote; +class SwUndoDelLayFormat; +class SwFlyFrameFormat; +class SwFormatField; +class SwTextField; class SwFieldType; -class SwTxtTOXMark; -class SwTxtRefMark; -class SwFrmFmt; +class SwTextTOXMark; +class SwTextRefMark; +class SwFrameFormat; class SwpHints; -class SwFmtChain; +class SwFormatChain; class SwNode; -class SwCharFmt; +class SwCharFormat; #include <tox.hxx> @@ -89,31 +89,31 @@ public: virtual OUString GetDescription() const; }; -class SwHistorySetFmt : public SwHistoryHint +class SwHistorySetFormat : public SwHistoryHint { ::std::unique_ptr<SfxPoolItem> m_pAttr; const sal_uLong m_nNodeIndex; public: - SwHistorySetFmt( const SfxPoolItem* pFmtHt, sal_uLong nNode ); - virtual ~SwHistorySetFmt(); + SwHistorySetFormat( const SfxPoolItem* pFormatHt, sal_uLong nNode ); + virtual ~SwHistorySetFormat(); virtual void SetInDoc( SwDoc* pDoc, bool bTmpSet ) SAL_OVERRIDE; virtual OUString GetDescription() const SAL_OVERRIDE; }; -class SwHistoryResetFmt : public SwHistoryHint +class SwHistoryResetFormat : public SwHistoryHint { const sal_uLong m_nNodeIndex; const sal_uInt16 m_nWhich; public: - SwHistoryResetFmt( const SfxPoolItem* pFmtHt, sal_uLong nNodeIdx ); + SwHistoryResetFormat( const SfxPoolItem* pFormatHt, sal_uLong nNodeIdx ); virtual void SetInDoc( SwDoc* pDoc, bool bTmpSet ) SAL_OVERRIDE; }; -class SwHistorySetTxt : public SwHistoryHint +class SwHistorySetText : public SwHistoryHint { ::std::unique_ptr<SfxPoolItem> m_pAttr; const sal_uLong m_nNodeIndex; @@ -123,26 +123,26 @@ class SwHistorySetTxt : public SwHistoryHint bool m_bFormatIgnoreEnd : 1; public: - SwHistorySetTxt( SwTxtAttr* pTxtHt, sal_uLong nNode ); - virtual ~SwHistorySetTxt(); + SwHistorySetText( SwTextAttr* pTextHt, sal_uLong nNode ); + virtual ~SwHistorySetText(); virtual void SetInDoc( SwDoc* pDoc, bool bTmpSet ) SAL_OVERRIDE; }; -class SwHistorySetTxtFld : public SwHistoryHint +class SwHistorySetTextField : public SwHistoryHint { //!! beware of the order for the declation of the auto_ptrs. //!! If they get destroyed in the wrong order sw may crash (namely mail-merge as well) - ::std::unique_ptr<SwFieldType> m_pFldType; - const ::std::unique_ptr<SwFmtFld> m_pFld; + ::std::unique_ptr<SwFieldType> m_pFieldType; + const ::std::unique_ptr<SwFormatField> m_pField; sal_uLong m_nNodeIndex; sal_Int32 m_nPos; - sal_uInt16 m_nFldWhich; + sal_uInt16 m_nFieldWhich; public: - SwHistorySetTxtFld( SwTxtFld* pTxtFld, sal_uLong nNode ); - virtual ~SwHistorySetTxtFld(); + SwHistorySetTextField( SwTextField* pTextField, sal_uLong nNode ); + virtual ~SwHistorySetTextField(); virtual void SetInDoc( SwDoc* pDoc, bool bTmpSet ) SAL_OVERRIDE; virtual OUString GetDescription() const SAL_OVERRIDE; @@ -157,7 +157,7 @@ class SwHistorySetRefMark : public SwHistoryHint const sal_Int32 m_nEnd; public: - SwHistorySetRefMark( SwTxtRefMark* pTxtHt, sal_uLong nNode ); + SwHistorySetRefMark( SwTextRefMark* pTextHt, sal_uLong nNode ); virtual void SetInDoc( SwDoc* pDoc, bool bTmpSet ) SAL_OVERRIDE; }; @@ -172,13 +172,13 @@ class SwHistorySetTOXMark : public SwHistoryHint const sal_Int32 m_nEnd; public: - SwHistorySetTOXMark( SwTxtTOXMark* pTxtHt, sal_uLong nNode ); + SwHistorySetTOXMark( SwTextTOXMark* pTextHt, sal_uLong nNode ); virtual void SetInDoc( SwDoc* pDoc, bool bTmpSet ) SAL_OVERRIDE; bool IsEqual( const SwTOXMark& rCmp ) const; }; -class SwHistoryResetTxt : public SwHistoryHint +class SwHistoryResetText : public SwHistoryHint { const sal_uLong m_nNodeIndex; const sal_Int32 m_nStart; @@ -186,13 +186,13 @@ class SwHistoryResetTxt : public SwHistoryHint const sal_uInt16 m_nAttr; public: - SwHistoryResetTxt( sal_uInt16 nWhich, sal_Int32 nStt, sal_Int32 nEnd, + SwHistoryResetText( sal_uInt16 nWhich, sal_Int32 nStt, sal_Int32 nEnd, sal_uLong nNode ); virtual void SetInDoc( SwDoc* pDoc, bool bTmpSet ) SAL_OVERRIDE; sal_uInt16 GetWhich() const { return m_nAttr; } sal_uLong GetNode() const { return m_nNodeIndex; } - sal_Int32 GetCntnt() const { return m_nStart; } + sal_Int32 GetContent() const { return m_nStart; } }; @@ -205,8 +205,8 @@ class SwHistorySetFootnote : public SwHistoryHint const bool m_bEndNote; public: - SwHistorySetFootnote( SwTxtFtn* pTxtFtn, sal_uLong nNode ); - SwHistorySetFootnote( const SwTxtFtn& ); + SwHistorySetFootnote( SwTextFootnote* pTextFootnote, sal_uLong nNode ); + SwHistorySetFootnote( const SwTextFootnote& ); virtual ~SwHistorySetFootnote(); virtual void SetInDoc( SwDoc* pDoc, bool bTmpSet ) SAL_OVERRIDE; @@ -214,27 +214,27 @@ public: }; -class SwHistoryChangeFmtColl : public SwHistoryHint +class SwHistoryChangeFormatColl : public SwHistoryHint { - SwFmtColl * const m_pColl; + SwFormatColl * const m_pColl; const sal_uLong m_nNodeIndex; const sal_uInt8 m_nNodeType; public: - SwHistoryChangeFmtColl( SwFmtColl* pColl, sal_uLong nNode, sal_uInt8 nNodeWhich ); + SwHistoryChangeFormatColl( SwFormatColl* pColl, sal_uLong nNode, sal_uInt8 nNodeWhich ); virtual void SetInDoc( SwDoc* pDoc, bool bTmpSet ) SAL_OVERRIDE; }; -class SwHistoryTxtFlyCnt : public SwHistoryHint +class SwHistoryTextFlyCnt : public SwHistoryHint { - ::std::unique_ptr<SwUndoDelLayFmt> m_pUndo; + ::std::unique_ptr<SwUndoDelLayFormat> m_pUndo; public: - SwHistoryTxtFlyCnt( SwFrmFmt* const pFlyFmt ); - virtual ~SwHistoryTxtFlyCnt(); + SwHistoryTextFlyCnt( SwFrameFormat* const pFlyFormat ); + virtual ~SwHistoryTextFlyCnt(); virtual void SetInDoc( SwDoc* pDoc, bool bTmpSet ) SAL_OVERRIDE; - SwUndoDelLayFmt* GetUDelLFmt() { return m_pUndo.get(); } + SwUndoDelLayFormat* GetUDelLFormat() { return m_pUndo.get(); } }; @@ -254,8 +254,8 @@ class SwHistoryBookmark : public SwHistoryHint vcl::KeyCode m_aKeycode; const sal_uLong m_nNode; const sal_uLong m_nOtherNode; - const sal_Int32 m_nCntnt; - const sal_Int32 m_nOtherCntnt; + const sal_Int32 m_nContent; + const sal_Int32 m_nOtherContent; const bool m_bSavePos; const bool m_bSaveOtherPos; const bool m_bHadOtherPos; @@ -291,39 +291,39 @@ public: const std::vector<sal_uInt16>& GetArr() const { return m_Array; } sal_uLong GetNode() const { return m_nNodeIndex; } - sal_Int32 GetCntnt() const { return m_nStart; } + sal_Int32 GetContent() const { return m_nStart; } }; class SwHistoryChangeFlyAnchor : public SwHistoryHint { - SwFrmFmt & m_rFmt; + SwFrameFormat & m_rFormat; const sal_uLong m_nOldNodeIndex; const sal_Int32 m_nOldContentIndex; public: - SwHistoryChangeFlyAnchor( SwFrmFmt& rFmt ); + SwHistoryChangeFlyAnchor( SwFrameFormat& rFormat ); virtual void SetInDoc( SwDoc* pDoc, bool bTmpSet ) SAL_OVERRIDE; }; class SwHistoryChangeFlyChain : public SwHistoryHint { - SwFlyFrmFmt * const m_pPrevFmt; - SwFlyFrmFmt * const m_pNextFmt; - SwFlyFrmFmt * const m_pFlyFmt; + SwFlyFrameFormat * const m_pPrevFormat; + SwFlyFrameFormat * const m_pNextFormat; + SwFlyFrameFormat * const m_pFlyFormat; public: - SwHistoryChangeFlyChain( SwFlyFrmFmt& rFmt, const SwFmtChain& rAttr ); + SwHistoryChangeFlyChain( SwFlyFrameFormat& rFormat, const SwFormatChain& rAttr ); virtual void SetInDoc( SwDoc* pDoc, bool bTmpSet ) SAL_OVERRIDE; }; -class SwHistoryChangeCharFmt : public SwHistoryHint +class SwHistoryChangeCharFormat : public SwHistoryHint { const SfxItemSet m_OldSet; - const OUString m_Fmt; + const OUString m_Format; public: - SwHistoryChangeCharFmt( const SfxItemSet& rSet, const OUString & sFmt); + SwHistoryChangeCharFormat( const SfxItemSet& rSet, const OUString & sFormat); virtual void SetInDoc( SwDoc* pDoc, bool bTmpSet ) SAL_OVERRIDE; }; @@ -350,13 +350,13 @@ public: void Add( const SfxPoolItem* pOldValue, const SfxPoolItem* pNewValue, sal_uLong nNodeIdx ); - void Add( SwTxtAttr* pTxtHt, sal_uLong nNodeIdx, bool bNewAttr = true ); - void Add( SwFmtColl*, sal_uLong nNodeIdx, sal_uInt8 nWhichNd ); + void Add( SwTextAttr* pTextHt, sal_uLong nNodeIdx, bool bNewAttr = true ); + void Add( SwFormatColl*, sal_uLong nNodeIdx, sal_uInt8 nWhichNd ); void Add( const ::sw::mark::IMark&, bool bSavePos, bool bSaveOtherPos ); - void Add( SwFrmFmt& rFmt ); - void Add( SwFlyFrmFmt&, sal_uInt16& rSetPos ); - void Add( const SwTxtFtn& ); - void Add( const SfxItemSet & rSet, const SwCharFmt & rCharFmt); + void Add( SwFrameFormat& rFormat ); + void Add( SwFlyFrameFormat&, sal_uInt16& rSetPos ); + void Add( const SwTextFootnote& ); + void Add( const SfxItemSet & rSet, const SwCharFormat & rCharFormat); sal_uInt16 Count() const { return m_SwpHstry.size(); } sal_uInt16 GetTmpEnd() const { return m_SwpHstry.size() - m_nEndDiff; } @@ -385,7 +385,7 @@ public: const sal_Int32 nEnd, const bool bCopyFields ); - void CopyFmtAttr( const SfxItemSet& rSet, sal_uLong nNodeIdx ); + void CopyFormatAttr( const SfxItemSet& rSet, sal_uLong nNodeIdx ); }; class SwRegHistory : public SwClient @@ -410,7 +410,7 @@ public: sal_Int32 const nStart, sal_Int32 const nEnd, SetAttrMode const nFlags ); - void AddHint( SwTxtAttr* pHt, const bool bNew = false ); + void AddHint( SwTextAttr* pHt, const bool bNew = false ); void RegisterInModify( SwModify* pRegIn, const SwNode& rNd ); void ChangeNodeIndex( sal_uLong nNew ) { m_nNodeIndex = nNew; } diff --git a/sw/source/core/inc/rootfrm.hxx b/sw/source/core/inc/rootfrm.hxx index cbb5c1f8896e..44952adfe692 100644 --- a/sw/source/core/inc/rootfrm.hxx +++ b/sw/source/core/inc/rootfrm.hxx @@ -24,10 +24,10 @@ #include <doc.hxx> #include <IDocumentTimerAccess.hxx> -class SwCntntFrm; +class SwContentFrm; class SwViewShell; class SdrPage; -class SwFrmFmt; +class SwFrameFormat; class SwPaM; class SwCursor; class SwShellCrsr; @@ -96,8 +96,8 @@ class SwRootFrm: public SwLayoutFrm */ long mnBrowseWidth; - /// If we only have to format one CntntFrm, its in mpTurbo - const SwCntntFrm *mpTurbo; + /// If we only have to format one ContentFrm, its in mpTurbo + const SwContentFrm *mpTurbo; /// We should not need to always struggle to find the last page, so store it here SwPageFrm *mpLastPage; @@ -160,7 +160,7 @@ public: void AllCheckPageDescs() const; void AllInvalidateAutoCompleteWords() const; void AllAddPaintRect() const; - void AllRemoveFtns() ; + void AllRemoveFootnotes() ; void AllInvalidateSmartTagsOrSpelling(bool bSmartTags) const; /// Output virtual Device (e.g. for animations) @@ -169,8 +169,8 @@ public: /// Save Clipping if exactly the ClipRect is outputted static bool HasSameRect( const SwRect& rRect ); - SwRootFrm( SwFrmFmt*, SwViewShell* ); - void Init(SwFrmFmt*); + SwRootFrm( SwFrameFormat*, SwViewShell* ); + void Init(SwFrameFormat*); SwViewShell *GetCurrShell() const { return mpCurrShell; } void DeRegisterShell( SwViewShell *pSh ); @@ -210,7 +210,7 @@ public: virtual bool FillSelection( SwSelectionList& rList, const SwRect& rRect ) const SAL_OVERRIDE; - Point GetNextPrevCntntPos( const Point &rPoint, bool bNext ) const; + Point GetNextPrevContentPos( const Point &rPoint, bool bNext ) const; virtual Size ChgSize( const Size& aNewSize ) SAL_OVERRIDE; @@ -253,8 +253,8 @@ public: */ static void AssertPageFlys( SwPageFrm * ); - /// Invalidate all Cntnt, Size or PrtArea - void InvalidateAllCntnt( sal_uInt8 nInvalidate = INV_SIZE ); + /// Invalidate all Content, Size or PrtArea + void InvalidateAllContent( sal_uInt8 nInvalidate = INV_SIZE ); /** * Invalidate/re-calculate the position of all floating @@ -299,22 +299,22 @@ public: * @returns false: There was no result because of an invalid layout * @returns true: Everything worked fine. */ - bool MakeTblCrsrs( SwTableCursor& ); + bool MakeTableCrsrs( SwTableCursor& ); void DisallowTurbo() const { const_cast<SwRootFrm*>(this)->mbTurboAllowed = false; } void ResetTurboFlag() const { const_cast<SwRootFrm*>(this)->mbTurboAllowed = true; } bool IsTurboAllowed() const { return mbTurboAllowed; } - void SetTurbo( const SwCntntFrm *pCntnt ) { mpTurbo = pCntnt; } + void SetTurbo( const SwContentFrm *pContent ) { mpTurbo = pContent; } void ResetTurbo() { mpTurbo = 0; } - const SwCntntFrm *GetTurbo() { return mpTurbo; } + const SwContentFrm *GetTurbo() { return mpTurbo; } /// Update the footernumbers of all Pages - void UpdateFtnNums(); // Only for page by page numnbering! + void UpdateFootnoteNums(); // Only for page by page numnbering! /// Remove all footnotes (but no references) - void RemoveFtns( SwPageFrm *pPage = 0, bool bPageOnly = false, + void RemoveFootnotes( SwPageFrm *pPage = 0, bool bPageOnly = false, bool bEndNotes = false ); - void CheckFtnPageDescs( bool bEndNote ); + void CheckFootnotePageDescs( bool bEndNote ); const SwPageFrm *GetLastPage() const { return mpLastPage; } SwPageFrm *GetLastPage() { return mpLastPage; } diff --git a/sw/source/core/inc/scriptinfo.hxx b/sw/source/core/inc/scriptinfo.hxx index 2fa1bc5cde26..5ad950fd4d8b 100644 --- a/sw/source/core/inc/scriptinfo.hxx +++ b/sw/source/core/inc/scriptinfo.hxx @@ -26,7 +26,7 @@ #include <rtl/ustrbuf.hxx> #include <osl/diagnose.h> -class SwTxtNode; +class SwTextNode; class Point; class MultiSelection; typedef std::list< sal_Int32 > PositionList; @@ -79,7 +79,7 @@ private: sal_Int32 nInvalidityPos; sal_uInt8 nDefaultDir; - void UpdateBidiInfo( const OUString& rTxt ); + void UpdateBidiInfo( const OUString& rText ); bool IsKashidaValid(sal_Int32 nKashPos) const; void MarkKashidaInvalid(sal_Int32 nKashPos); @@ -96,8 +96,8 @@ public: ~SwScriptInfo(); // determines script changes - void InitScriptInfo( const SwTxtNode& rNode, bool bRTL ); - void InitScriptInfo( const SwTxtNode& rNode ); + void InitScriptInfo( const SwTextNode& rNode, bool bRTL ); + void InitScriptInfo( const SwTextNode& rNode ); // set/get position from which data is invalid void SetInvalidityA(const sal_Int32 nPos) @@ -172,9 +172,9 @@ public: OSL_ENSURE( nCnt < aHiddenChg.size(),"No HiddenChg today!"); return aHiddenChg[ nCnt ]; } - static void CalcHiddenRanges(const SwTxtNode& rNode, MultiSelection& rHiddenMulti); - static void selectHiddenTextProperty(const SwTxtNode& rNode, MultiSelection &rHiddenMulti); - static void selectRedLineDeleted(const SwTxtNode& rNode, MultiSelection &rHiddenMulti, bool bSelect=true); + static void CalcHiddenRanges(const SwTextNode& rNode, MultiSelection& rHiddenMulti); + static void selectHiddenTextProperty(const SwTextNode& rNode, MultiSelection &rHiddenMulti); + static void selectRedLineDeleted(const SwTextNode& rNode, MultiSelection &rHiddenMulti, bool bSelect=true); // "high" level operations, nPos refers to string position sal_Int32 NextScriptChg( const sal_Int32 nPos ) const; @@ -194,7 +194,7 @@ public: @descr Determines if a given position is inside a hidden text range. The static version tries to obtain a valid SwScriptInfo object - via the SwTxtNode, otherwise it calculates the values from scratch. + via the SwTextNode, otherwise it calculates the values from scratch. The non-static version uses the internally cached informatio for the calculation. @@ -214,13 +214,13 @@ public: returns true if there are any hidden characters in this paragraph. */ - static bool GetBoundsOfHiddenRange( const SwTxtNode& rNode, sal_Int32 nPos, + static bool GetBoundsOfHiddenRange( const SwTextNode& rNode, sal_Int32 nPos, sal_Int32& rnStartPos, sal_Int32& rnEndPos, PositionList* pList = 0 ); bool GetBoundsOfHiddenRange( sal_Int32 nPos, sal_Int32& rnStartPos, sal_Int32& rnEndPos, PositionList* pList = 0 ) const; - static bool IsInHiddenRange( const SwTxtNode& rNode, sal_Int32 nPos ); + static bool IsInHiddenRange( const SwTextNode& rNode, sal_Int32 nPos ); /** Hidden text attribute handling @@ -237,18 +237,18 @@ public: If set, the hidden ranges will be deleted from the text node. */ static sal_Int32 MaskHiddenRanges( - const SwTxtNode& rNode, OUStringBuffer& rText, + const SwTextNode& rNode, OUStringBuffer& rText, const sal_Int32 nStt, const sal_Int32 nEnd, const sal_Unicode cChar ); /** Hidden text attribute handling - @descr Takes a SwTxtNode and deletes the hidden ranges from the node. + @descr Takes a SwTextNode and deletes the hidden ranges from the node. @param rNode The text node. */ - static void DeleteHiddenRanges( SwTxtNode& rNode ); + static void DeleteHiddenRanges( SwTextNode& rNode ); // HIDDEN TEXT STUFF END @@ -320,19 +320,19 @@ public: /** Checks if text is Arabic text. @descr Checks if text is Arabic text. - @param rTxt + @param rText The text to check @param nStt Start index of the text @return Returns if the language is an Arabic language */ - static bool IsArabicText( const OUString& rTxt, sal_Int32 nStt, sal_Int32 nLen ); + static bool IsArabicText( const OUString& rText, sal_Int32 nStt, sal_Int32 nLen ); /** Performs a thai justification on the kerning array @descr Add some extra space for thai justification to the positions in the kerning array. - @param rTxt + @param rText The String @param pKernArray The printers kerning array. Optional. @@ -346,15 +346,15 @@ public: The value which has to be added to the cells. @return The number of extra spaces in the given range */ - static sal_Int32 ThaiJustify( const OUString& rTxt, long* pKernArray, + static sal_Int32 ThaiJustify( const OUString& rText, long* pKernArray, long* pScrArray, sal_Int32 nIdx, sal_Int32 nLen, sal_Int32 nNumberOfBlanks = 0, long nSpaceAdd = 0 ); - static SwScriptInfo* GetScriptInfo( const SwTxtNode& rNode, + static SwScriptInfo* GetScriptInfo( const SwTextNode& rNode, bool bAllowInvalid = false ); - static sal_uInt8 WhichFont(sal_Int32 nIdx, const OUString* pTxt, const SwScriptInfo* pSI); + static sal_uInt8 WhichFont(sal_Int32 nIdx, const OUString* pText, const SwScriptInfo* pSI); }; #endif diff --git a/sw/source/core/inc/sectfrm.hxx b/sw/source/core/inc/sectfrm.hxx index 408d4d9b9aba..df36cf8929e0 100644 --- a/sw/source/core/inc/sectfrm.hxx +++ b/sw/source/core/inc/sectfrm.hxx @@ -25,9 +25,9 @@ #include <set> class SwSection; -class SwSectionFmt; +class SwSectionFormat; class SwAttrSetChg; -class SwFtnContFrm; +class SwFootnoteContFrm; class SwLayouter; #define FINDMODE_ENDNOTE 1 @@ -37,21 +37,21 @@ class SwLayouter; class SwSectionFrm: public SwLayoutFrm, public SwFlowFrm { SwSection* pSection; - bool bFtnAtEnd; // footnotes at the end of section + bool bFootnoteAtEnd; // footnotes at the end of section bool bEndnAtEnd; // endnotes at the end of section - bool bCntntLock; // content locked - bool bOwnFtnNum; // special numbering of footnotes - bool bFtnLock; // ftn, don't leave this section bwd + bool bContentLock; // content locked + bool bOwnFootnoteNum; // special numbering of footnotes + bool bFootnoteLock; // ftn, don't leave this section bwd void _UpdateAttr( const SfxPoolItem*, const SfxPoolItem*, sal_uInt8 &, SwAttrSetChg *pa = 0, SwAttrSetChg *pb = 0 ); void _Cut( bool bRemove ); - // Is there a FtnContainer? - // An empty sectionfrm without FtnCont is superfluous - bool IsSuperfluous() const { return !ContainsAny() && !ContainsFtnCont(); } - void CalcFtnAtEndFlag(); + // Is there a FootnoteContainer? + // An empty sectionfrm without FootnoteCont is superfluous + bool IsSuperfluous() const { return !ContainsAny() && !ContainsFootnoteCont(); } + void CalcFootnoteAtEndFlag(); void CalcEndAtEndFlag(); - const SwSectionFmt* _GetEndSectFmt() const; + const SwSectionFormat* _GetEndSectFormat() const; bool IsEndnoteAtMyEnd() const; virtual void DestroyImpl() SAL_OVERRIDE; @@ -80,16 +80,16 @@ public: inline SwSectionFrm *GetFollow(); SwSectionFrm* FindMaster() const; - SwCntntFrm *FindLastCntnt( sal_uInt8 nMode = 0 ); - inline const SwCntntFrm *FindLastCntnt( sal_uInt8 nMode = 0 ) const; + SwContentFrm *FindLastContent( sal_uInt8 nMode = 0 ); + inline const SwContentFrm *FindLastContent( sal_uInt8 nMode = 0 ) const; inline SwSection* GetSection() { return pSection; } inline const SwSection* GetSection() const { return pSection; } inline void ColLock() { mbColLocked = true; } inline void ColUnlock() { mbColLocked = false; } - void CalcFtnCntnt(); + void CalcFootnoteContent(); void SimpleFormat(); - bool IsDescendantFrom( const SwSectionFmt* pSect ) const; + bool IsDescendantFrom( const SwSectionFormat* pSect ) const; bool HasToBreak( const SwFrm* pFrm ) const; void MergeNext( SwSectionFrm* pNxt ); @@ -100,8 +100,8 @@ public: bool SplitSect( SwFrm* pFrm, bool bApres ); void DelEmpty( bool bRemove ); // Like Cut(), except for that Follow chaining is maintained bool IsToIgnore() const // No size, no content; need to be ignored - { return !Frm().Height() && !ContainsCntnt(); } - SwFtnContFrm* ContainsFtnCont( const SwFtnContFrm* pCont = NULL ) const; + { return !Frm().Height() && !ContainsContent(); } + SwFootnoteContFrm* ContainsFootnoteCont( const SwFootnoteContFrm* pCont = NULL ) const; bool Growable() const; SwTwips _Shrink( SwTwips, bool bTst ); SwTwips _Grow ( SwTwips, bool bTst ); @@ -131,29 +131,29 @@ public: /// Adapt size to surroundings void _CheckClipping( bool bGrow, bool bMaximize ); - void InvalidateFtnPos(); + void InvalidateFootnotePos(); void CollectEndnotes( SwLayouter* pLayouter ); - const SwSectionFmt* GetEndSectFmt() const - { if( IsEndnAtEnd() ) return _GetEndSectFmt(); return NULL; } + const SwSectionFormat* GetEndSectFormat() const + { if( IsEndnAtEnd() ) return _GetEndSectFormat(); return NULL; } - static void MoveCntntAndDelete( SwSectionFrm* pDel, bool bSave ); + static void MoveContentAndDelete( SwSectionFrm* pDel, bool bSave ); bool IsBalancedSection() const; virtual void dumpAsXmlAttributes(xmlTextWriterPtr writer) const SAL_OVERRIDE; - bool IsFtnAtEnd() const { return bFtnAtEnd; } + bool IsFootnoteAtEnd() const { return bFootnoteAtEnd; } bool IsEndnAtEnd() const { return bEndnAtEnd; } - bool IsAnyNoteAtEnd() const { return bFtnAtEnd || bEndnAtEnd; } - bool AreNotesAtEnd() const { return bFtnAtEnd && bEndnAtEnd; } + bool IsAnyNoteAtEnd() const { return bFootnoteAtEnd || bEndnAtEnd; } + bool AreNotesAtEnd() const { return bFootnoteAtEnd && bEndnAtEnd; } - void SetCntntLock( bool bNew ) { bCntntLock = bNew; } - bool IsCntntLocked() const { return bCntntLock; } + void SetContentLock( bool bNew ) { bContentLock = bNew; } + bool IsContentLocked() const { return bContentLock; } - bool IsOwnFtnNum() const { return bOwnFtnNum; } + bool IsOwnFootnoteNum() const { return bOwnFootnoteNum; } - void SetFtnLock( bool bNew ) { bFtnLock = bNew; } - bool IsFtnLock() const { return bFtnLock; } + void SetFootnoteLock( bool bNew ) { bFootnoteLock = bNew; } + bool IsFootnoteLock() const { return bFootnoteLock; } DECL_FIXEDMEMPOOL_NEWDEL(SwSectionFrm) }; @@ -168,9 +168,9 @@ inline SwSectionFrm *SwSectionFrm::GetFollow() { return static_cast<SwSectionFrm*>(SwFlowFrm::GetFollow()); } -inline const SwCntntFrm *SwSectionFrm::FindLastCntnt( sal_uInt8 nMode ) const +inline const SwContentFrm *SwSectionFrm::FindLastContent( sal_uInt8 nMode ) const { - return const_cast<SwSectionFrm*>(this)->FindLastCntnt( nMode ); + return const_cast<SwSectionFrm*>(this)->FindLastContent( nMode ); } #endif // INCLUDED_SW_SOURCE_CORE_INC_SECTFRM_HXX diff --git a/sw/source/core/inc/swblocks.hxx b/sw/source/core/inc/swblocks.hxx index 3a7280a5fd3f..6c186abae8a8 100644 --- a/sw/source/core/inc/swblocks.hxx +++ b/sw/source/core/inc/swblocks.hxx @@ -36,8 +36,8 @@ public: OUString aShort; /// Shortname OUString aLong; /// Longname OUString aPackageName; /// Package name - bool bIsOnlyTxtFlagInit : 1; /// Is the Flag valid? - bool bIsOnlyTxt : 1; /// Unformatted text + bool bIsOnlyTextFlagInit : 1; /// Is the Flag valid? + bool bIsOnlyText : 1; /// Unformatted text bool bInPutMuchBlocks : 1; /// Put serveral block entries SwBlockName( const OUString& rShort, const OUString& rLong ); @@ -81,7 +81,7 @@ protected: virtual void ClearDoc(); // Delete Doc content SwPaM* MakePaM(); // Span PaM over Doc - virtual void AddName( const OUString&, const OUString&, bool bOnlyTxt = false ); + virtual void AddName( const OUString&, const OUString&, bool bOnlyText = false ); bool IsFileChanged() const; void Touch(); @@ -118,10 +118,10 @@ public: virtual bool IsOnlyTextBlock( const OUString& rShort ) const; - virtual sal_uLong GetMacroTable( sal_uInt16 nIdx, SvxMacroTableDtor& rMacroTbl, + virtual sal_uLong GetMacroTable( sal_uInt16 nIdx, SvxMacroTableDtor& rMacroTable, bool bFileAlreadyOpen = false ); virtual sal_uLong SetMacroTable( sal_uInt16 nIdx, - const SvxMacroTableDtor& rMacroTbl, + const SvxMacroTableDtor& rMacroTable, bool bFileAlreadyOpen = false ); virtual bool PutMuchEntries( bool bOn ); }; diff --git a/sw/source/core/inc/swfont.hxx b/sw/source/core/inc/swfont.hxx index 266c5c5ffd37..97da4572235e 100644 --- a/sw/source/core/inc/swfont.hxx +++ b/sw/source/core/inc/swfont.hxx @@ -33,7 +33,7 @@ class SfxItemSet; class SwAttrSet; class SwDoCapitals; // DoCapitals class SwDrawTextInfo; // _DrawText -class SwScriptInfo; // _GetTxtSize +class SwScriptInfo; // _GetTextSize class SwViewShell; class IDocumentSettingAccess; typedef struct _xmlTextWriter *xmlTextWriterPtr; @@ -76,7 +76,7 @@ class SwSubFont : public SvxFont bool IsSymbol( SwViewShell *pSh ); sal_uInt16 GetAscent( SwViewShell *pSh, const OutputDevice& rOut ); sal_uInt16 GetHeight( SwViewShell *pSh, const OutputDevice& rOut ); - Size _GetTxtSize( SwDrawTextInfo& rInf ); + Size _GetTextSize( SwDrawTextInfo& rInf ); Size GetCapitalSize( SwDrawTextInfo& rInf ); void _DrawText( SwDrawTextInfo &rInf, const bool bGrey ); void DrawCapital( SwDrawTextInfo &rInf ); @@ -161,7 +161,7 @@ class SwFont sal_uInt8 nActual; // actual font (Latin, CJK or CTL) // switch for the font-extensions - bool bNoHyph :1; // SwTxtNoHyphenHere: no separator + bool bNoHyph :1; // SwTextNoHyphenHere: no separator bool bBlink :1; // blinking font bool bPaintBlank :1; // blanks not with DrawRect bool bFntChg :1; @@ -277,7 +277,7 @@ public: inline void SetPaintWrong( const bool bNew ); inline bool IsPaintWrong() const { return bPaintWrong; } - // setting of the base class font for SwTxtCharFmt + // setting of the base class font for SwTextCharFormat void SetDiffFnt( const SfxItemSet* pSet, const IDocumentSettingAccess* pIDocumentSettingAccess ); @@ -343,7 +343,7 @@ public: { return aSub[nActual].GetCapitalSize( rInf ); } sal_Int32 GetCapitalBreak( SwViewShell const* pSh, const OutputDevice* pOut, - const SwScriptInfo* pScript, const OUString& rTxt, + const SwScriptInfo* pScript, const OUString& rText, long nTextWidth, const sal_Int32 nIdx, const sal_Int32 nLen ); @@ -359,10 +359,10 @@ public: void DoOnCapitals( SwDoCapitals &rDo ) { aSub[nActual].DoOnCapitals( rDo ); } - Size _GetTxtSize( SwDrawTextInfo& rInf ) - { rInf.SetFont( this ); return aSub[nActual]._GetTxtSize( rInf ); } + Size _GetTextSize( SwDrawTextInfo& rInf ) + { rInf.SetFont( this ); return aSub[nActual]._GetTextSize( rInf ); } - sal_Int32 GetTxtBreak( SwDrawTextInfo& rInf, long nTextWidth ); + sal_Int32 GetTextBreak( SwDrawTextInfo& rInf, long nTextWidth ); sal_Int32 _GetCrsrOfst( SwDrawTextInfo& rInf ) { return aSub[nActual]._GetCrsrOfst( rInf ); } diff --git a/sw/source/core/inc/swselectionlist.hxx b/sw/source/core/inc/swselectionlist.hxx index aa920d78d0e5..01bbfef5575a 100644 --- a/sw/source/core/inc/swselectionlist.hxx +++ b/sw/source/core/inc/swselectionlist.hxx @@ -45,7 +45,7 @@ public: /** Ctor to create an empty list for a given context @param pInitCxt - The frame (normally a SwTxtFrm) where the block cursor selection starts, + The frame (normally a SwTextFrm) where the block cursor selection starts, it will be used to get the allowed context for the text selections. */ explicit SwSelectionList( const SwFrm* pInitCxt ); diff --git a/sw/source/core/inc/tabfrm.hxx b/sw/source/core/inc/tabfrm.hxx index 593f1148f029..3b418cf7f18b 100644 --- a/sw/source/core/inc/tabfrm.hxx +++ b/sw/source/core/inc/tabfrm.hxx @@ -30,7 +30,7 @@ class SwAttrSetChg; /// SwTabFrm is one table in the document layout, containing rows (which contain cells). class SwTabFrm: public SwLayoutFrm, public SwFlowFrm { - friend void CalcCntnt( SwLayoutFrm *pLay, bool bNoColl, bool bNoCalcFollow ); + friend void CalcContent( SwLayoutFrm *pLay, bool bNoColl, bool bNoCalcFollow ); // does the special treatment for _Get[Next|Prev]Leaf() using SwFrm::GetLeaf; @@ -47,11 +47,11 @@ class SwTabFrm: public SwLayoutFrm, public SwFlowFrm bool m_bLockBackMove :1; /// The Master took care of the BackMove test 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 CntntFrm::Grow; there it might be called for + /// it in ContentFrm::Grow; there it might be called for /// _every_ Cell bool m_bONECalcLowers :1; /// Primarily for the StarONE SS - /// The Cntnts are formatted via Calc() on MakeAll in any + /// The Contents are formatted via Calc() on MakeAll in any /// case. There are no further invalidations and that path can /// hardly give any guarantees @@ -125,7 +125,7 @@ public: inline SwTabFrm *GetFollow(); SwTabFrm* FindMaster( bool bFirstMaster = false ) const; - virtual bool GetInfo( SfxPoolItem &rHnt ) const SAL_OVERRIDE; + virtual bool GetInfo( SfxPoolItem &rHint ) const SAL_OVERRIDE; virtual void Paint( SwRect const&, SwPrintData const*const pPrintData = NULL ) const SAL_OVERRIDE; virtual void CheckDirection( bool bVert ) SAL_OVERRIDE; @@ -136,8 +136,8 @@ public: virtual void Prepare( const PrepareHint ePrep = PREP_CLEAR, const void *pVoid = 0, bool bNotify = true ) SAL_OVERRIDE; - SwCntntFrm *FindLastCntnt(); - inline const SwCntntFrm *FindLastCntnt() const; + SwContentFrm *FindLastContent(); + inline const SwContentFrm *FindLastContent() const; const SwTable *GetTable() const { return m_pTable; } SwTable *GetTable() { return m_pTable; } @@ -224,9 +224,9 @@ public: DECL_FIXEDMEMPOOL_NEWDEL(SwTabFrm) }; -inline const SwCntntFrm *SwTabFrm::FindLastCntnt() const +inline const SwContentFrm *SwTabFrm::FindLastContent() const { - return const_cast<SwTabFrm*>(this)->FindLastCntnt(); + return const_cast<SwTabFrm*>(this)->FindLastContent(); } inline const SwTabFrm *SwTabFrm::GetFollow() const diff --git a/sw/source/core/inc/tblrwcl.hxx b/sw/source/core/inc/tblrwcl.hxx index 158e7d79bb1f..e23a41eebb93 100644 --- a/sw/source/core/inc/tblrwcl.hxx +++ b/sw/source/core/inc/tblrwcl.hxx @@ -30,12 +30,12 @@ class SwDoc; class SwTableNode; class SwTableLine; class SwTableBox; -class SwTableBoxFmt; +class SwTableBoxFormat; class SwHistory; -class SwCntntNode; +class SwContentNode; class SfxPoolItem; -class SwShareBoxFmts; -class SwFmtFrmSize; +class SwShareBoxFormats; +class SwFormatFrmSize; struct _CpyPara; struct _InsULPara; @@ -45,13 +45,13 @@ void sw_LineSetHeadCondColl( const SwTableLine* pLine ); void _CheckBoxWidth( const SwTableLine& rLine, SwTwips nSize ); #endif -void _InsTblBox( SwDoc* pDoc, SwTableNode* pTblNd, - SwTableLine* pLine, SwTableBoxFmt* pBoxFrmFmt, +void _InsTableBox( SwDoc* pDoc, SwTableNode* pTableNd, + SwTableLine* pLine, SwTableBoxFormat* pBoxFrameFormat, SwTableBox* pBox, sal_uInt16 nInsPos, sal_uInt16 nCnt = 1 ); -SW_DLLPUBLIC void _DeleteBox( SwTable& rTbl, SwTableBox* pBox, SwUndo* pUndo = 0, +SW_DLLPUBLIC void _DeleteBox( SwTable& rTable, SwTableBox* pBox, SwUndo* pUndo = 0, bool bCalcNewSize = true, const bool bCorrBorder = true, - SwShareBoxFmts* pShareFmts = 0 ); + SwShareBoxFormats* pShareFormats = 0 ); /** * Class for SplitTable @@ -60,7 +60,7 @@ SW_DLLPUBLIC void _DeleteBox( SwTable& rTbl, SwTableBox* pBox, SwUndo* pUndo = 0 * * @see implementation in im ndtbl.cxx */ -class SwCollectTblLineBoxes +class SwCollectTableLineBoxes { std::vector<sal_uInt16> aPosArr; std::vector<SwTableBox*> m_Boxes; @@ -70,7 +70,7 @@ class SwCollectTblLineBoxes bool bGetValues : 1; public: - SwCollectTblLineBoxes( bool bTop, sal_uInt16 nMd = 0, SwHistory* pHist=0 ) + SwCollectTableLineBoxes( bool bTop, sal_uInt16 nMd = 0, SwHistory* pHist=0 ) : pHst( pHist ), nMode( nMd ), nWidth( 0 ), bGetFromTop( bTop ), bGetValues( true ) @@ -79,7 +79,7 @@ public: void AddBox( const SwTableBox& rBox ); const SwTableBox* GetBoxOfPos( const SwTableBox& rBox ); - void AddToUndoHistory( const SwCntntNode& rNd ); + void AddToUndoHistory( const SwContentNode& rNd ); size_t Count() const { return m_Boxes.size(); } const SwTableBox& GetBox( std::size_t nPos, sal_uInt16* pWidth = 0 ) const @@ -100,10 +100,10 @@ public: bool Resize( sal_uInt16 nOffset, sal_uInt16 nWidth ); }; -void sw_Box_CollectBox( const SwTableBox* pBox, SwCollectTblLineBoxes* pSplPara ); +void sw_Box_CollectBox( const SwTableBox* pBox, SwCollectTableLineBoxes* pSplPara ); bool sw_Line_CollectBox( const SwTableLine*& rpLine, void* pPara ); -void sw_BoxSetSplitBoxFmts( SwTableBox* pBox, SwCollectTblLineBoxes* pSplPara ); +void sw_BoxSetSplitBoxFormats( SwTableBox* pBox, SwCollectTableLineBoxes* pSplPara ); /** * This structure is needed by Undo to restore row span attributes @@ -119,14 +119,14 @@ struct SwSaveRowSpan struct _SwGCLineBorder { const SwTableLines* pLines; - SwShareBoxFmts* pShareFmts; + SwShareBoxFormats* pShareFormats; sal_uInt16 nLinePos; _SwGCLineBorder( const SwTable& rTable ) - : pLines( &rTable.GetTabLines() ), pShareFmts(0), nLinePos( 0 ) {} + : pLines( &rTable.GetTabLines() ), pShareFormats(0), nLinePos( 0 ) {} _SwGCLineBorder( const SwTableBox& rBox ) - : pLines( &rBox.GetTabLines() ), pShareFmts(0), nLinePos( 0 ) {} + : pLines( &rBox.GetTabLines() ), pShareFormats(0), nLinePos( 0 ) {} bool IsLastLine() const { return nLinePos + 1 >= (sal_uInt16)pLines->size(); } }; @@ -144,55 +144,55 @@ public: * Check whether the left Border is the same as the set one * @returns false if no Border was set */ - bool CheckLeftBorderOfFormat( const SwFrmFmt& rFmt ); + bool CheckLeftBorderOfFormat( const SwFrameFormat& rFormat ); bool IsAnyBorderFound() const { return bAnyBorderFnd; } }; void sw_GC_Line_Border( const SwTableLine* pLine, _SwGCLineBorder* pGCPara ); -class SwShareBoxFmt +class SwShareBoxFormat { - const SwFrmFmt* pOldFmt; - std::vector<SwFrmFmt*> aNewFmts; + const SwFrameFormat* pOldFormat; + std::vector<SwFrameFormat*> aNewFormats; public: - SwShareBoxFmt( const SwFrmFmt& rFmt ) - : pOldFmt( &rFmt ) + SwShareBoxFormat( const SwFrameFormat& rFormat ) + : pOldFormat( &rFormat ) {} - const SwFrmFmt& GetOldFormat() const { return *pOldFmt; } + const SwFrameFormat& GetOldFormat() const { return *pOldFormat; } - SwFrmFmt* GetFormat( long nWidth ) const; - SwFrmFmt* GetFormat( const SfxPoolItem& rItem ) const; - void AddFormat( SwFrmFmt& rFmt ); + SwFrameFormat* GetFormat( long nWidth ) const; + SwFrameFormat* GetFormat( const SfxPoolItem& rItem ) const; + void AddFormat( SwFrameFormat& rFormat ); /// @returns true, if we can delete - bool RemoveFormat( const SwFrmFmt& rFmt ); + bool RemoveFormat( const SwFrameFormat& rFormat ); }; -typedef boost::ptr_vector<SwShareBoxFmt> _SwShareBoxFmts; +typedef boost::ptr_vector<SwShareBoxFormat> _SwShareBoxFormats; -class SwShareBoxFmts +class SwShareBoxFormats { - _SwShareBoxFmts aShareArr; - bool Seek_Entry( const SwFrmFmt& rFmt, sal_uInt16* pPos ) const; + _SwShareBoxFormats aShareArr; + bool Seek_Entry( const SwFrameFormat& rFormat, sal_uInt16* pPos ) const; - void ChangeFrmFmt( SwTableBox* pBox, SwTableLine* pLn, SwFrmFmt& rFmt ); + void ChangeFrameFormat( SwTableBox* pBox, SwTableLine* pLn, SwFrameFormat& rFormat ); public: - SwShareBoxFmts() {} - ~SwShareBoxFmts(); + SwShareBoxFormats() {} + ~SwShareBoxFormats(); - SwFrmFmt* GetFormat( const SwFrmFmt& rFmt, long nWidth ) const; - SwFrmFmt* GetFormat( const SwFrmFmt& rFmt, const SfxPoolItem& ) const; + SwFrameFormat* GetFormat( const SwFrameFormat& rFormat, long nWidth ) const; + SwFrameFormat* GetFormat( const SwFrameFormat& rFormat, const SfxPoolItem& ) const; - void AddFormat( const SwFrmFmt& rOld, SwFrmFmt& rNew ); + void AddFormat( const SwFrameFormat& rOld, SwFrameFormat& rNew ); - void SetSize( SwTableBox& rBox, const SwFmtFrmSize& rSz ); + void SetSize( SwTableBox& rBox, const SwFormatFrmSize& rSz ); void SetAttr( SwTableBox& rBox, const SfxPoolItem& rItem ); void SetAttr( SwTableLine& rLine, const SfxPoolItem& rItem ); - void RemoveFormat( const SwFrmFmt& rFmt ); + void RemoveFormat( const SwFrameFormat& rFormat ); }; #endif diff --git a/sw/source/core/inc/tocntntanchoredobjectposition.hxx b/sw/source/core/inc/tocntntanchoredobjectposition.hxx index 66e5d5d24aa5..077d5fbd14c9 100644 --- a/sw/source/core/inc/tocntntanchoredobjectposition.hxx +++ b/sw/source/core/inc/tocntntanchoredobjectposition.hxx @@ -21,13 +21,13 @@ #include <anchoredobjectposition.hxx> class SwFrm; -class SwTxtFrm; +class SwTextFrm; class SwLayoutFrm; class SwRect; namespace objectpositioning { - class SwToCntntAnchoredObjectPosition : public SwAnchoredObjectPosition + class SwToContentAnchoredObjectPosition : public SwAnchoredObjectPosition { private: // calculated data for object position @@ -51,7 +51,7 @@ namespace objectpositioning // method to cast <SwAnchoredObjectPosition::GetAnchorFrm()> to // the needed type - SwTxtFrm& GetAnchorTxtFrm() const; + SwTextFrm& GetAnchorTextFrm() const; /** determine frame for horizontal position @@ -71,8 +71,8 @@ namespace objectpositioning const SwFrm& _GetHoriVirtualAnchor( const SwLayoutFrm& _pProposedFrm ) const; public: - SwToCntntAnchoredObjectPosition( SdrObject& _rDrawObj ); - virtual ~SwToCntntAnchoredObjectPosition(); + SwToContentAnchoredObjectPosition( SdrObject& _rDrawObj ); + virtual ~SwToContentAnchoredObjectPosition(); /** calculate position of object */ diff --git a/sw/source/core/inc/txmsrt.hxx b/sw/source/core/inc/txmsrt.hxx index 8822a219f76e..619229fea4ff 100644 --- a/sw/source/core/inc/txmsrt.hxx +++ b/sw/source/core/inc/txmsrt.hxx @@ -25,11 +25,11 @@ #include <com/sun/star/lang/Locale.hpp> class CharClass; -class SwCntntNode; -class SwTxtNode; -class SwTxtTOXMark; +class SwContentNode; +class SwTextNode; +class SwTextTOXMark; class SwIndex; -class SwFmtFld; +class SwFormatField; class IndexEntrySupplierWrapper; enum TOXSortType @@ -44,11 +44,11 @@ enum TOXSortType struct SwTOXSource { - const SwCntntNode* pNd; + const SwContentNode* pNd; sal_Int32 nPos; bool bMainEntry; - SwTOXSource( const SwCntntNode* pNode, sal_Int32 n, bool bMain ) + SwTOXSource( const SwContentNode* pNode, sal_Int32 n, bool bMain ) : pNd(pNode), nPos(n), bMainEntry(bMain) { } @@ -122,8 +122,8 @@ struct SwTOXSortTabBase { SwTOXSources aTOXSources; ::com::sun::star::lang::Locale aLocale; - const SwTxtNode* pTOXNd; - const SwTxtTOXMark* pTxtMark; + const SwTextNode* pTOXNd; + const SwTextTOXMark* pTextMark; const SwTOXInternational* pTOXIntl; sal_uLong nPos; sal_Int32 nCntPos; @@ -131,8 +131,8 @@ struct SwTOXSortTabBase static sal_uInt16 nOpt; SwTOXSortTabBase( TOXSortType nType, - const SwCntntNode* pTOXSrc, - const SwTxtTOXMark* pTxtMark, + const SwContentNode* pTOXSrc, + const SwTextTOXMark* pTextMark, const SwTOXInternational* pIntl, const ::com::sun::star::lang::Locale* pLocale = NULL ); virtual ~SwTOXSortTabBase() {} @@ -140,31 +140,31 @@ struct SwTOXSortTabBase sal_uInt16 GetType() const { return nType; } static sal_uInt16 GetOptions() { return nOpt; } - virtual void FillText( SwTxtNode& rNd, const SwIndex& rInsPos, sal_uInt16 nAuthField = 0) const; + virtual void FillText( SwTextNode& rNd, const SwIndex& rInsPos, sal_uInt16 nAuthField = 0) const; virtual sal_uInt16 GetLevel() const = 0; virtual bool operator==( const SwTOXSortTabBase& ); virtual bool operator<( const SwTOXSortTabBase& ); virtual OUString GetURL() const; - inline TextAndReading GetTxt() const; + inline TextAndReading GetText() const; inline const ::com::sun::star::lang::Locale& GetLocale() const; private: - mutable bool bValidTxt; + mutable bool bValidText; mutable TextAndReading m_aSort; virtual TextAndReading GetText_Impl() const = 0; }; -inline TextAndReading SwTOXSortTabBase::GetTxt() const +inline TextAndReading SwTOXSortTabBase::GetText() const { - if( !bValidTxt ) + if( !bValidText ) { // 'this' is 'SwTOXSortTabBase const*', so the virtual // mechanism will call the derived class' GetText_Impl m_aSort = GetText_Impl(); - bValidTxt = true; + bValidText = true; } return m_aSort; } @@ -179,12 +179,12 @@ inline const ::com::sun::star::lang::Locale& SwTOXSortTabBase::GetLocale() const */ struct SwTOXIndex : public SwTOXSortTabBase { - SwTOXIndex( const SwTxtNode&, const SwTxtTOXMark*, sal_uInt16 nOptions, sal_uInt8 nKeyLevel, + SwTOXIndex( const SwTextNode&, const SwTextTOXMark*, sal_uInt16 nOptions, sal_uInt8 nKeyLevel, const SwTOXInternational& rIntl, const ::com::sun::star::lang::Locale& rLocale ); virtual ~SwTOXIndex() {} - virtual void FillText( SwTxtNode& rNd, const SwIndex& rInsPos, sal_uInt16 nAuthField = 0 ) const SAL_OVERRIDE; + virtual void FillText( SwTextNode& rNd, const SwIndex& rInsPos, sal_uInt16 nAuthField = 0 ) const SAL_OVERRIDE; virtual sal_uInt16 GetLevel() const SAL_OVERRIDE; virtual bool operator==( const SwTOXSortTabBase& ) SAL_OVERRIDE; virtual bool operator<( const SwTOXSortTabBase& ) SAL_OVERRIDE; @@ -218,11 +218,11 @@ private: */ struct SwTOXContent : public SwTOXSortTabBase { - SwTOXContent( const SwTxtNode&, const SwTxtTOXMark*, + SwTOXContent( const SwTextNode&, const SwTextTOXMark*, const SwTOXInternational& rIntl ); virtual ~SwTOXContent() {} - virtual void FillText( SwTxtNode& rNd, const SwIndex& rInsPos, sal_uInt16 nAuthField = 0 ) const SAL_OVERRIDE; + virtual void FillText( SwTextNode& rNd, const SwIndex& rInsPos, sal_uInt16 nAuthField = 0 ) const SAL_OVERRIDE; virtual sal_uInt16 GetLevel() const SAL_OVERRIDE; private: virtual TextAndReading GetText_Impl() const SAL_OVERRIDE; @@ -231,13 +231,13 @@ private: struct SwTOXPara : public SwTOXSortTabBase { - SwTOXPara( const SwCntntNode&, SwTOXElement, sal_uInt16 nLevel = FORM_ALPHA_DELIMITTER, const OUString& sSeqName = OUString() ); + SwTOXPara( const SwContentNode&, SwTOXElement, sal_uInt16 nLevel = FORM_ALPHA_DELIMITTER, const OUString& sSeqName = OUString() ); virtual ~SwTOXPara() {} void SetStartIndex(sal_Int32 nSet) { nStartIndex = nSet; } void SetEndIndex(sal_Int32 nSet) { nEndIndex = nSet; } - virtual void FillText( SwTxtNode& rNd, const SwIndex& rInsPos, sal_uInt16 nAuthField = 0 ) const SAL_OVERRIDE; + virtual void FillText( SwTextNode& rNd, const SwIndex& rInsPos, sal_uInt16 nAuthField = 0 ) const SAL_OVERRIDE; virtual sal_uInt16 GetLevel() const SAL_OVERRIDE; virtual OUString GetURL() const SAL_OVERRIDE; @@ -253,7 +253,7 @@ private: struct SwTOXTable : public SwTOXSortTabBase { - SwTOXTable( const SwCntntNode& rNd ); + SwTOXTable( const SwContentNode& rNd ); virtual ~SwTOXTable() {} void SetLevel(sal_uInt16 nSet){nLevel = nSet;} @@ -270,15 +270,15 @@ private: struct SwTOXAuthority : public SwTOXSortTabBase { private: - SwFmtFld& m_rField; - virtual void FillText( SwTxtNode& rNd, const SwIndex& rInsPos, sal_uInt16 nAuthField = 0 ) const SAL_OVERRIDE; + SwFormatField& m_rField; + virtual void FillText( SwTextNode& rNd, const SwIndex& rInsPos, sal_uInt16 nAuthField = 0 ) const SAL_OVERRIDE; virtual TextAndReading GetText_Impl() const SAL_OVERRIDE; public: - SwTOXAuthority( const SwCntntNode& rNd, SwFmtFld& rField, const SwTOXInternational& rIntl ); + SwTOXAuthority( const SwContentNode& rNd, SwFormatField& rField, const SwTOXInternational& rIntl ); virtual ~SwTOXAuthority() {} - SwFmtFld& GetFldFmt() {return m_rField;} + SwFormatField& GetFieldFormat() {return m_rField;} virtual bool operator==( const SwTOXSortTabBase& ) SAL_OVERRIDE; virtual bool operator<( const SwTOXSortTabBase& ) SAL_OVERRIDE; diff --git a/sw/source/core/inc/txtfly.hxx b/sw/source/core/inc/txtfly.hxx index 4fe14f436b90..bdb26e4bb778 100644 --- a/sw/source/core/inc/txtfly.hxx +++ b/sw/source/core/inc/txtfly.hxx @@ -25,15 +25,15 @@ #include <vector> class OutputDevice; -class SwCntntFrm; +class SwContentFrm; class SwPageFrm; -class SwTxtFly; +class SwTextFly; class SdrObject; -class SwTxtPaintInfo; -class SwFmt; +class SwTextPaintInfo; +class SwFormat; class TextRanger; class SwAnchoredObject; -class SwTxtFrm; +class SwTextFrm; class SwDrawTextInfo; class SwContourCache; @@ -59,8 +59,8 @@ class SwContourCache TextRanger *pTextRanger[ POLY_CNT ]; long nPntCnt; sal_uInt16 nObjCnt; - const SwRect ContourRect( const SwFmt* pFmt, const SdrObject* pObj, - const SwTxtFrm* pFrm, const SwRect &rLine, const long nXPos, + const SwRect ContourRect( const SwFormat* pFormat, const SdrObject* pObj, + const SwTextFrm* pFrm, const SwRect &rLine, const long nXPos, const bool bRight ); public: @@ -79,7 +79,7 @@ public: */ static const SwRect CalcBoundRect( const SwAnchoredObject* pAnchoredObj, const SwRect &rLine, - const SwTxtFrm* pFrm, + const SwTextFrm* pFrm, const long nXPos, const bool bRight ); }; @@ -87,11 +87,11 @@ public: /** The purpose of this class is to be the universal interface between formatting/text output and the possibly overlapping free-flying frames. - During formatting the formatter gets the information from SwTxtFly, whether + During formatting the formatter gets the information from SwTextFly, whether a certain area is present by the attributes of an overlapping frame. Such areas are represented by dummy portions. - The whole text output and touch-up is, again, forwarded to a SwTxtFly. + The whole text output and touch-up is, again, forwarded to a SwTextFly. This one decides, whether parts of the text need to be clipped and splits the areas for e.g. a DrawRect. @@ -116,12 +116,12 @@ public: Every frame can push away text, with the restriction that it only has influence until the next frame. */ -class SwTxtFly +class SwTextFly { const SwPageFrm * pPage; const SwAnchoredObject * mpCurrAnchoredObj; - const SwTxtFrm * pCurrFrm; - const SwCntntFrm * pMaster; + const SwTextFrm * pCurrFrm; + const SwContentFrm * pMaster; SwAnchoredObjList * mpAnchoredObjList; long nMinBottom; @@ -196,21 +196,21 @@ class SwTxtFly SwAnchoredObjList::size_type GetPos( const SwAnchoredObject* pAnchoredObj ) const; bool GetTop( const SwAnchoredObject* _pAnchoredObj, - const bool bInFtn, + const bool bInFootnote, const bool bInFooterOrHeader ); SwTwips CalcMinBottom() const; - const SwCntntFrm* _GetMaster(); + const SwContentFrm* _GetMaster(); public: - SwTxtFly(); - SwTxtFly( const SwTxtFrm *pFrm ); - SwTxtFly( const SwTxtFly& rTxtFly ); - ~SwTxtFly(); + SwTextFly(); + SwTextFly( const SwTextFrm *pFrm ); + SwTextFly( const SwTextFly& rTextFly ); + ~SwTextFly(); - void CtorInitTxtFly( const SwTxtFrm *pFrm ); + void CtorInitTextFly( const SwTextFrm *pFrm ); void SetTopRule(); @@ -227,7 +227,7 @@ public: bool Relax(); SwTwips GetMinBottom() const; - const SwCntntFrm* GetMaster() const; + const SwContentFrm* GetMaster() const; // This temporary variable needs to be manipulated in const methods long GetNextTop() const; @@ -266,10 +266,10 @@ public: won't be scribbled */ void DrawFlyRect( OutputDevice* pOut, const SwRect &rRect, - const SwTxtPaintInfo &rInf, bool bNoGraphic = false ); + const SwTextPaintInfo &rInf, bool bNoGraphic = false ); /** - Used to switch off the SwTxtFly when there is no overlapping object (Relax). + Used to switch off the SwTextFly when there is no overlapping object (Relax). \param[in] the line area \return whether the line will be overlapped by a frame @@ -299,24 +299,24 @@ public: void SetIgnoreObjsInHeaderFooter( const bool bNew ); }; -inline SwAnchoredObjList* SwTxtFly::GetAnchoredObjList() const +inline SwAnchoredObjList* SwTextFly::GetAnchoredObjList() const { return mpAnchoredObjList ? mpAnchoredObjList - : const_cast<SwTxtFly*>(this)->InitAnchoredObjList(); + : const_cast<SwTextFly*>(this)->InitAnchoredObjList(); } -inline void SwTxtFly::SetTopRule() +inline void SwTextFly::SetTopRule() { bTopRule = false; } -inline bool SwTxtFly::IsOn() const +inline bool SwTextFly::IsOn() const { return bOn; } -inline bool SwTxtFly::Relax( const SwRect &rRect ) +inline bool SwTextFly::Relax( const SwRect &rRect ) { if (bOn) { @@ -325,7 +325,7 @@ inline bool SwTxtFly::Relax( const SwRect &rRect ) return bOn; } -inline bool SwTxtFly::Relax() +inline bool SwTextFly::Relax() { if (bOn) { @@ -334,42 +334,42 @@ inline bool SwTxtFly::Relax() return bOn; } -inline SwTwips SwTxtFly::GetMinBottom() const +inline SwTwips SwTextFly::GetMinBottom() const { return mpAnchoredObjList ? nMinBottom : CalcMinBottom(); } -inline const SwCntntFrm* SwTxtFly::GetMaster() const +inline const SwContentFrm* SwTextFly::GetMaster() const { - return pMaster ? pMaster : const_cast<SwTxtFly*>(this)->_GetMaster(); + return pMaster ? pMaster : const_cast<SwTextFly*>(this)->_GetMaster(); } -inline long SwTxtFly::GetNextTop() const +inline long SwTextFly::GetNextTop() const { return nNextTop; } -inline void SwTxtFly::SetNextTop( long nNew ) const +inline void SwTextFly::SetNextTop( long nNew ) const { - const_cast<SwTxtFly*>(this)->nNextTop = nNew; + const_cast<SwTextFly*>(this)->nNextTop = nNew; } -inline SwRect SwTxtFly::GetFrm( const SwRect &rRect, bool bTop ) const +inline SwRect SwTextFly::GetFrm( const SwRect &rRect, bool bTop ) const { return bOn ? _GetFrm( rRect, bTop ) : SwRect(); } -inline void SwTxtFly::SetIgnoreCurrentFrame( bool bNew ) +inline void SwTextFly::SetIgnoreCurrentFrame( bool bNew ) { mbIgnoreCurrentFrame = bNew; } -inline void SwTxtFly::SetIgnoreContour( bool bNew ) +inline void SwTextFly::SetIgnoreContour( bool bNew ) { mbIgnoreContour = bNew; } -inline void SwTxtFly::SetIgnoreObjsInHeaderFooter( const bool bNew ) +inline void SwTextFly::SetIgnoreObjsInHeaderFooter( const bool bNew ) { mbIgnoreObjsInHeaderFooter = bNew; } diff --git a/sw/source/core/inc/txtfrm.hxx b/sw/source/core/inc/txtfrm.hxx index 784db5f8e510..2d1418c49966 100644 --- a/sw/source/core/inc/txtfrm.hxx +++ b/sw/source/core/inc/txtfrm.hxx @@ -25,17 +25,17 @@ #include "ndtxt.hxx" class SwCharRange; -class SwTxtNode; -class SwTxtFormatter; -class SwTxtFormatInfo; +class SwTextNode; +class SwTextFormatter; +class SwTextFormatInfo; class SwParaPortion; class WidowsAndOrphans; class SwBodyFrm; -class SwTxtFtn; +class SwTextFootnote; class SwInterHyphInfo; // Hyphenate() class SwCache; class SwBorderAttrs; -class SwFrmFmt; +class SwFrameFormat; class OutputDevice; class SwTestFormat; struct SwCrsrMoveState; @@ -48,15 +48,15 @@ class SwWrongList; #define NON_PRINTING_CHARACTER_COLOR RGB_COLORDATA(0x26, 0x8b, 0xd2) /// Represents the visualization of a paragraph. -class SwTxtFrm: public SwCntntFrm +class SwTextFrm: public SwContentFrm { - friend class SwTxtIter; + friend class SwTextIter; friend class SwTestFormat; friend class WidowsAndOrphans; - friend class TxtFrmLockGuard; // May Lock()/Unlock() - friend bool sw_ChangeOffset( SwTxtFrm* pFrm, sal_Int32 nNew ); + friend class TextFrmLockGuard; // May Lock()/Unlock() + friend bool sw_ChangeOffset( SwTextFrm* pFrm, sal_Int32 nNew ); - static SwCache *pTxtCache; // Pointer to the Line Cache + static SwCache *pTextCache; // Pointer to the Line Cache static long nMinPrtLine; // This Line must not be underrun when printing // Hack for table cells stretching multiple pages @@ -64,11 +64,11 @@ class SwTxtFrm: public SwCntntFrm sal_uLong nThisLines :8; // Count of Lines of the Frame // The x position for flys anchored at this paragraph. - // These values are calculated in SwTxtFrm::CalcBaseOfstForFly() + // These values are calculated in SwTextFrm::CalcBaseOfstForFly() SwTwips mnFlyAnchorOfst; // The x position for wrap-through flys anchored at this paragraph. SwTwips mnFlyAnchorOfstNoWrap; - SwTwips mnFtnLine; + SwTwips mnFootnoteLine; // OD 2004-03-17 #i11860# - re-factoring of #i11859# // member for height of last line (value needed for proportional line spacing) SwTwips mnHeightOfLastLine; @@ -78,14 +78,14 @@ class SwTxtFrm: public SwCntntFrm // It is NOT used for the determination of printing area. SwTwips mnAdditionalFirstLineOffset; - sal_Int32 nOfst; // Is the offset in the Cntnt (character count) + sal_Int32 nOfst; // Is the offset in the Content (character count) sal_uInt16 nCacheIdx; // Index into the cache, USHRT_MAX if there's definitely no fitting object in the cache // Separates the Master and creates a Follow or adjusts the data in the Follow - void _AdjustFollow( SwTxtFormatter &rLine, const sal_Int32 nOffset, + void _AdjustFollow( SwTextFormatter &rLine, const sal_Int32 nOffset, const sal_Int32 nStrEnd, const sal_uInt8 nMode ); - inline void AdjustFollow( SwTxtFormatter &rLine, const sal_Int32 nOffset, + inline void AdjustFollow( SwTextFormatter &rLine, const sal_Int32 nOffset, const sal_Int32 nStrEnd, const sal_uInt8 nMode ); // Iterates all Lines and sets the line spacing using the attribute @@ -101,16 +101,16 @@ class SwTxtFrm: public SwCntntFrm inline void InvalidateRange( const SwCharRange &, const long = 0); // WidowsAndOrphans, AdjustFrm, AdjustFollow - void FormatAdjust( SwTxtFormatter &rLine, WidowsAndOrphans &rFrmBreak, + void FormatAdjust( SwTextFormatter &rLine, WidowsAndOrphans &rFrmBreak, const sal_Int32 nStrLen, const bool bDummy ); bool bLocked : 1; // In the Format? bool bWidow : 1; // Are we a Widow? bool bJustWidow : 1; // Did we just request to be a Widow? bool bEmpty : 1; // Are we an empty paragraph? - bool bInFtnConnect : 1; // Is in Connect at the moment - bool bFtn : 1; // Has at least one footnote - bool bRepaint : 1; // TxtFrm: Repaint is ready to be fetched + bool bInFootnoteConnect : 1; // Is in Connect at the moment + bool bFootnote : 1; // Has at least one footnote + bool bRepaint : 1; // TextFrm: Repaint is ready to be fetched bool bBlinkPor : 1; // Contains Blink Portions bool bFieldFollow : 1; // Start with Field rest of the Master bool bHasAnimation : 1; // Contains animated SwGrfNumPortion @@ -138,29 +138,29 @@ class SwTxtFrm: public SwCntntFrm void FillCrsrPos( SwFillData &rFill ) const; // Format exactly one Line - bool FormatLine( SwTxtFormatter &rLine, const bool bPrev ); + bool FormatLine( SwTextFormatter &rLine, const bool bPrev ); // In order to safe stack space, we split this method: // _Format calls _Format with parameters void _Format( SwParaPortion *pPara ); - void _Format( SwTxtFormatter &rLine, SwTxtFormatInfo &rInf, + void _Format( SwTextFormatter &rLine, SwTextFormatInfo &rInf, const bool bAdjust = false ); - void FormatOnceMore( SwTxtFormatter &rLine, SwTxtFormatInfo &rInf ); + void FormatOnceMore( SwTextFormatter &rLine, SwTextFormatInfo &rInf ); // Formats the Follow and ensures disposing on orphans - bool CalcFollow( const sal_Int32 nTxtOfst ); + bool CalcFollow( const sal_Int32 nTextOfst ); // Corrects the position from which we need to format - static sal_Int32 FindBrk(const OUString &rTxt, const sal_Int32 nStart, + static sal_Int32 FindBrk(const OUString &rText, const sal_Int32 nStart, const sal_Int32 nEnd); // inline branch - SwTwips _GetFtnFrmHeight() const; + SwTwips _GetFootnoteFrmHeight() const; // Outsourced to CalcPreps - bool CalcPrepFtnAdjust(); + bool CalcPrepFootnoteAdjust(); - // For Ftn and WidOrp: Forced validation + // For Footnote and WidOrp: Forced validation void ValidateFrm(); void ValidateBodyFrm(); @@ -168,7 +168,7 @@ class SwTxtFrm: public SwCntntFrm void SetPara( SwParaPortion *pNew, bool bDelete = true ); - bool _IsFtnNumFrm() const; + bool _IsFootnoteNumFrm() const; // Refresh formatting information bool FormatQuick( bool bForceQuickFormat ); @@ -199,14 +199,14 @@ class SwTxtFrm: public SwCntntFrm void _CalcHeightOfLastLine( const bool _bUseFont = false ); // ST2 - SwWrongList* _SmartTagScan ( const OUString& aTxtToScan, SwWrongList *pSmartTagList, + SwWrongList* _SmartTagScan ( const OUString& aTextToScan, SwWrongList *pSmartTagList, sal_Int32 nBegin,sal_Int32 nEnd, sal_Int32 nInsertPos, sal_Int32 nActPos, sal_Int32 &nChgStart, sal_Int32 &nChgEnd, sal_Int32 &nInvStart, sal_Int32 &nInvEnd); virtual void DestroyImpl() SAL_OVERRIDE; - virtual ~SwTxtFrm(); + virtual ~SwTextFrm(); protected: virtual void Modify( const SfxPoolItem*, const SfxPoolItem* ) SAL_OVERRIDE; @@ -222,13 +222,13 @@ public: void Init(); /// Is called by FormatSpelling() - SwRect _AutoSpell( const SwCntntNode*, sal_Int32 ); + SwRect _AutoSpell( const SwContentNode*, sal_Int32 ); /// Is called by FormatSpelling() - SwRect SmartTagScan( SwCntntNode* , sal_Int32 ); + SwRect SmartTagScan( SwContentNode* , sal_Int32 ); /// Is called by CollectAutoCmplWords() - void CollectAutoCmplWrds( SwCntntNode* , sal_Int32 ); + void CollectAutoCmplWrds( SwContentNode* , sal_Int32 ); /** * Returns the screen position of rPos. The values are relative to the upper @@ -316,30 +316,30 @@ public: bool& bRight, bool bInsertCrsr ); /// Methods to manage the FollowFrame - SwCntntFrm *SplitFrm( const sal_Int32 nTxtPos ); - SwCntntFrm *JoinFrm(); + SwContentFrm *SplitFrm( const sal_Int32 nTextPos ); + SwContentFrm *JoinFrm(); inline sal_Int32 GetOfst() const { return nOfst; } void _SetOfst( const sal_Int32 nNewOfst ); inline void SetOfst ( const sal_Int32 nNewOfst ); inline void ManipOfst ( const sal_Int32 nNewOfst ){ nOfst = nNewOfst; } - SwTxtFrm *GetFrmAtPos ( const SwPosition &rPos); - inline const SwTxtFrm *GetFrmAtPos ( const SwPosition &rPos) const; - SwTxtFrm& GetFrmAtOfst( const sal_Int32 nOfst ); + SwTextFrm *GetFrmAtPos ( const SwPosition &rPos); + inline const SwTextFrm *GetFrmAtPos ( const SwPosition &rPos) const; + SwTextFrm& GetFrmAtOfst( const sal_Int32 nOfst ); /// If there's a Follow and we don't contain text ourselves inline bool IsEmptyMaster() const { return GetFollow() && !GetFollow()->GetOfst(); } /// Returns the text portion we want to edit (for inline see underneath) - const OUString& GetTxt() const; - inline SwTxtNode *GetTxtNode() - { return static_cast< SwTxtNode* >( SwCntntFrm::GetNode()); } - inline const SwTxtNode *GetTxtNode() const - { return static_cast< const SwTxtNode* >( SwCntntFrm::GetNode()); } + const OUString& GetText() const; + inline SwTextNode *GetTextNode() + { return static_cast< SwTextNode* >( SwContentFrm::GetNode()); } + inline const SwTextNode *GetTextNode() const + { return static_cast< const SwTextNode* >( SwContentFrm::GetNode()); } - SwTxtFrm(SwTxtNode * const, SwFrm* ); + SwTextFrm(SwTextNode * const, SwFrm* ); /** - * SwCntntFrm: the shortcut for the Frames + * SwContentFrm: the shortcut for the Frames * If the void* casts wrongly, it's its own fault! * The void* must be checked for 0 in any case! */ @@ -381,7 +381,7 @@ public: // RTTI TYPEINFO_OVERRIDE(); - DECL_FIXEDMEMPOOL_NEWDEL(SwTxtFrm) + DECL_FIXEDMEMPOOL_NEWDEL(SwTextFrm) // Locking inline bool IsLocked() const { return bLocked; } @@ -389,8 +389,8 @@ public: inline bool IsWidow() const { return bWidow; } inline bool IsJustWidow() const { return bJustWidow; } inline bool IsEmpty() const { return bEmpty; } - inline bool HasFtn() const { return bFtn; } - inline bool IsInFtnConnect()const { return bInFtnConnect;} + inline bool HasFootnote() const { return bFootnote; } + inline bool IsInFootnoteConnect()const { return bInFootnoteConnect;} inline bool IsFieldFollow() const { return bFieldFollow;} inline void SetRepaint() const; @@ -400,16 +400,16 @@ public: inline void ResetBlinkPor() const; inline bool HasBlinkPor() const { return bBlinkPor; } inline void SetAnimation() const - { const_cast<SwTxtFrm*>(this)->bHasAnimation = true; } + { const_cast<SwTextFrm*>(this)->bHasAnimation = true; } inline bool HasAnimation() const { return bHasAnimation; } inline bool IsSwapped() const { return bIsSwapped; } /// Does the Frm have a local footnote (in this Frm or Follow)? #ifdef DBG_UTIL - void CalcFtnFlag( sal_Int32 nStop = COMPLETE_STRING ); //For testing SplitFrm + void CalcFootnoteFlag( sal_Int32 nStop = COMPLETE_STRING ); //For testing SplitFrm #else - void CalcFtnFlag(); + void CalcFootnoteFlag(); #endif /// Hidden @@ -424,20 +424,20 @@ public: */ void HideAndShowObjects(); - /// Ftn - void RemoveFtn( const sal_Int32 nStart = 0, + /// Footnote + void RemoveFootnote( const sal_Int32 nStart = 0, const sal_Int32 nLen = COMPLETE_STRING ); - inline SwTwips GetFtnFrmHeight() const; - SwTxtFrm *FindFtnRef( const SwTxtFtn *pFtn ); - inline const SwTxtFrm *FindFtnRef( const SwTxtFtn *pFtn ) const - { return const_cast<SwTxtFrm *>(this)->FindFtnRef( pFtn ); } - void ConnectFtn( SwTxtFtn *pFtn, const SwTwips nDeadLine ); + inline SwTwips GetFootnoteFrmHeight() const; + SwTextFrm *FindFootnoteRef( const SwTextFootnote *pFootnote ); + inline const SwTextFrm *FindFootnoteRef( const SwTextFootnote *pFootnote ) const + { return const_cast<SwTextFrm *>(this)->FindFootnoteRef( pFootnote ); } + void ConnectFootnote( SwTextFootnote *pFootnote, const SwTwips nDeadLine ); /** - * If we're a Ftn that grows towards its reference ... - * public, because it's needed by SwCntntFrm::MakeAll + * If we're a Footnote that grows towards its reference ... + * public, because it's needed by SwContentFrm::MakeAll */ - SwTwips GetFtnLine( const SwTxtFtn *pFtn ) const; + SwTwips GetFootnoteLine( const SwTextFootnote *pFootnote ) const; /** * Returns the left and the right margin document coordinates @@ -455,11 +455,11 @@ public: /// Returns the remaining height inline SwTwips GetRstHeight() const; - inline SwTxtFrm *GetFollow(); - inline const SwTxtFrm *GetFollow() const; + inline SwTextFrm *GetFollow(); + inline const SwTextFrm *GetFollow() const; /// Find the page number of ErgoSum and QuoVadis - SwTxtFrm *FindQuoVadisFrm(); + SwTextFrm *FindQuoVadisFrm(); /** * Makes up for formatting if the Idle Handler has struck @@ -469,10 +469,10 @@ public: * has to be avoided during painting. Therefore we need to pass the * information that we are currently in the paint process. */ - SwTxtFrm* GetFormatted( bool bForceQuickFormat = false ); + SwTextFrm* GetFormatted( bool bForceQuickFormat = false ); /// Will be moved soon - inline void SetFtn( const bool bNew ) { bFtn = bNew; } + inline void SetFootnote( const bool bNew ) { bFootnote = bNew; } /// Respect the Follows inline bool IsInside( const sal_Int32 nPos ) const; @@ -483,8 +483,8 @@ public: inline bool GetDropRect( SwRect &rRect ) const { return HasPara() && _GetDropRect( rRect ); } - static SwCache *GetTxtCache() { return pTxtCache; } - static void SetTxtCache( SwCache *pNew ) { pTxtCache = pNew; } + static SwCache *GetTextCache() { return pTextCache; } + static void SetTextCache( SwCache *pNew ) { pTextCache = pNew; } static long GetMinPrtLine() { return nMinPrtLine; } static void SetMinPrtLine( long nNew ) { nMinPrtLine = nNew; } @@ -495,9 +495,9 @@ public: /// Removes the Line information from the Cache void ClearPara(); - /// Am I a FtnFrm, with a number at the start of the paragraph? - inline bool IsFtnNumFrm() const - { return IsInFtn() && !GetIndPrev() && _IsFtnNumFrm(); } + /// Am I a FootnoteFrm, with a number at the start of the paragraph? + inline bool IsFootnoteNumFrm() const + { return IsInFootnote() && !GetIndPrev() && _IsFootnoteNumFrm(); } /** * Simulates a formatting as if there were not right margin or Flys or other @@ -529,10 +529,10 @@ public: sal_uInt16 FirstLineHeight() const; /// Rewires FlyInCntFrm, if nEnd > Index >= nStart - void MoveFlyInCnt( SwTxtFrm *pNew, sal_Int32 nStart, sal_Int32 nEnd ); + void MoveFlyInCnt( SwTextFrm *pNew, sal_Int32 nStart, sal_Int32 nEnd ); /// Calculates the position of FlyInCntFrms - sal_Int32 CalcFlyPos( SwFrmFmt* pSearch ); + sal_Int32 CalcFlyPos( SwFrameFormat* pSearch ); /// Determines the start position and step size of the register bool FillRegister( SwTwips& rRegStart, sal_uInt16& rRegDiff ); @@ -644,28 +644,28 @@ public: return mnHeightOfLastLine; } - static void repaintTextFrames( const SwTxtNode& rNode ); + static void repaintTextFrames( const SwTextNode& rNode ); virtual void dumpAsXmlAttributes(xmlTextWriterPtr writer) const SAL_OVERRIDE; }; -//use this to protect a SwTxtFrm for a given scope from getting merged with +//use this to protect a SwTextFrm for a given scope from getting merged with //its neighbour and thus deleted -class TxtFrmLockGuard +class TextFrmLockGuard { private: - SwTxtFrm *m_pTxtFrm; + SwTextFrm *m_pTextFrm; bool m_bOldLocked; public: //Lock pFrm for the lifetime of the Cut/Paste call, etc. to avoid - //SwTxtFrm::_AdjustFollow removing the pFrm we're trying to Make - TxtFrmLockGuard(SwFrm* pFrm) + //SwTextFrm::_AdjustFollow removing the pFrm we're trying to Make + TextFrmLockGuard(SwFrm* pFrm) { - m_pTxtFrm = pFrm->IsTxtFrm() ? static_cast<SwTxtFrm*>(pFrm) : 0; - if (m_pTxtFrm) + m_pTextFrm = pFrm->IsTextFrm() ? static_cast<SwTextFrm*>(pFrm) : 0; + if (m_pTextFrm) { - m_bOldLocked = m_pTxtFrm->IsLocked(); - m_pTxtFrm->Lock(); + m_bOldLocked = m_pTextFrm->IsLocked(); + m_pTextFrm->Lock(); } else { @@ -673,25 +673,25 @@ public: } } - ~TxtFrmLockGuard() + ~TextFrmLockGuard() { - if (m_pTxtFrm && !m_bOldLocked) - m_pTxtFrm->Unlock(); + if (m_pTextFrm && !m_bOldLocked) + m_pTextFrm->Unlock(); } }; -inline const SwParaPortion *SwTxtFrm::GetPara() const +inline const SwParaPortion *SwTextFrm::GetPara() const { - return const_cast<SwTxtFrm*>(this)->GetPara(); + return const_cast<SwTextFrm*>(this)->GetPara(); } -inline bool SwTxtFrm::HasPara() const +inline bool SwTextFrm::HasPara() const { return nCacheIdx!=USHRT_MAX && _HasPara(); } /// 9104: Frm().Height() - Prt().Height(), see widorp.cxx and 7455, 6114, 7908 -inline SwTwips SwTxtFrm::GetRstHeight() const +inline SwTwips SwTextFrm::GetRstHeight() const { return !GetUpper() ? 0 : static_cast<const SwFrm*>(GetUpper())->Frm().Top() + static_cast<const SwFrm*>(GetUpper())->Prt().Top() @@ -699,84 +699,84 @@ inline SwTwips SwTxtFrm::GetRstHeight() const - Frm().Top() - (Frm().Height() - Prt().Height()); } -inline SwTwips SwTxtFrm::GetLeftMargin() const +inline SwTwips SwTextFrm::GetLeftMargin() const { return Frm().Left() + Prt().Left(); } -inline SwTwips SwTxtFrm::GetRightMargin() const +inline SwTwips SwTextFrm::GetRightMargin() const { return Frm().Left() + Prt().Left() + Prt().Width(); } -inline SwTwips SwTxtFrm::GrowTst( const SwTwips nGrow ) +inline SwTwips SwTextFrm::GrowTst( const SwTwips nGrow ) { return Grow( nGrow, true ); } -inline bool SwTxtFrm::IsInside( const sal_Int32 nPos ) const +inline bool SwTextFrm::IsInside( const sal_Int32 nPos ) const { bool bRet = true; if( nPos < GetOfst() ) bRet = false; else { - const SwTxtFrm *pFoll = GetFollow(); + const SwTextFrm *pFoll = GetFollow(); if( pFoll && nPos >= pFoll->GetOfst() ) bRet = false; } return bRet; } -inline SwTwips SwTxtFrm::GetFtnFrmHeight() const +inline SwTwips SwTextFrm::GetFootnoteFrmHeight() const { - if( !IsFollow() && IsInFtn() && HasPara() ) - return _GetFtnFrmHeight(); + if( !IsFollow() && IsInFootnote() && HasPara() ) + return _GetFootnoteFrmHeight(); else return 0; } -inline const SwTxtFrm *SwTxtFrm::GetFollow() const +inline const SwTextFrm *SwTextFrm::GetFollow() const { - return static_cast<const SwTxtFrm*>(SwCntntFrm::GetFollow()); + return static_cast<const SwTextFrm*>(SwContentFrm::GetFollow()); } -inline SwTxtFrm *SwTxtFrm::GetFollow() +inline SwTextFrm *SwTextFrm::GetFollow() { - return static_cast<SwTxtFrm*>(SwCntntFrm::GetFollow()); + return static_cast<SwTextFrm*>(SwContentFrm::GetFollow()); } -inline const SwTxtFrm *SwTxtFrm::GetFrmAtPos( const SwPosition &rPos) const +inline const SwTextFrm *SwTextFrm::GetFrmAtPos( const SwPosition &rPos) const { - return const_cast<SwTxtFrm*>(this)->GetFrmAtPos( rPos ); + return const_cast<SwTextFrm*>(this)->GetFrmAtPos( rPos ); } -inline void SwTxtFrm::AdjustFollow( SwTxtFormatter &rLine, +inline void SwTextFrm::AdjustFollow( SwTextFormatter &rLine, const sal_Int32 nOffset, const sal_Int32 nStrEnd, const sal_uInt8 nMode ) { if ( HasFollow() ) _AdjustFollow( rLine, nOffset, nStrEnd, nMode ); } -inline void SwTxtFrm::SetOfst( const sal_Int32 nNewOfst ) +inline void SwTextFrm::SetOfst( const sal_Int32 nNewOfst ) { if ( nOfst != nNewOfst ) _SetOfst( nNewOfst ); } -inline void SwTxtFrm::SetRepaint() const +inline void SwTextFrm::SetRepaint() const { - const_cast<SwTxtFrm*>(this)->bRepaint = true; + const_cast<SwTextFrm*>(this)->bRepaint = true; } -inline void SwTxtFrm::ResetRepaint() const +inline void SwTextFrm::ResetRepaint() const { - const_cast<SwTxtFrm*>(this)->bRepaint = false; + const_cast<SwTextFrm*>(this)->bRepaint = false; } -inline void SwTxtFrm::SetBlinkPor() const +inline void SwTextFrm::SetBlinkPor() const { - const_cast<SwTxtFrm*>(this)->bBlinkPor = true; + const_cast<SwTextFrm*>(this)->bBlinkPor = true; } -inline void SwTxtFrm::ResetBlinkPor() const +inline void SwTextFrm::ResetBlinkPor() const { - const_cast<SwTxtFrm*>(this)->bBlinkPor = false; + const_cast<SwTextFrm*>(this)->bBlinkPor = false; } #define SWAP_IF_SWAPPED( pFrm )\ @@ -784,7 +784,7 @@ inline void SwTxtFrm::ResetBlinkPor() const if ( pFrm->IsVertical() && pFrm->IsSwapped() )\ { \ bUndoSwap = true; \ - const_cast<SwTxtFrm*>(pFrm)->SwapWidthAndHeight(); \ + const_cast<SwTextFrm*>(pFrm)->SwapWidthAndHeight(); \ } #define SWAP_IF_NOT_SWAPPED( pFrm )\ @@ -792,12 +792,12 @@ inline void SwTxtFrm::ResetBlinkPor() const if ( pFrm->IsVertical() && ! pFrm->IsSwapped() )\ { \ bUndoSwap = true; \ - const_cast<SwTxtFrm*>(pFrm)->SwapWidthAndHeight(); \ + const_cast<SwTextFrm*>(pFrm)->SwapWidthAndHeight(); \ } #define UNDO_SWAP( pFrm )\ if ( bUndoSwap )\ - const_cast<SwTxtFrm*>(pFrm)->SwapWidthAndHeight(); + const_cast<SwTextFrm*>(pFrm)->SwapWidthAndHeight(); /** * Helper class which can be used instead of the macros if a function @@ -805,10 +805,10 @@ inline void SwTxtFrm::ResetBlinkPor() const */ class SwFrmSwapper { - const SwTxtFrm* pFrm; + const SwTextFrm* pFrm; bool bUndo; public: - SwFrmSwapper( const SwTxtFrm* pFrm, bool bSwapIfNotSwapped ); + SwFrmSwapper( const SwTextFrm* pFrm, bool bSwapIfNotSwapped ); ~SwFrmSwapper(); }; diff --git a/sw/source/core/inc/undoflystrattr.hxx b/sw/source/core/inc/undoflystrattr.hxx index 93611f173f35..66440e8696eb 100644 --- a/sw/source/core/inc/undoflystrattr.hxx +++ b/sw/source/core/inc/undoflystrattr.hxx @@ -22,12 +22,12 @@ #include <undobj.hxx> #include <swundo.hxx> -class SwFlyFrmFmt; +class SwFlyFrameFormat; class SwUndoFlyStrAttr : public SwUndo { public: - SwUndoFlyStrAttr( SwFlyFrmFmt& rFlyFrmFmt, + SwUndoFlyStrAttr( SwFlyFrameFormat& rFlyFrameFormat, const SwUndoId eUndoId, const OUString& sOldStr, const OUString& sNewStr ); @@ -39,7 +39,7 @@ class SwUndoFlyStrAttr : public SwUndo virtual SwRewriter GetRewriter() const SAL_OVERRIDE; private: - SwFlyFrmFmt& mrFlyFrmFmt; + SwFlyFrameFormat& mrFlyFrameFormat; const OUString msOldStr; const OUString msNewStr; }; diff --git a/sw/source/core/inc/unoevent.hxx b/sw/source/core/inc/unoevent.hxx index cc0ff3364d4f..26fb808c7ebf 100644 --- a/sw/source/core/inc/unoevent.hxx +++ b/sw/source/core/inc/unoevent.hxx @@ -29,7 +29,7 @@ class SwXTextFrame; class SwXTextGraphicObject; class SwXTextEmbeddedObject; class SwXFrameStyle; -class SwFmtINetFmt; +class SwFormatINetFormat; class SwHyperlinkEventDescriptor : public SvDetachedEventDescriptor { @@ -44,8 +44,8 @@ public: SwHyperlinkEventDescriptor(); - void copyMacrosFromINetFmt(const SwFmtINetFmt& aFmt); - void copyMacrosIntoINetFmt(SwFmtINetFmt& aFmt); + void copyMacrosFromINetFormat(const SwFormatINetFormat& aFormat); + void copyMacrosIntoINetFormat(SwFormatINetFormat& aFormat); void copyMacrosFromNameReplace( ::com::sun::star::uno::Reference< diff --git a/sw/source/core/inc/unofield.hxx b/sw/source/core/inc/unofield.hxx index 3b30ee143793..b2aa572d9cdb 100644 --- a/sw/source/core/inc/unofield.hxx +++ b/sw/source/core/inc/unofield.hxx @@ -32,7 +32,7 @@ class SwFieldType; class SwDoc; -class SwFmtFld; +class SwFormatField; class SwField; class SwSetExpField; class SwTextAPIObject; @@ -67,9 +67,9 @@ public: sal_uInt16 nResId = 0xFFFF); static OUString GetProgrammaticName(const SwFieldType& rType, SwDoc& rDoc); - static OUString LocalizeFormula(const SwSetExpField& rFld, const OUString& rFormula, bool bQuery); + static OUString LocalizeFormula(const SwSetExpField& rField, const OUString& rFormula, bool bQuery); - SwFieldType* GetFldType(bool bDontCreate = false) const; + SwFieldType* GetFieldType(bool bDontCreate = false) const; static const ::com::sun::star::uno::Sequence< sal_Int8 > & getUnoTunnelId(); @@ -167,7 +167,7 @@ private: virtual ~SwXTextField(); - SwXTextField(SwFmtFld& rFmt, SwDoc & rDoc); + SwXTextField(SwFormatField& rFormat, SwDoc & rDoc); /// descriptor SwXTextField(sal_uInt16 nServiceId, SwDoc* pDoc=0); @@ -177,7 +177,7 @@ public: /// @return an SwXTextField, either an already existing one or a new one static ::com::sun::star::uno::Reference< ::com::sun::star::text::XTextField> - CreateXTextField(SwDoc * pDoc, SwFmtFld const* pFmt, + CreateXTextField(SwDoc * pDoc, SwFormatField const* pFormat, sal_uInt16 nServiceId = 0xFFFF); static const ::com::sun::star::uno::Sequence< sal_Int8 > & getUnoTunnelId(); diff --git a/sw/source/core/inc/unoflatpara.hxx b/sw/source/core/inc/unoflatpara.hxx index 247243939425..71182ecb4685 100644 --- a/sw/source/core/inc/unoflatpara.hxx +++ b/sw/source/core/inc/unoflatpara.hxx @@ -40,7 +40,7 @@ namespace com { namespace sun { namespace star { namespace text { class XTextRange; } } } } -class SwTxtNode; +class SwTextNode; class SwDoc; typedef ::cppu::ImplInheritanceHelper @@ -54,7 +54,7 @@ class SwXFlatParagraph : public SwXFlatParagraph_Base { public: - SwXFlatParagraph( SwTxtNode& rTxtNode, const OUString& aExpandText, const ModelToViewHelper& rConversionMap ); + SwXFlatParagraph( SwTextNode& rTextNode, const OUString& aExpandText, const ModelToViewHelper& rConversionMap ); virtual ~SwXFlatParagraph(); // XPropertySet @@ -124,7 +124,7 @@ public: virtual void SAL_CALL changeAttributes(::sal_Int32 nPos, ::sal_Int32 nLen, const css::uno::Sequence< css::beans::PropertyValue > & aAttributes) throw (css::uno::RuntimeException, css::lang::IllegalArgumentException, std::exception) SAL_OVERRIDE; virtual css::uno::Sequence< ::sal_Int32 > SAL_CALL getLanguagePortions() throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE; - using SwXTextMarkup::GetTxtNode; + using SwXTextMarkup::GetTextNode; static const css::uno::Sequence< sal_Int8 >& getUnoTunnelId(); diff --git a/sw/source/core/inc/unofootnote.hxx b/sw/source/core/inc/unofootnote.hxx index fdf9cf9f90cf..67eae2330250 100644 --- a/sw/source/core/inc/unofootnote.hxx +++ b/sw/source/core/inc/unofootnote.hxx @@ -33,7 +33,7 @@ class SwDoc; class SwModify; -class SwFmtFtn; +class SwFormatFootnote; typedef ::cppu::WeakImplHelper < ::com::sun::star::lang::XUnoTunnel @@ -66,13 +66,13 @@ protected: virtual ~SwXFootnote(); - SwXFootnote(SwDoc & rDoc, SwFmtFtn & rFmt); + SwXFootnote(SwDoc & rDoc, SwFormatFootnote & rFormat); SwXFootnote(const bool bEndnote); public: static css::uno::Reference<css::text::XFootnote> - CreateXFootnote(SwDoc & rDoc, SwFmtFtn * pFootnoteFmt, + CreateXFootnote(SwDoc & rDoc, SwFormatFootnote * pFootnoteFormat, bool isEndnote = false); // XInterface diff --git a/sw/source/core/inc/unometa.hxx b/sw/source/core/inc/unometa.hxx index e292b3bb0e0e..46523e26484a 100644 --- a/sw/source/core/inc/unometa.hxx +++ b/sw/source/core/inc/unometa.hxx @@ -42,7 +42,7 @@ typedef ::std::deque< TextRangeList_t; class SwPaM; -class SwTxtNode; +class SwTextNode; namespace sw { class Meta; @@ -104,7 +104,7 @@ public: /// init params with position of the attribute content (w/out CH_TXTATR) bool SetContentRange( - SwTxtNode *& rpNode, sal_Int32 & rStart, sal_Int32 & rEnd) const; + SwTextNode *& rpNode, sal_Int32 & rStart, sal_Int32 & rEnd) const; ::com::sun::star::uno::Reference< ::com::sun::star::text::XText > GetParentText() const; diff --git a/sw/source/core/inc/unoparaframeenum.hxx b/sw/source/core/inc/unoparaframeenum.hxx index bdbf12507e14..e4f001de58bf 100644 --- a/sw/source/core/inc/unoparaframeenum.hxx +++ b/sw/source/core/inc/unoparaframeenum.hxx @@ -35,7 +35,7 @@ class SwDepend; class SwNodeIndex; class SwPaM; -class SwFrmFmt; +class SwFrameFormat; struct FrameDependSortListEntry { @@ -85,7 +85,7 @@ private: public: SwXParaFrameEnumeration(const SwPaM& rPaM, - const enum ParaFrameMode eParaFrameMode, SwFrmFmt *const pFmt = 0); + const enum ParaFrameMode eParaFrameMode, SwFrameFormat *const pFormat = 0); // XServiceInfo virtual OUString SAL_CALL getImplementationName() diff --git a/sw/source/core/inc/unoport.hxx b/sw/source/core/inc/unoport.hxx index 9a82ca09c6bd..4c35e0031d24 100644 --- a/sw/source/core/inc/unoport.hxx +++ b/sw/source/core/inc/unoport.hxx @@ -43,10 +43,10 @@ #include <calbck.hxx> #include <unobaseclass.hxx> -class SwFmtFld; -class SwFrmFmt; +class SwFormatField; +class SwFrameFormat; class SwRangeRedline; -class SwTxtRuby; +class SwTextRuby; typedef ::std::deque< ::com::sun::star::uno::Reference< ::com::sun::star::text::XTextRange > > @@ -116,12 +116,12 @@ private: ::std::unique_ptr< ::com::sun::star::uno::Any > m_pRubyIsAbove; const SwDepend m_FrameDepend; - SwFrmFmt * m_pFrameFmt; + SwFrameFormat * m_pFrameFormat; const SwTextPortionType m_ePortionType; bool m_bIsCollapsed; - SwFmtFld * GetFldFmt(bool bInit = false); + SwFormatField * GetFieldFormat(bool bInit = false); void init(const SwUnoCrsr* pPortionCursor); @@ -153,11 +153,11 @@ protected: public: SwXTextPortion(const SwUnoCrsr* pPortionCrsr, ::com::sun::star::uno::Reference< ::com::sun::star::text::XText > const& rParent, SwTextPortionType eType ); - SwXTextPortion(const SwUnoCrsr* pPortionCrsr, ::com::sun::star::uno::Reference< ::com::sun::star::text::XText > const& rParent, SwFrmFmt& rFmt ); + SwXTextPortion(const SwUnoCrsr* pPortionCrsr, ::com::sun::star::uno::Reference< ::com::sun::star::text::XText > const& rParent, SwFrameFormat& rFormat ); // for Ruby SwXTextPortion(const SwUnoCrsr* pPortionCrsr, - SwTxtRuby const& rAttr, + SwTextRuby const& rAttr, ::com::sun::star::uno::Reference< ::com::sun::star::text::XText > const& xParent, bool bIsEnd ); diff --git a/sw/source/core/inc/unorefmark.hxx b/sw/source/core/inc/unorefmark.hxx index 6874d939de0d..29641aa16384 100644 --- a/sw/source/core/inc/unorefmark.hxx +++ b/sw/source/core/inc/unorefmark.hxx @@ -32,7 +32,7 @@ class SwDoc; class SwModify; -class SwFmtRefMark; +class SwFormatRefMark; typedef ::cppu::WeakImplHelper < ::com::sun::star::lang::XUnoTunnel @@ -53,12 +53,12 @@ private: virtual ~SwXReferenceMark(); - SwXReferenceMark(SwDoc *const pDoc, SwFmtRefMark *const pMark); + SwXReferenceMark(SwDoc *const pDoc, SwFormatRefMark *const pMark); public: static css::uno::Reference<css::text::XTextContent> - CreateXReferenceMark(SwDoc & rDoc, SwFmtRefMark * pMarkFmt); + CreateXReferenceMark(SwDoc & rDoc, SwFormatRefMark * pMarkFormat); static const ::com::sun::star::uno::Sequence< sal_Int8 >& getUnoTunnelId(); diff --git a/sw/source/core/inc/unosection.hxx b/sw/source/core/inc/unosection.hxx index 651151ef76d1..bfca3adfa9bc 100644 --- a/sw/source/core/inc/unosection.hxx +++ b/sw/source/core/inc/unosection.hxx @@ -35,7 +35,7 @@ #include <unobaseclass.hxx> -class SwSectionFmt; +class SwSectionFormat; struct SwTextSectionProperties_Impl; @@ -59,17 +59,17 @@ private: class Impl; ::sw::UnoImplPtr<Impl> m_pImpl; - SwXTextSection(SwSectionFmt *const pFmt, const bool bIndexHeader = false); + SwXTextSection(SwSectionFormat *const pFormat, const bool bIndexHeader = false); virtual ~SwXTextSection(); public: - SwSectionFmt* GetFmt() const; + SwSectionFormat* GetFormat() const; static ::com::sun::star::uno::Reference< ::com::sun::star::text::XTextSection > - CreateXTextSection(SwSectionFmt *const pFmt = 0, + CreateXTextSection(SwSectionFormat *const pFormat = 0, const bool bIndexHeader = false); // MetadatableMixin diff --git a/sw/source/core/inc/unotextmarkup.hxx b/sw/source/core/inc/unotextmarkup.hxx index e7d8a0ea19e3..652e1f535123 100644 --- a/sw/source/core/inc/unotextmarkup.hxx +++ b/sw/source/core/inc/unotextmarkup.hxx @@ -37,7 +37,7 @@ namespace com { namespace sun { namespace star { namespace text { class XTextRange; } } } } -class SwTxtNode; +class SwTextNode; class ModelToViewHelper; class SfxPoolItem; @@ -50,7 +50,7 @@ class SwXTextMarkup > { public: - SwXTextMarkup(SwTxtNode *const rTxtNode, + SwXTextMarkup(SwTextNode *const rTextNode, const ModelToViewHelper& rConversionMap); virtual ~SwXTextMarkup(); @@ -74,8 +74,8 @@ private: ::sw::UnoImplPtr<Impl> m_pImpl; protected: - SwTxtNode* GetTxtNode(); - void ClearTxtNode(); + SwTextNode* GetTextNode(); + void ClearTextNode(); const ModelToViewHelper& GetConversionMap(); }; diff --git a/sw/source/core/inc/viewimp.hxx b/sw/source/core/inc/viewimp.hxx index 923eee01a7f2..2028eadc4f87 100644 --- a/sw/source/core/inc/viewimp.hxx +++ b/sw/source/core/inc/viewimp.hxx @@ -44,7 +44,7 @@ class Fraction; class SwPrintData; class SwPagePreviewLayout; struct PreviewPage; -class SwTxtFrm; +class SwTextFrm; // --> OD #i76669# namespace sdr { namespace contact { class ViewObjectContactRedirector; @@ -106,18 +106,18 @@ private: implementation for wrapper method <SwViewShell::InvalidateAccessibleParaFlowRelation(..)> - @param _pFromTxtFrm + @param _pFromTextFrm input parameter - paragraph frame, for which the relation CONTENT_FLOWS_FROM has to be invalidated. If NULL, no CONTENT_FLOWS_FROM relation has to be invalidated - @param _pToTxtFrm + @param _pToTextFrm input parameter - paragraph frame, for which the relation CONTENT_FLOWS_TO has to be invalidated. If NULL, no CONTENT_FLOWS_TO relation has to be invalidated */ - void _InvalidateAccessibleParaFlowRelation( const SwTxtFrm* _pFromTxtFrm, - const SwTxtFrm* _pToTxtFrm ); + void _InvalidateAccessibleParaFlowRelation( const SwTextFrm* _pFromTextFrm, + const SwTextFrm* _pToTextFrm ); /** invalidate text selection for paragraphs @@ -133,7 +133,7 @@ private: implementation for wrapper method <SwViewShell::InvalidateAccessibleParaAttrs(..)> */ - void _InvalidateAccessibleParaAttrs( const SwTxtFrm& rTxtFrm ); + void _InvalidateAccessibleParaAttrs( const SwTextFrm& rTextFrm ); public: SwViewShellImp( SwViewShell * ); @@ -208,7 +208,7 @@ public: * * There we also set the Flag for ExpressionFields */ - bool IsUpdateExpFlds(); + bool IsUpdateExpFields(); void SetRestoreActions(sal_uInt16 nSet){nRestoreActions = nSet;} sal_uInt16 GetRestoreActions() const{return nRestoreActions;} |