diff options
Diffstat (limited to 'sw/source/uibase/frmdlg')
| -rw-r--r-- | sw/source/uibase/frmdlg/colex.cxx | 607 | ||||
| -rw-r--r-- | sw/source/uibase/frmdlg/colmgr.cxx | 161 | ||||
| -rw-r--r-- | sw/source/uibase/frmdlg/frmmgr.cxx | 613 |
3 files changed, 1381 insertions, 0 deletions
diff --git a/sw/source/uibase/frmdlg/colex.cxx b/sw/source/uibase/frmdlg/colex.cxx new file mode 100644 index 000000000..8d458f016 --- /dev/null +++ b/sw/source/uibase/frmdlg/colex.cxx @@ -0,0 +1,607 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <cmdid.h> +#include <hintids.hxx> +#include <svl/eitem.hxx> +#include <tools/fract.hxx> +#include <editeng/lrspitem.hxx> +#include <editeng/ulspitem.hxx> +#include <editeng/sizeitem.hxx> +#include <svx/pageitem.hxx> +#include <editeng/brushitem.hxx> +#include <editeng/frmdiritem.hxx> +#include <vcl/outdev.hxx> +#include <vcl/settings.hxx> +#include <tgrditem.hxx> +#include <viewopt.hxx> +#include <colex.hxx> +#include <colmgr.hxx> +#include <svx/unobrushitemhelper.hxx> + +void SwPageExample::UpdateExample( const SfxItemSet& rSet ) +{ + if (SfxItemState::DEFAULT <= rSet.GetItemState(RES_FRAMEDIR)) + { + const SvxFrameDirectionItem& rDirItem = rSet.Get(RES_FRAMEDIR); + m_bVertical = rDirItem.GetValue() == SvxFrameDirection::Vertical_RL_TB|| + rDirItem.GetValue() == SvxFrameDirection::Vertical_LR_TB; + } + + SfxItemPool* pPool = rSet.GetPool(); + sal_uInt16 nWhich = pPool->GetWhich( SID_ATTR_PAGE ); + if ( rSet.GetItemState( nWhich, false ) == SfxItemState::SET ) + { + // alignment + const SvxPageItem& rPage = static_cast<const SvxPageItem&>(rSet.Get(nWhich)); + SetUsage(rPage.GetPageUsage()); + } + + nWhich = pPool->GetWhich( SID_ATTR_PAGE_SIZE ); + + if ( rSet.GetItemState( nWhich, false ) == SfxItemState::SET ) + { + // orientation and size from PageItem + const SvxSizeItem& rSize = static_cast<const SvxSizeItem&>(rSet.Get( nWhich )); + SetSize( rSize.GetSize() ); + } + nWhich = RES_LR_SPACE; + if ( rSet.GetItemState( nWhich, false ) == SfxItemState::SET ) + { + // set left and right border + const SvxLRSpaceItem& rLRSpace = static_cast<const SvxLRSpaceItem&>(rSet.Get( nWhich )); + + SetLeft( rLRSpace.GetLeft() ); + SetRight( rLRSpace.GetRight() ); + } + else + { + SetLeft( 0 ); + SetRight( 0 ); + } + + nWhich = RES_UL_SPACE; + + if ( rSet.GetItemState( nWhich, false ) == SfxItemState::SET ) + { + // set upper and lower border + const SvxULSpaceItem& rULSpace = static_cast<const SvxULSpaceItem&>(rSet.Get( nWhich )); + + SetTop( rULSpace.GetUpper() ); + SetBottom( rULSpace.GetLower() ); + } + else + { + SetTop( 0 ); + SetBottom( 0 ); + } + + // evaluate header-attributes + const SfxPoolItem* pItem; + if( SfxItemState::SET == rSet.GetItemState( pPool->GetWhich( SID_ATTR_PAGE_HEADERSET), + false, &pItem ) ) + { + const SfxItemSet& rHeaderSet = static_cast<const SvxSetItem*>(pItem)->GetItemSet(); + const SfxBoolItem& rHeaderOn = + static_cast<const SfxBoolItem&>(rHeaderSet.Get( pPool->GetWhich( SID_ATTR_PAGE_ON ) ) ); + + if ( rHeaderOn.GetValue() ) + { + const SvxSizeItem& rSize = + static_cast<const SvxSizeItem&>(rHeaderSet.Get(pPool->GetWhich(SID_ATTR_PAGE_SIZE))); + + const SvxULSpaceItem& rUL = static_cast<const SvxULSpaceItem&>(rHeaderSet.Get( + pPool->GetWhich(SID_ATTR_ULSPACE))); + const SvxLRSpaceItem& rLR = static_cast<const SvxLRSpaceItem&>(rHeaderSet.Get( + pPool->GetWhich(SID_ATTR_LRSPACE))); + + SetHdHeight( rSize.GetSize().Height() - rUL.GetLower()); + SetHdDist( rUL.GetLower() ); + SetHdLeft( rLR.GetLeft() ); + SetHdRight( rLR.GetRight() ); + SetHeader( true ); + + if(SfxItemState::SET == rHeaderSet.GetItemState(RES_BACKGROUND)) + { + // create FillAttributes from SvxBrushItem //SetHdColor(rItem.GetColor()); + const SvxBrushItem& rItem = rHeaderSet.Get(RES_BACKGROUND); + SfxItemSet aTempSet(*rHeaderSet.GetPool(), svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{}); + + setSvxBrushItemAsFillAttributesToTargetSet(rItem, aTempSet); + setHeaderFillAttributes( + std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>( + aTempSet)); + } + } + else + SetHeader( false ); + } + + if( SfxItemState::SET == rSet.GetItemState( pPool->GetWhich( SID_ATTR_PAGE_FOOTERSET), + false, &pItem ) ) + { + const SfxItemSet& rFooterSet = static_cast<const SvxSetItem*>(pItem)->GetItemSet(); + const SfxBoolItem& rFooterOn = rFooterSet.Get( SID_ATTR_PAGE_ON ); + + if ( rFooterOn.GetValue() ) + { + const SvxSizeItem& rSize = + static_cast<const SvxSizeItem&>(rFooterSet.Get( pPool->GetWhich( SID_ATTR_PAGE_SIZE ) )); + + const SvxULSpaceItem& rUL = static_cast<const SvxULSpaceItem&>(rFooterSet.Get( + pPool->GetWhich( SID_ATTR_ULSPACE ) )); + const SvxLRSpaceItem& rLR = static_cast<const SvxLRSpaceItem&>(rFooterSet.Get( + pPool->GetWhich( SID_ATTR_LRSPACE ) )); + + SetFtHeight( rSize.GetSize().Height() - rUL.GetUpper()); + SetFtDist( rUL.GetUpper() ); + SetFtLeft( rLR.GetLeft() ); + SetFtRight( rLR.GetRight() ); + SetFooter( true ); + + if( rFooterSet.GetItemState( RES_BACKGROUND ) == SfxItemState::SET ) + { + // create FillAttributes from SvxBrushItem //SetFtColor(rItem.GetColor()); + const SvxBrushItem& rItem = rFooterSet.Get(RES_BACKGROUND); + SfxItemSet aTempSet(*rFooterSet.GetPool(), svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{}); + + setSvxBrushItemAsFillAttributesToTargetSet(rItem, aTempSet); + setFooterFillAttributes( + std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>( + aTempSet)); + } + } + else + SetFooter( false ); + } + + if(SfxItemState::SET == rSet.GetItemState(RES_BACKGROUND, false, &pItem)) + { + // create FillAttributes from SvxBrushItem + const SvxBrushItem& rItem = static_cast< const SvxBrushItem& >(*pItem); + SfxItemSet aTempSet(*rSet.GetPool(), svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{}); + + setSvxBrushItemAsFillAttributesToTargetSet(rItem, aTempSet); + setPageFillAttributes( + std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>( + aTempSet)); + } + + Invalidate(); +} + +void SwColExample::DrawPage(vcl::RenderContext& rRenderContext, const Point& rOrg, + const bool bSecond, const bool bEnabled) +{ + SwPageExample::DrawPage(rRenderContext, rOrg, bSecond, bEnabled); + if (!pColMgr) + return; + sal_uInt16 nColumnCount = pColMgr->GetCount(); + if (!nColumnCount) + return; + + long nL = GetLeft(); + long nR = GetRight(); + + if (GetUsage() == SvxPageUsage::Mirror && !bSecond) + { + // swap for mirrored + nL = GetRight(); + nR = GetLeft(); + } + + rRenderContext.SetFillColor(COL_LIGHTGRAY); + tools::Rectangle aRect; + aRect.SetRight( rOrg.X() + GetSize().Width() - nR ); + aRect.SetLeft( rOrg.X() + nL ); + aRect.SetTop( rOrg.Y() + GetTop() + GetHdHeight() + GetHdDist() ); + aRect.SetBottom( rOrg.Y() + GetSize().Height() - GetBottom() - GetFtHeight() - GetFtDist() ); + rRenderContext.DrawRect(aRect); + + const tools::Rectangle aDefineRect(aRect); + const drawinglayer::attribute::SdrAllFillAttributesHelperPtr& rFillAttributes = getPageFillAttributes(); + + if (!rFillAttributes || !rFillAttributes->isUsed()) + { + // If there is no fill, use fallback color + const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings(); + const Color& rFieldColor = rStyleSettings.GetFieldColor(); + + setPageFillAttributes( + std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>( + rFieldColor)); + } + + // #97495# make sure that the automatic column width's are always equal + bool bAutoWidth = pColMgr->IsAutoWidth(); + sal_Int32 nAutoColWidth = 0; + if (bAutoWidth) + { + sal_Int32 nColumnWidthSum = 0; + for (sal_uInt16 i = 0; i < nColumnCount; ++i) + nColumnWidthSum += pColMgr->GetColWidth( i ); + nAutoColWidth = nColumnWidthSum / nColumnCount; + } + + for (sal_uInt16 i = 0; i < nColumnCount; ++i) + { + if (!bAutoWidth) + nAutoColWidth = pColMgr->GetColWidth(i); + + if (!m_bVertical) + aRect.SetRight( aRect.Left() + nAutoColWidth ); + else + aRect.SetBottom( aRect.Top() + nAutoColWidth ); + + // use primitive draw command + drawFillAttributes(rRenderContext, getPageFillAttributes(), aRect, aDefineRect); + + if (i < nColumnCount - 1) + { + if (!m_bVertical) + aRect.SetLeft( aRect.Right() + pColMgr->GetGutterWidth(i) ); + else + aRect.SetTop( aRect.Bottom() + pColMgr->GetGutterWidth(i) ); + } + } + if (pColMgr->HasLine()) + { + Point aUp(rOrg.X() + nL, rOrg.Y() + GetTop()); + Point aDown(rOrg.X() + nL, + rOrg.Y() + GetSize().Height() - GetBottom() - GetFtHeight() - GetFtDist()); + + if (pColMgr->GetLineHeightPercent() != 100) + { + long nLength = !m_bVertical ? aDown.Y() - aUp.Y() : aDown.X() - aUp.X(); + nLength -= nLength * pColMgr->GetLineHeightPercent() / 100; + switch (pColMgr->GetAdjust()) + { + case COLADJ_BOTTOM: + if (!m_bVertical) + aUp.AdjustY(nLength ); + else + aUp.AdjustX(nLength ); + break; + case COLADJ_TOP: + if (!m_bVertical) + aDown.AdjustY( -nLength ); + else + aDown.AdjustX( -nLength ); + break; + case COLADJ_CENTER: + if (!m_bVertical) + { + aUp.AdjustY(nLength / 2 ); + aDown.AdjustY( -(nLength / 2) ); + } + else + { + aUp.AdjustX(nLength / 2 ); + aDown.AdjustX( -(nLength / 2) ); + } + break; + default: + break; // prevent warning + } + } + + for (sal_uInt16 i = 0; i < nColumnCount - 1; ++i) + { + int nGutter = pColMgr->GetGutterWidth(i); + int nDist = pColMgr->GetColWidth( i ) + nGutter; + nDist -= (i == 0) ? nGutter / 2 : 0; + if (!m_bVertical) + { + aUp.AdjustX(nDist ); + aDown.AdjustX(nDist ); + } + else + { + aUp.AdjustY(nDist ); + aDown.AdjustY(nDist ); + } + + rRenderContext.DrawLine(aUp, aDown); + } + } +} + +SwColumnOnlyExample::SwColumnOnlyExample() + : m_aFrameSize(SvxPaperInfo::GetPaperSize(PAPER_A4)) // DIN A4 +{ + ::FitToActualSize(m_aCols, static_cast<sal_uInt16>(m_aFrameSize.Width())); +} + +void SwColumnOnlyExample::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& /*rRect*/) +{ + rRenderContext.Push(PushFlags::MAPMODE); + + Fraction aScale(m_aWinSize.Height(), m_aFrameSize.Height()); + MapMode aMapMode(MapUnit::MapTwip); + aMapMode.SetScaleX(aScale); + aMapMode.SetScaleY(aScale); + rRenderContext.SetMapMode(aMapMode); + + const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings(); + const Color& rFieldColor = rStyleSettings.GetFieldColor(); + const Color& rDlgColor = rStyleSettings.GetDialogColor(); + const Color& rFieldTextColor = SwViewOption::GetFontColor(); + Color aGrayColor(COL_LIGHTGRAY); + if (rFieldColor == aGrayColor) + aGrayColor.Invert(); + + Size aLogSize(rRenderContext.PixelToLogic(GetOutputSizePixel())); + tools::Rectangle aCompleteRect(Point(0,0), aLogSize); + rRenderContext.SetLineColor(rDlgColor); + rRenderContext.SetFillColor(rDlgColor); + rRenderContext.DrawRect(aCompleteRect); + + rRenderContext.SetLineColor(rFieldTextColor); + Point aTL((aLogSize.Width() - m_aFrameSize.Width()) / 2, + (aLogSize.Height() - m_aFrameSize.Height()) / 2); + tools::Rectangle aRect(aTL, m_aFrameSize); + + //draw a shadow rectangle + rRenderContext.SetFillColor(COL_GRAY); + tools::Rectangle aShadowRect(aRect); + aShadowRect.Move(aTL.Y(), aTL.Y()); + rRenderContext.DrawRect(aShadowRect); + + rRenderContext.SetFillColor(rFieldColor); + rRenderContext.DrawRect(aRect); + + rRenderContext.SetFillColor(aGrayColor); + + //column separator? + long nLength = aLogSize.Height() - 2 * aTL.Y(); + Point aUp(aTL); + Point aDown(aTL.X(), nLength); + bool bLines = false; + if (m_aCols.GetLineAdj() != COLADJ_NONE) + { + bLines = true; + + sal_uInt16 nPercent = m_aCols.GetLineHeight(); + if (nPercent != 100) + { + nLength -= nLength * nPercent / 100; + switch(m_aCols.GetLineAdj()) + { + case COLADJ_BOTTOM: aUp.AdjustY(nLength ); break; + case COLADJ_TOP: aDown.AdjustY( -nLength ); break; + case COLADJ_CENTER: + aUp.AdjustY(nLength / 2 ); + aDown.AdjustY( -(nLength / 2) ); + break; + default: + break; //prevent warning + } + } + + } + const SwColumns& rCols = m_aCols.GetColumns(); + sal_uInt16 nColCount = rCols.size(); + if (nColCount) + { + rRenderContext.DrawRect(aRect); + rRenderContext.SetFillColor(rFieldColor); + tools::Rectangle aFrameRect(aTL, m_aFrameSize); + long nSum = aTL.X(); + for (sal_uInt16 i = 0; i < nColCount; i++) + { + const SwColumn* pCol = &rCols[i]; + aFrameRect.SetLeft( nSum + pCol->GetLeft() ); //nSum + pCol->GetLeft() + aTL.X(); + nSum += pCol->GetWishWidth(); + aFrameRect.SetRight( nSum - pCol->GetRight() ); + rRenderContext.DrawRect(aFrameRect); + } + if (bLines) + { + nSum = aTL.X(); + for (sal_uInt16 i = 0; i < nColCount - 1; i++) + { + nSum += rCols[i].GetWishWidth(); + aUp.setX( nSum ); + aDown.setX( nSum ); + rRenderContext.DrawLine(aUp, aDown); + } + } + } + rRenderContext.Pop(); +} + +void SwColumnOnlyExample::SetColumns(const SwFormatCol& rCol) +{ + m_aCols = rCol; + sal_uInt16 nWishSum = m_aCols.GetWishWidth(); + long nFrameWidth = m_aFrameSize.Width(); + SwColumns& rCols = m_aCols.GetColumns(); + sal_uInt16 nColCount = rCols.size(); + + for(sal_uInt16 i = 0; i < nColCount; i++) + { + SwColumn* pCol = &rCols[i]; + long nWish = pCol->GetWishWidth(); + nWish *= nFrameWidth; + nWish /= nWishSum; + pCol->SetWishWidth(static_cast<sal_uInt16>(nWish)); + long nLeft = pCol->GetLeft(); + nLeft *= nFrameWidth; + nLeft /= nWishSum; + pCol->SetLeft(static_cast<sal_uInt16>(nLeft)); + long nRight = pCol->GetRight(); + nRight *= nFrameWidth; + nRight /= nWishSum; + pCol->SetRight(static_cast<sal_uInt16>(nRight)); + } + // #97495# make sure that the automatic column width's are always equal + if(nColCount && m_aCols.IsOrtho()) + { + sal_Int32 nColumnWidthSum = 0; + sal_uInt16 i; + for(i = 0; i < nColCount; ++i) + { + SwColumn* pCol = &rCols[i]; + nColumnWidthSum += pCol->GetWishWidth(); + nColumnWidthSum -= (pCol->GetRight() + pCol->GetLeft()); + } + nColumnWidthSum /= nColCount; + for(i = 0; i < nColCount; ++i) + { + SwColumn* pCol = &rCols[i]; + pCol->SetWishWidth( static_cast< sal_uInt16 >(nColumnWidthSum + pCol->GetRight() + pCol->GetLeft())); + } + } +} + +void SwColumnOnlyExample::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + weld::CustomWidgetController::SetDrawingArea(pDrawingArea); + OutputDevice& rRefDevice = pDrawingArea->get_ref_device(); + Size aPrefSize(rRefDevice.LogicToPixel(Size(75, 46), MapMode(MapUnit::MapAppFont))); + pDrawingArea->set_size_request(aPrefSize.Width(), aPrefSize.Height()); +} + +void SwColumnOnlyExample::Resize() +{ + OutputDevice& rRefDevice = GetDrawingArea()->get_ref_device(); + rRefDevice.Push(PushFlags::MAPMODE); + rRefDevice.SetMapMode(MapMode(MapUnit::MapTwip)); + m_aWinSize = GetOutputSizePixel(); + m_aWinSize.AdjustHeight( -4 ); + m_aWinSize.AdjustWidth( -4 ); + m_aWinSize = rRefDevice.PixelToLogic(m_aWinSize); + rRefDevice.Pop(); + Invalidate(); +} + +SwPageGridExample::SwPageGridExample() +{ +} + +void SwPageGridExample::DrawPage(vcl::RenderContext& rRenderContext, const Point& rOrg, + const bool bSecond, const bool bEnabled) +{ + SwPageExample::DrawPage(rRenderContext, rOrg, bSecond, bEnabled); + + if (!pGridItem || !pGridItem->GetGridType()) + return; + + //paint the grid now + Color aLineColor = pGridItem->GetColor(); + if (aLineColor == COL_AUTO) + { + aLineColor = rRenderContext.GetFillColor(); + aLineColor.Invert(); + } + rRenderContext.SetLineColor(aLineColor); + long nL = GetLeft(); + long nR = GetRight(); + + if (GetUsage() == SvxPageUsage::Mirror && !bSecond) + { + // rotate for mirrored + nL = GetRight(); + nR = GetLeft(); + } + + tools::Rectangle aRect; + aRect.SetRight( rOrg.X() + GetSize().Width() - nR ); + aRect.SetLeft( rOrg.X() + nL ); + aRect.SetTop( rOrg.Y() + GetTop() + GetHdHeight() + GetHdDist() ); + aRect.SetBottom( rOrg.Y() + GetSize().Height() - GetBottom() - GetFtHeight() - GetFtDist() ); + + //increase the values to get a 'viewable' preview + sal_Int32 nBaseHeight = pGridItem->GetBaseHeight() * 3; + sal_Int32 nRubyHeight = pGridItem->GetRubyHeight() * 3; + + //detect height of rectangles + tools::Rectangle aRubyRect(aRect.TopLeft(), + m_bVertical ? + Size(nRubyHeight, aRect.GetHeight()) : + Size(aRect.GetWidth(), nRubyHeight)); + tools::Rectangle aCharRect(aRect.TopLeft(), + m_bVertical ? + Size(nBaseHeight, aRect.GetHeight()) : + Size(aRect.GetWidth(), nBaseHeight)); + + sal_Int32 nLineHeight = nBaseHeight + nRubyHeight; + + //detect count of rectangles + sal_Int32 nLines = (m_bVertical ? aRect.GetWidth(): aRect.GetHeight()) / nLineHeight; + if (nLines > pGridItem->GetLines()) + nLines = pGridItem->GetLines(); + + // determine start position + if (m_bVertical) + { + sal_Int16 nXStart = static_cast<sal_Int16>(aRect.GetWidth() / 2 - nLineHeight * nLines /2); + aRubyRect.Move(nXStart, 0); + aCharRect.Move(nXStart, 0); + } + else + { + sal_Int16 nYStart = static_cast<sal_Int16>(aRect.GetHeight() / 2 - nLineHeight * nLines /2); + aRubyRect.Move(0, nYStart); + aCharRect.Move(0, nYStart); + } + + if (pGridItem->IsRubyTextBelow()) + m_bVertical ? aRubyRect.Move(nBaseHeight, 0) : aRubyRect.Move(0, nBaseHeight); + else + m_bVertical ? aCharRect.Move(nRubyHeight, 0) : aCharRect.Move(0, nRubyHeight); + + //vertical lines + bool bBothLines = pGridItem->GetGridType() == GRID_LINES_CHARS; + rRenderContext.SetFillColor(COL_TRANSPARENT); + sal_Int32 nXMove = m_bVertical ? nLineHeight : 0; + sal_Int32 nYMove = m_bVertical ? 0 : nLineHeight; + for (sal_Int32 nLine = 0; nLine < nLines; nLine++) + { + rRenderContext.DrawRect(aRubyRect); + rRenderContext.DrawRect(aCharRect); + if (bBothLines) + { + Point aStart = aCharRect.TopLeft(); + Point aEnd = m_bVertical ? aCharRect.TopRight() : aCharRect.BottomLeft(); + while (m_bVertical ? aStart.Y() < aRect.Bottom(): aStart.X() < aRect.Right()) + { + rRenderContext.DrawLine(aStart, aEnd); + if (m_bVertical) + aStart.setY( aEnd.AdjustY(nBaseHeight ) ); + else + aStart.setX( aEnd.AdjustX(nBaseHeight ) ); + } + } + aRubyRect.Move(nXMove, nYMove); + aCharRect.Move(nXMove, nYMove); + } + +} + +void SwPageGridExample::UpdateExample( const SfxItemSet& rSet ) +{ + pGridItem.reset(); + //get the grid information + if (SfxItemState::DEFAULT <= rSet.GetItemState(RES_TEXTGRID)) + pGridItem.reset(rSet.Get(RES_TEXTGRID).Clone()); + SwPageExample::UpdateExample(rSet); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/uibase/frmdlg/colmgr.cxx b/sw/source/uibase/frmdlg/colmgr.cxx new file mode 100644 index 000000000..8dda357ee --- /dev/null +++ b/sw/source/uibase/frmdlg/colmgr.cxx @@ -0,0 +1,161 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <sal/config.h> + +#include <algorithm> + +#include <hintids.hxx> +#include <editeng/lrspitem.hxx> +#include <osl/diagnose.h> + +#include <colmgr.hxx> +#include <fmtfsize.hxx> +#include <swtypes.hxx> + +// private methods + +// set column width to current width +void FitToActualSize(SwFormatCol& rCol, sal_uInt16 nWidth) +{ + const sal_uInt16 nCount = rCol.GetColumns().size(); + for(sal_uInt16 i = 0; i < nCount; ++i) + { + const sal_uInt16 nTmp = rCol.CalcColWidth(i, nWidth); + auto & col = rCol.GetColumns()[i]; + col.SetWishWidth(nTmp); + // If necessary, shrink borders (as equally as possible) to keep up the invariant that + // GetWishWidth() >= GetLeft() + GetRight(): + sal_uInt32 const borders = col.GetLeft() + col.GetRight(); + if (borders > nTmp) + { + auto const shrink = borders - nTmp; + auto const half = shrink / 2; // rounds down + if (col.GetLeft() < col.GetRight()) + { + auto const shrinkLeft = std::min(sal_uInt32(col.GetLeft()), half); + col.SetLeft(col.GetLeft() - shrinkLeft); + col.SetRight(col.GetRight() - (shrink - shrinkLeft)); + } + else + { + auto const shrinkRight = std::min(sal_uInt32(col.GetRight()), half); + col.SetLeft(col.GetLeft() - (shrink - shrinkRight)); + col.SetRight(col.GetRight() - shrinkRight); + } + } + } + rCol.SetWishWidth(nWidth); +} + +// public methods + +// set column quantity and Gutterwidth +void SwColMgr::SetCount(sal_uInt16 nCount, sal_uInt16 nGutterWidth) +{ + aFormatCol.Init(nCount, nGutterWidth, nWidth); + aFormatCol.SetWishWidth(nWidth); + aFormatCol.SetGutterWidth(nGutterWidth, nWidth); +} + +sal_uInt16 SwColMgr::GetGutterWidth( sal_uInt16 nPos ) const +{ + sal_uInt16 nRet; + if(nPos == USHRT_MAX ) + nRet = GetCount() > 1 ? aFormatCol.GetGutterWidth() : DEF_GUTTER_WIDTH; + else + { + OSL_ENSURE(nPos < GetCount() - 1, "column overindexed" ); + const SwColumns& rCols = aFormatCol.GetColumns(); + nRet = rCols[nPos].GetRight() + rCols[nPos + 1].GetLeft(); + } + return nRet; +} + +void SwColMgr::SetGutterWidth(sal_uInt16 nGutterWidth, sal_uInt16 nPos ) +{ + if(nPos == USHRT_MAX) + aFormatCol.SetGutterWidth(nGutterWidth, nWidth); + else + { + OSL_ENSURE(nPos < GetCount() - 1, "column overindexed" ); + SwColumns& rCols = aFormatCol.GetColumns(); + sal_uInt16 nGutterWidth2 = nGutterWidth / 2; + rCols[nPos].SetRight(nGutterWidth2); + rCols[nPos + 1].SetLeft(nGutterWidth2); + } +} + +// height separation line +short SwColMgr::GetLineHeightPercent() const +{ + return static_cast<short>(aFormatCol.GetLineHeight()); +} +void SwColMgr::SetLineHeightPercent(short nPercent) +{ + OSL_ENSURE(nPercent <= 100, "line height may be at most 100%"); + aFormatCol.SetLineHeight(static_cast<sal_uInt8>(nPercent)); +} + +// column width +sal_uInt16 SwColMgr::GetColWidth(sal_uInt16 nIdx) const +{ + OSL_ENSURE(nIdx < GetCount(), "Column array overindexed."); + return aFormatCol.CalcPrtColWidth(nIdx, nWidth); +} + +void SwColMgr::SetColWidth(sal_uInt16 nIdx, sal_uInt16 nWd) +{ + OSL_ENSURE(nIdx < GetCount(), "Column array overindexed."); + aFormatCol.GetColumns()[nIdx].SetWishWidth(nWd); + +} + +// newly set size +void SwColMgr::SetActualWidth(sal_uInt16 nW) +{ + nWidth = nW; + ::FitToActualSize(aFormatCol, nW); +} + +// ctor +SwColMgr::SwColMgr(const SfxItemSet& rSet) : + aFormatCol(rSet.Get(RES_COL)) +{ + nWidth = static_cast<sal_uInt16>(rSet.Get(RES_FRM_SIZE).GetWidth()); + if (nWidth < MINLAY) + nWidth = USHRT_MAX; + const SvxLRSpaceItem &rLR = rSet.Get(RES_LR_SPACE); + nWidth = nWidth - static_cast<sal_uInt16>(rLR.GetLeft()); + nWidth = nWidth - static_cast<sal_uInt16>(rLR.GetRight()); + ::FitToActualSize(aFormatCol, nWidth); +} + +SwColMgr::~SwColMgr() +{ +} + +void SwColMgr::SetLineWidthAndColor(SvxBorderLineStyle eStyle, sal_uLong nLWidth, const Color& rCol) +{ + aFormatCol.SetLineStyle(eStyle); + aFormatCol.SetLineWidth(nLWidth); + aFormatCol.SetLineColor(rCol); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sw/source/uibase/frmdlg/frmmgr.cxx b/sw/source/uibase/frmdlg/frmmgr.cxx new file mode 100644 index 000000000..926a949e2 --- /dev/null +++ b/sw/source/uibase/frmdlg/frmmgr.cxx @@ -0,0 +1,613 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <cmdid.h> +#include <hintids.hxx> + +#include <svl/stritem.hxx> +#include <editeng/boxitem.hxx> +#include <editeng/lrspitem.hxx> +#include <editeng/ulspitem.hxx> +#include <editeng/shaditem.hxx> +#include <svx/swframevalidation.hxx> +#include <svx/xdef.hxx> +#include <tools/globname.hxx> +#include <comphelper/classids.hxx> +#include <fmtclds.hxx> +#include <wrtsh.hxx> +#include <view.hxx> +#include <viewopt.hxx> +#include <uitool.hxx> +#include <frmmgr.hxx> +#include <format.hxx> +#include <mdiexp.hxx> +#include <poolfmt.hxx> +#include <com/sun/star/text/HoriOrientation.hpp> +#include <com/sun/star/text/VertOrientation.hpp> +#include <com/sun/star/text/RelOrientation.hpp> +#include <grfatr.hxx> + +using namespace ::com::sun::star; + +static sal_uInt16 aFrameMgrRange[] = { + RES_FRMATR_BEGIN, RES_FRMATR_END-1, // 87-129 + + // RotGrfFlyFrame: Support here, but seems not to be + // added in range of m_pOwnSh->GetFlyFrameAttr result + // (see below). Tried to find, but could not identify + RES_GRFATR_ROTATION, RES_GRFATR_ROTATION, // 132 + + // FillAttribute support + XATTR_FILL_FIRST, XATTR_FILL_LAST, // 1014-1033 + + SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER, + FN_SET_FRM_NAME, FN_SET_FRM_NAME, + 0}; + +// determine frame attributes via Shell +SwFlyFrameAttrMgr::SwFlyFrameAttrMgr( bool bNew, SwWrtShell* pSh, Frmmgr_Type nType, const SvGlobalName* pName ) : + m_aSet( static_cast<SwAttrPool&>(pSh->GetAttrPool()), aFrameMgrRange ), + m_pOwnSh( pSh ), + m_bAbsPos( false ), + m_bNewFrame( bNew ), + m_bIsInVertical( false ), + m_bIsInVerticalL2R( false ) +{ + if ( m_bNewFrame ) + { + sal_uInt16 nId; + switch ( nType ) + { + case Frmmgr_Type::TEXT: nId = RES_POOLFRM_FRAME; break; + case Frmmgr_Type::OLE: nId = RES_POOLFRM_OLE; break; + case Frmmgr_Type::GRF: nId = RES_POOLFRM_GRAPHIC; break; + // set defaults: + default: nId=0; break; + } + m_aSet.SetParent( &m_pOwnSh->GetFormatFromPool( nId )->GetAttrSet()); + m_aSet.Put( SwFormatFrameSize( SwFrameSize::Minimum, DFLT_WIDTH, DFLT_HEIGHT )); + if ( 0 != ::GetHtmlMode(pSh->GetView().GetDocShell()) ) + m_aSet.Put( SwFormatHoriOrient( 0, text::HoriOrientation::LEFT, text::RelOrientation::PRINT_AREA ) ); + + if (nType == Frmmgr_Type::GRF || nType == Frmmgr_Type::OLE) + { + if (!pName || *pName != SvGlobalName( SO3_SM_CLASSID )) + { + // Default anchor for new graphics and objects is at-char, except for Math objects. + m_aSet.Put(SwFormatAnchor(RndStdIds::FLY_AT_CHAR)); + } + } + } + else if ( nType == Frmmgr_Type::NONE ) + { + m_pOwnSh->GetFlyFrameAttr( m_aSet ); + bool bRightToLeft; + m_bIsInVertical = m_pOwnSh->IsFrameVertical(true, bRightToLeft, m_bIsInVerticalL2R); + } + ::PrepareBoxInfo( m_aSet, *m_pOwnSh ); +} + +SwFlyFrameAttrMgr::SwFlyFrameAttrMgr( bool bNew, SwWrtShell* pSh, const SfxItemSet &rSet ) : + m_aSet( rSet ), + m_pOwnSh( pSh ), + m_bAbsPos( false ), + m_bNewFrame( bNew ), + m_bIsInVertical(false), + m_bIsInVerticalL2R(false) +{ + if(!bNew) + { + bool bRightToLeft; + m_bIsInVertical = pSh->IsFrameVertical(true, bRightToLeft, m_bIsInVerticalL2R); + } +} + +// Initialise +void SwFlyFrameAttrMgr::UpdateAttrMgr() +{ + if ( !m_bNewFrame && m_pOwnSh->IsFrameSelected() ) + m_pOwnSh->GetFlyFrameAttr( m_aSet ); + ::PrepareBoxInfo( m_aSet, *m_pOwnSh ); +} + +void SwFlyFrameAttrMgr::UpdateFlyFrame_() +{ + const SfxPoolItem* pItem = nullptr; + + if (m_aSet.GetItemState(FN_SET_FRM_NAME, false, &pItem) == SfxItemState::SET) + m_pOwnSh->SetFlyName(static_cast<const SfxStringItem *>(pItem)->GetValue()); + + m_pOwnSh->SetModified(); + + if ( m_bAbsPos ) + { + m_pOwnSh->SetFlyPos( m_aAbsPos ); + m_bAbsPos = false; + } +} + +// change existing Fly-Frame +void SwFlyFrameAttrMgr::UpdateFlyFrame() +{ + OSL_ENSURE( m_pOwnSh->IsFrameSelected(), + "no frame selected or no shell, update not possible"); + + if( m_pOwnSh->IsFrameSelected() ) + { + //JP 6.8.2001: set never an invalid anchor into the core. + const SfxPoolItem *pGItem, *pItem; + if( SfxItemState::SET == m_aSet.GetItemState( RES_ANCHOR, false, &pItem )) + { + SfxItemSet aGetSet( *m_aSet.GetPool(), svl::Items<RES_ANCHOR, RES_ANCHOR>{} ); + if( m_pOwnSh->GetFlyFrameAttr( aGetSet ) && 1 == aGetSet.Count() && + SfxItemState::SET == aGetSet.GetItemState( RES_ANCHOR, false, &pGItem ) + && static_cast<const SwFormatAnchor*>(pGItem)->GetAnchorId() == + static_cast<const SwFormatAnchor*>(pItem)->GetAnchorId() ) + m_aSet.ClearItem( RES_ANCHOR ); + } + + // return wg. BASIC + if( m_aSet.Count() ) + { + m_pOwnSh->StartAllAction(); + m_pOwnSh->SetFlyFrameAttr( m_aSet ); + UpdateFlyFrame_(); + m_pOwnSh->EndAllAction(); + } + } +} + +// insert frame +void SwFlyFrameAttrMgr::InsertFlyFrame() +{ + m_pOwnSh->StartAllAction(); + + bool bRet = nullptr != m_pOwnSh->NewFlyFrame( m_aSet ); + + // turn on the right mode at the shell, frame got selected automatically. + if ( bRet ) + { + UpdateFlyFrame_(); + m_pOwnSh->EnterSelFrameMode(); + FrameNotify(m_pOwnSh, FLY_DRAG_START); + } + m_pOwnSh->EndAllAction(); +} + +// Insert frames of type eAnchorType. Position and size are being set explicitly. +// Not-allowed values of the enumeration type get corrected. +void SwFlyFrameAttrMgr::InsertFlyFrame(RndStdIds eAnchorType, + const Point &rPos, + const Size &rSize ) +{ + OSL_ENSURE( eAnchorType == RndStdIds::FLY_AT_PAGE || + eAnchorType == RndStdIds::FLY_AT_PARA || + eAnchorType == RndStdIds::FLY_AT_CHAR || + eAnchorType == RndStdIds::FLY_AT_FLY || + eAnchorType == RndStdIds::FLY_AS_CHAR, "invalid frame type" ); + + SetPos( rPos ); + + SetSize( rSize ); + SetAnchor( eAnchorType ); + InsertFlyFrame(); +} + +// set anchor +void SwFlyFrameAttrMgr::SetAnchor( RndStdIds eId ) +{ + sal_uInt16 nPhyPageNum, nVirtPageNum; + m_pOwnSh->GetPageNum( nPhyPageNum, nVirtPageNum ); + + m_aSet.Put( SwFormatAnchor( eId, nPhyPageNum ) ); + if ((RndStdIds::FLY_AT_PAGE == eId) || (RndStdIds::FLY_AT_PARA == eId) || (RndStdIds::FLY_AT_CHAR == eId) + || (RndStdIds::FLY_AT_FLY == eId)) + { + SwFormatVertOrient aVertOrient( GetVertOrient() ); + SwFormatHoriOrient aHoriOrient( GetHoriOrient() ); + aHoriOrient.SetRelationOrient( text::RelOrientation::FRAME ); + aVertOrient.SetRelationOrient( text::RelOrientation::FRAME ); + m_aSet.Put( aVertOrient ); + m_aSet.Put( aHoriOrient ); + } +} + +// set the attribute for columns +void SwFlyFrameAttrMgr::SetCol( const SwFormatCol &rCol ) +{ + m_aSet.Put( rCol ); +} + +// set absolute position +void SwFlyFrameAttrMgr::SetAbsPos( const Point& rPoint ) +{ + m_bAbsPos = true; + m_aAbsPos = rPoint; + SwFormatVertOrient aVertOrient( GetVertOrient() ); + SwFormatHoriOrient aHoriOrient( GetHoriOrient() ); + aHoriOrient.SetHoriOrient( text::HoriOrientation::NONE ); + aVertOrient.SetVertOrient( text::VertOrientation::NONE ); + m_aSet.Put( aVertOrient ); + m_aSet.Put( aHoriOrient ); +} + +// check metrics for correctness +void SwFlyFrameAttrMgr::ValidateMetrics( SvxSwFrameValidation& rVal, + const SwPosition* pToCharContentPos, + bool bOnlyPercentRefValue ) +{ + if (!bOnlyPercentRefValue) + { + rVal.nMinHeight = MINFLY + CalcTopSpace() + CalcBottomSpace(); + rVal.nMinWidth = MINFLY + CalcLeftSpace()+ CalcRightSpace(); + } + + SwRect aBoundRect; + + // OD 18.09.2003 #i18732# - adjustment for allowing vertical position + // aligned to page for fly frame anchored to paragraph or to character. + const RndStdIds eAnchorType = rVal.nAnchorType; + const SwFormatFrameSize& rSize = m_aSet.Get(RES_FRM_SIZE); + m_pOwnSh->CalcBoundRect( aBoundRect, eAnchorType, + rVal.nHRelOrient, + rVal.nVRelOrient, + pToCharContentPos, + rVal.bFollowTextFlow, + rVal.bMirror, nullptr, &rVal.aPercentSize, + &rSize); + + if (bOnlyPercentRefValue) + return; + + // #mongolianlayout# + if ( m_bIsInVertical || m_bIsInVerticalL2R ) + { + Point aPos(aBoundRect.Pos()); + long nTmp = aPos.X(); + aPos.setX( aPos.Y() ); + aPos.setY( nTmp ); + Size aSize(aBoundRect.SSize()); + nTmp = aSize.Width(); + aSize.setWidth( aSize.Height() ); + aSize.setHeight( nTmp ); + aBoundRect.Chg( aPos, aSize ); + //exchange width/height to enable correct values + nTmp = rVal.nWidth; + rVal.nWidth = rVal.nHeight; + rVal.nHeight = nTmp; + } + if ((eAnchorType == RndStdIds::FLY_AT_PAGE) || (eAnchorType == RndStdIds::FLY_AT_FLY)) + { + // MinimalPosition + rVal.nMinHPos = aBoundRect.Left(); + rVal.nMinVPos = aBoundRect.Top(); + SwTwips nH = rVal.nHPos; + SwTwips nV = rVal.nVPos; + + if (rVal.nHPos + rVal.nWidth > aBoundRect.Right()) + { + if (rVal.nHoriOrient == text::HoriOrientation::NONE) + { + rVal.nHPos -= ((rVal.nHPos + rVal.nWidth) - aBoundRect.Right()); + nH = rVal.nHPos; + } + else + rVal.nWidth = aBoundRect.Right() - rVal.nHPos; + } + + if (rVal.nHPos + rVal.nWidth > aBoundRect.Right()) + rVal.nWidth = aBoundRect.Right() - rVal.nHPos; + + if (rVal.nVPos + rVal.nHeight > aBoundRect.Bottom()) + { + if (rVal.nVertOrient == text::VertOrientation::NONE) + { + rVal.nVPos -= ((rVal.nVPos + rVal.nHeight) - aBoundRect.Bottom()); + nV = rVal.nVPos; + } + else + rVal.nHeight = aBoundRect.Bottom() - rVal.nVPos; + } + + if (rVal.nVPos + rVal.nHeight > aBoundRect.Bottom()) + rVal.nHeight = aBoundRect.Bottom() - rVal.nVPos; + + if ( rVal.nVertOrient != text::VertOrientation::NONE ) + nV = aBoundRect.Top(); + + if ( rVal.nHoriOrient != text::HoriOrientation::NONE ) + nH = aBoundRect.Left(); + + rVal.nMaxHPos = aBoundRect.Right() - rVal.nWidth; + rVal.nMaxHeight = aBoundRect.Bottom() - nV; + + rVal.nMaxVPos = aBoundRect.Bottom() - rVal.nHeight; + rVal.nMaxWidth = aBoundRect.Right() - nH; + } + // OD 12.11.2003 #i22341# - handle to character anchored objects vertical + // aligned at character or top of line in a special case + else if ((eAnchorType == RndStdIds::FLY_AT_PARA) || + ((eAnchorType == RndStdIds::FLY_AT_CHAR) && + (rVal.nVRelOrient != text::RelOrientation::CHAR) && + (rVal.nVRelOrient != text::RelOrientation::TEXT_LINE) ) ) + { + if (rVal.nHPos + rVal.nWidth > aBoundRect.Right()) + { + if (rVal.nHoriOrient == text::HoriOrientation::NONE) + { + rVal.nHPos -= ((rVal.nHPos + rVal.nWidth) - aBoundRect.Right()); + } + else + rVal.nWidth = aBoundRect.Right() - rVal.nHPos; + } + + // OD 29.09.2003 #i17567#, #i18732# - consider following the text flow + // and alignment at page areas. + const bool bMaxVPosAtBottom = !rVal.bFollowTextFlow || + rVal.nVRelOrient == text::RelOrientation::PAGE_FRAME || + rVal.nVRelOrient == text::RelOrientation::PAGE_PRINT_AREA; + { + SwTwips nTmpMaxVPos = ( bMaxVPosAtBottom + ? aBoundRect.Bottom() + : aBoundRect.Height() ) - + rVal.nHeight; + if ( rVal.nVPos > nTmpMaxVPos ) + { + if (rVal.nVertOrient == text::VertOrientation::NONE) + { + rVal.nVPos = nTmpMaxVPos; + } + else + { + rVal.nHeight = ( bMaxVPosAtBottom + ? aBoundRect.Bottom() + : aBoundRect.Height() ) - rVal.nVPos; + } + } + } + + rVal.nMinHPos = aBoundRect.Left(); + rVal.nMaxHPos = aBoundRect.Right() - rVal.nWidth; + + rVal.nMinVPos = aBoundRect.Top(); + // OD 26.09.2003 #i17567#, #i18732# - determine maximum vertical position + if ( bMaxVPosAtBottom ) + { + rVal.nMaxVPos = aBoundRect.Bottom() - rVal.nHeight; + } + else + { + rVal.nMaxVPos = aBoundRect.Height() - rVal.nHeight; + } + + // maximum width height + const SwTwips nH = ( rVal.nHoriOrient != text::HoriOrientation::NONE ) + ? aBoundRect.Left() + : rVal.nHPos; + const SwTwips nV = ( rVal.nVertOrient != text::VertOrientation::NONE ) + ? aBoundRect.Top() + : rVal.nVPos; + rVal.nMaxHeight = rVal.nMaxVPos + rVal.nHeight - nV; + rVal.nMaxWidth = rVal.nMaxHPos + rVal.nWidth - nH; + } + // OD 12.11.2003 #i22341# - special case for to character anchored objects + // vertical aligned at character or top of line. + // Note: (1) positive vertical values are positions above the top of line + // (2) negative vertical values are positions below the top of line + else if ( (eAnchorType == RndStdIds::FLY_AT_CHAR) && + ( rVal.nVRelOrient == text::RelOrientation::CHAR || + rVal.nVRelOrient == text::RelOrientation::TEXT_LINE ) ) + { + // determine horizontal values + rVal.nMinHPos = aBoundRect.Left(); + + rVal.nMaxHPos = aBoundRect.Right() - rVal.nWidth; + if (rVal.nHPos + rVal.nWidth > aBoundRect.Right()) + { + if (rVal.nHoriOrient == text::HoriOrientation::NONE) + { + rVal.nHPos -= ((rVal.nHPos + rVal.nWidth) - aBoundRect.Right()); + } + else + rVal.nWidth = aBoundRect.Right() - rVal.nHPos; + } + + const SwTwips nH = ( rVal.nHoriOrient != text::HoriOrientation::NONE ) + ? aBoundRect.Left() + : rVal.nHPos; + rVal.nMaxWidth = rVal.nMaxHPos + rVal.nWidth - nH; + + // determine vertical values + rVal.nMinVPos = -( aBoundRect.Bottom() - rVal.nHeight ); + if ( rVal.nVPos < rVal.nMinVPos && + rVal.nVertOrient == text::VertOrientation::NONE ) + { + rVal.nVPos = rVal.nMinVPos; + } + + rVal.nMaxVPos = -aBoundRect.Top(); + if ( rVal.nVPos > rVal.nMaxVPos && + rVal.nVertOrient == text::VertOrientation::NONE ) + { + rVal.nVPos = rVal.nMaxVPos; + } + + if ( rVal.nVertOrient == text::VertOrientation::NONE ) + { + rVal.nMaxHeight = aBoundRect.Bottom() + rVal.nVPos; + } + else + { + rVal.nMaxHeight = aBoundRect.Height(); + } + } + else if ( eAnchorType == RndStdIds::FLY_AS_CHAR ) + { + rVal.nMinHPos = 0; + rVal.nMaxHPos = 0; + + rVal.nMaxHeight = aBoundRect.Height(); + rVal.nMaxWidth = aBoundRect.Width(); + + rVal.nMaxVPos = aBoundRect.Height(); + rVal.nMinVPos = -aBoundRect.Height() + rVal.nHeight; + if (rVal.nMaxVPos < rVal.nMinVPos) + { + rVal.nMinVPos = rVal.nMaxVPos; + rVal.nMaxVPos = -aBoundRect.Height(); + } + } + // #mongolianlayout# + if ( m_bIsInVertical || m_bIsInVerticalL2R ) + { + //restore width/height exchange + long nTmp = rVal.nWidth; + rVal.nWidth = rVal.nHeight; + rVal.nHeight = nTmp; + } + + if (rVal.nMaxWidth < rVal.nWidth) + rVal.nWidth = rVal.nMaxWidth; + if (rVal.nMaxHeight < rVal.nHeight) + rVal.nHeight = rVal.nMaxHeight; +} + +// correction for border +SwTwips SwFlyFrameAttrMgr::CalcTopSpace() +{ + const SvxShadowItem& rShadow = GetShadow(); + const SvxBoxItem& rBox = GetBox(); + return rShadow.CalcShadowSpace(SvxShadowItemSide::TOP ) + rBox.CalcLineSpace(SvxBoxItemLine::TOP); +} + +SwTwips SwFlyFrameAttrMgr::CalcBottomSpace() +{ + const SvxShadowItem& rShadow = GetShadow(); + const SvxBoxItem& rBox = GetBox(); + return rShadow.CalcShadowSpace(SvxShadowItemSide::BOTTOM) + rBox.CalcLineSpace(SvxBoxItemLine::BOTTOM); +} + +SwTwips SwFlyFrameAttrMgr::CalcLeftSpace() +{ + const SvxShadowItem& rShadow = GetShadow(); + const SvxBoxItem& rBox = GetBox(); + return rShadow.CalcShadowSpace(SvxShadowItemSide::LEFT) + rBox.CalcLineSpace(SvxBoxItemLine::LEFT); +} + +SwTwips SwFlyFrameAttrMgr::CalcRightSpace() +{ + const SvxShadowItem& rShadow = GetShadow(); + const SvxBoxItem& rBox = GetBox(); + return rShadow.CalcShadowSpace(SvxShadowItemSide::RIGHT) + rBox.CalcLineSpace(SvxBoxItemLine::RIGHT); +} + +// erase attribute from the set +void SwFlyFrameAttrMgr::DelAttr( sal_uInt16 nId ) +{ + m_aSet.ClearItem( nId ); +} + +void SwFlyFrameAttrMgr::SetLRSpace( long nLeft, long nRight ) +{ + OSL_ENSURE( LONG_MAX != nLeft && LONG_MAX != nRight, "Which border to set?" ); + + SvxLRSpaceItem aTmp( m_aSet.Get( RES_LR_SPACE ) ); + if( LONG_MAX != nLeft ) + aTmp.SetLeft( sal_uInt16(nLeft) ); + if( LONG_MAX != nRight ) + aTmp.SetRight( sal_uInt16(nRight) ); + m_aSet.Put( aTmp ); +} + +void SwFlyFrameAttrMgr::SetULSpace( long nTop, long nBottom ) +{ + OSL_ENSURE(LONG_MAX != nTop && LONG_MAX != nBottom, "Which border to set?" ); + + SvxULSpaceItem aTmp( m_aSet.Get( RES_UL_SPACE ) ); + if( LONG_MAX != nTop ) + aTmp.SetUpper( sal_uInt16(nTop) ); + if( LONG_MAX != nBottom ) + aTmp.SetLower( sal_uInt16(nBottom) ); + m_aSet.Put( aTmp ); +} + +void SwFlyFrameAttrMgr::SetPos( const Point& rPoint ) +{ + SwFormatVertOrient aVertOrient( GetVertOrient() ); + SwFormatHoriOrient aHoriOrient( GetHoriOrient() ); + + aHoriOrient.SetPos ( rPoint.X() ); + aHoriOrient.SetHoriOrient( text::HoriOrientation::NONE ); + + aVertOrient.SetPos ( rPoint.Y() ); + aVertOrient.SetVertOrient( text::VertOrientation::NONE ); + + m_aSet.Put( aVertOrient ); + m_aSet.Put( aHoriOrient ); +} + +void SwFlyFrameAttrMgr::SetHorzOrientation( sal_Int16 eOrient ) +{ + SwFormatHoriOrient aHoriOrient( GetHoriOrient() ); + aHoriOrient.SetHoriOrient( eOrient ); + m_aSet.Put( aHoriOrient ); +} + +void SwFlyFrameAttrMgr::SetVertOrientation( sal_Int16 eOrient ) +{ + SwFormatVertOrient aVertOrient( GetVertOrient() ); + aVertOrient.SetVertOrient( eOrient ); + m_aSet.Put( aVertOrient ); +} + +void SwFlyFrameAttrMgr::SetHeightSizeType( SwFrameSize eType ) +{ + SwFormatFrameSize aSize( GetFrameSize() ); + aSize.SetHeightSizeType( eType ); + m_aSet.Put( aSize ); +} + +void SwFlyFrameAttrMgr::SetRotation(sal_uInt16 nOld, sal_uInt16 nNew, const Size& rUnrotatedSize) +{ + // RotGrfFlyFrame: Central handling of real change of rotation here, all adaptations use this. + // Adaptation of pos/size may be wanted in the future. Already tried to keep last Size in + // UnrotatedSize in the SwRotationGrf Item, but this will lead to various problems. Also tried + // to use m_aSet.Put(...) as in other methods (also tried read methods for Rotation/UnrotatedSize) but + // somehow the needed ID (RES_GRFATR_ROTATION) is *not* in the SfxItemSet of the Frame, so for + // now set directly. Undo/Redo is preserved by AttributeChange + if(nOld != nNew) + { + m_pOwnSh->SetAttrItem(SwRotationGrf(nNew, rUnrotatedSize)); + } +} + +void SwFlyFrameAttrMgr::SetSize( const Size& rSize ) +{ + SwFormatFrameSize aSize( GetFrameSize() ); + aSize.SetSize(Size(std::max(rSize.Width(), long(MINFLY)), std::max(rSize.Height(), long(MINFLY)))); + m_aSet.Put( aSize ); +} + +void SwFlyFrameAttrMgr::SetAttrSet(const SfxItemSet& rSet) +{ + m_aSet.ClearItem(); + m_aSet.Put( rSet ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |