From ed5640d8b587fbcfed7dd7967f3de04b37a76f26 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 11:06:44 +0200 Subject: Adding upstream version 4:7.4.7. Signed-off-by: Daniel Baumann --- svx/source/xoutdev/XPropertyEntry.cxx | 29 + svx/source/xoutdev/_xoutbmp.cxx | 389 ++++ svx/source/xoutdev/_xpoly.cxx | 947 ++++++++++ svx/source/xoutdev/xattr.cxx | 3118 +++++++++++++++++++++++++++++++++ svx/source/xoutdev/xattr2.cxx | 731 ++++++++ svx/source/xoutdev/xattrbmp.cxx | 342 ++++ svx/source/xoutdev/xpool.cxx | 219 +++ svx/source/xoutdev/xtabbtmp.cxx | 114 ++ svx/source/xoutdev/xtabcolr.cxx | 172 ++ svx/source/xoutdev/xtabdash.cxx | 220 +++ svx/source/xoutdev/xtabgrdt.cxx | 216 +++ svx/source/xoutdev/xtabhtch.cxx | 195 +++ svx/source/xoutdev/xtable.cxx | 392 +++++ svx/source/xoutdev/xtablend.cxx | 163 ++ svx/source/xoutdev/xtabptrn.cxx | 149 ++ 15 files changed, 7396 insertions(+) create mode 100644 svx/source/xoutdev/XPropertyEntry.cxx create mode 100644 svx/source/xoutdev/_xoutbmp.cxx create mode 100644 svx/source/xoutdev/_xpoly.cxx create mode 100644 svx/source/xoutdev/xattr.cxx create mode 100644 svx/source/xoutdev/xattr2.cxx create mode 100644 svx/source/xoutdev/xattrbmp.cxx create mode 100644 svx/source/xoutdev/xpool.cxx create mode 100644 svx/source/xoutdev/xtabbtmp.cxx create mode 100644 svx/source/xoutdev/xtabcolr.cxx create mode 100644 svx/source/xoutdev/xtabdash.cxx create mode 100644 svx/source/xoutdev/xtabgrdt.cxx create mode 100644 svx/source/xoutdev/xtabhtch.cxx create mode 100644 svx/source/xoutdev/xtable.cxx create mode 100644 svx/source/xoutdev/xtablend.cxx create mode 100644 svx/source/xoutdev/xtabptrn.cxx (limited to 'svx/source/xoutdev') diff --git a/svx/source/xoutdev/XPropertyEntry.cxx b/svx/source/xoutdev/XPropertyEntry.cxx new file mode 100644 index 000000000..0c3d140e8 --- /dev/null +++ b/svx/source/xoutdev/XPropertyEntry.cxx @@ -0,0 +1,29 @@ +/* -*- 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 + +XPropertyEntry::XPropertyEntry(const OUString& rPropEntryName) + : maPropEntryName(rPropEntryName) +{ +} + +XPropertyEntry::~XPropertyEntry() {} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/xoutdev/_xoutbmp.cxx b/svx/source/xoutdev/_xoutbmp.cxx new file mode 100644 index 000000000..cb690df32 --- /dev/null +++ b/svx/source/xoutdev/_xoutbmp.cxx @@ -0,0 +1,389 @@ +/* -*- 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 +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +constexpr OUStringLiteral FORMAT_BMP = u"bmp"; +constexpr OUStringLiteral FORMAT_GIF = u"gif"; +constexpr OUStringLiteral FORMAT_JPG = u"jpg"; +constexpr OUStringLiteral FORMAT_PNG = u"png"; +constexpr OUStringLiteral FORMAT_WEBP = u"webp"; + +using namespace com::sun::star; + +Animation XOutBitmap::MirrorAnimation( const Animation& rAnimation, bool bHMirr, bool bVMirr ) +{ + Animation aNewAnim( rAnimation ); + + if( bHMirr || bVMirr ) + { + const Size& rGlobalSize = aNewAnim.GetDisplaySizePixel(); + BmpMirrorFlags nMirrorFlags = BmpMirrorFlags::NONE; + + if( bHMirr ) + nMirrorFlags |= BmpMirrorFlags::Horizontal; + + if( bVMirr ) + nMirrorFlags |= BmpMirrorFlags::Vertical; + + for( sal_uInt16 i = 0, nCount = aNewAnim.Count(); i < nCount; i++ ) + { + AnimationBitmap aAnimationBitmap( aNewAnim.Get( i ) ); + + // mirror the BitmapEx + aAnimationBitmap.maBitmapEx.Mirror( nMirrorFlags ); + + // Adjust the positions inside the whole bitmap + if( bHMirr ) + aAnimationBitmap.maPositionPixel.setX(rGlobalSize.Width() - aAnimationBitmap.maPositionPixel.X() - + aAnimationBitmap.maSizePixel.Width()); + + if( bVMirr ) + aAnimationBitmap.maPositionPixel.setY(rGlobalSize.Height() - aAnimationBitmap.maPositionPixel.Y() - + aAnimationBitmap.maSizePixel.Height()); + + aNewAnim.Replace(aAnimationBitmap, i); + } + } + + return aNewAnim; +} + +Graphic XOutBitmap::MirrorGraphic( const Graphic& rGraphic, const BmpMirrorFlags nMirrorFlags ) +{ + Graphic aRetGraphic; + + if( nMirrorFlags != BmpMirrorFlags::NONE ) + { + if( rGraphic.IsAnimated() ) + { + aRetGraphic = MirrorAnimation( rGraphic.GetAnimation(), + bool( nMirrorFlags & BmpMirrorFlags::Horizontal ), + bool( nMirrorFlags & BmpMirrorFlags::Vertical ) ); + } + else + { + BitmapEx aBmp( rGraphic.GetBitmapEx() ); + aBmp.Mirror( nMirrorFlags ); + aRetGraphic = aBmp; + } + } + else + aRetGraphic = rGraphic; + + return aRetGraphic; +} + +ErrCode XOutBitmap::WriteGraphic( const Graphic& rGraphic, OUString& rFileName, + const OUString& rFilterName, const XOutFlags nFlags, + const Size* pMtfSize_100TH_MM, + const css::uno::Sequence< css::beans::PropertyValue >* pFilterData ) +{ + if( rGraphic.GetType() == GraphicType::NONE ) + return ERRCODE_NONE; + + INetURLObject aURL( rFileName ); + Graphic aGraphic; + OUString aExt; + GraphicFilter& rFilter = GraphicFilter::GetGraphicFilter(); + ErrCode nErr = ERRCODE_GRFILTER_FILTERERROR; + bool bTransparent = rGraphic.IsTransparent(), bAnimated = rGraphic.IsAnimated(); + + DBG_ASSERT( aURL.GetProtocol() != INetProtocol::NotValid, "XOutBitmap::WriteGraphic(...): invalid URL" ); + + // calculate correct file name + if( !( nFlags & XOutFlags::DontExpandFilename ) ) + { + OUString aStr( OUString::number( rGraphic.GetChecksum(), 16 ) ); + if ( aStr[0] == '-' ) + aStr = OUString::Concat("m") + aStr.subView(1); + OUString aName = aURL.getBase() + "_" + aURL.getExtension() + "_" + aStr; + aURL.setBase( aName ); + } + + // #i121128# use shortcut to write Vector Graphic Data data in original form (if possible) + auto const & rVectorGraphicDataPtr(rGraphic.getVectorGraphicData()); + + if (rVectorGraphicDataPtr && rVectorGraphicDataPtr->getBinaryDataContainer().getSize()) + { + // Does the filter name match the original format? + const bool bIsSvg(rFilterName.equalsIgnoreAsciiCase("svg") && VectorGraphicDataType::Svg == rVectorGraphicDataPtr->getType()); + const bool bIsWmf(rFilterName.equalsIgnoreAsciiCase("wmf") && VectorGraphicDataType::Wmf == rVectorGraphicDataPtr->getType()); + bool bIsEmf(rFilterName.equalsIgnoreAsciiCase("emf") && VectorGraphicDataType::Emf == rVectorGraphicDataPtr->getType()); + if (!bIsEmf) + { + bIsEmf = rFilterName.equalsIgnoreAsciiCase("emf") && rGraphic.GetGfxLink().IsEMF(); + } + const bool bIsPdf(rFilterName.equalsIgnoreAsciiCase("pdf") && VectorGraphicDataType::Pdf == rVectorGraphicDataPtr->getType()); + + if (bIsSvg || bIsWmf || bIsEmf || bIsPdf) + { + if (!(nFlags & XOutFlags::DontAddExtension)) + { + aURL.setExtension(rFilterName); + } + + rFileName = aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE); + SfxMedium aMedium(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), StreamMode::WRITE | StreamMode::SHARE_DENYNONE | StreamMode::TRUNC); + SvStream* pOStm = aMedium.GetOutStream(); + + if (pOStm) + { + auto & rDataContainer = rVectorGraphicDataPtr->getBinaryDataContainer(); + pOStm->WriteBytes(rDataContainer.getData(), rDataContainer.getSize()); + aMedium.Commit(); + + if (!aMedium.GetError()) + return ERRCODE_NONE; + } + } + } + + if( ( nFlags & XOutFlags::UseNativeIfPossible ) && + !( nFlags & XOutFlags::MirrorHorz ) && + !( nFlags & XOutFlags::MirrorVert ) && + ( rGraphic.GetType() != GraphicType::GdiMetafile ) && rGraphic.IsGfxLink() ) + { + // try to write native link + const GfxLink aGfxLink( rGraphic.GetGfxLink() ); + + switch( aGfxLink.GetType() ) + { + case GfxLinkType::NativeGif: aExt = FORMAT_GIF; break; + + // #i15508# added BMP type for better exports (no call/trigger found, prob used in HTML export) + case GfxLinkType::NativeBmp: aExt = FORMAT_BMP; break; + + case GfxLinkType::NativeJpg: aExt = FORMAT_JPG; break; + case GfxLinkType::NativePng: aExt = FORMAT_PNG; break; + case GfxLinkType::NativeWebp: aExt = FORMAT_WEBP; break; + + default: + break; + } + + // tdf#60684: use native format if possible but it must correspond to filter name + // or no specific format has been required + // without this, you may save for example file with png extension but jpg content + if( !aExt.isEmpty() && (aExt == rFilterName || rFilterName.isEmpty()) ) + { + if( !(nFlags & XOutFlags::DontAddExtension) ) + aURL.setExtension( aExt ); + rFileName = aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + + SfxMedium aMedium(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), StreamMode::WRITE | StreamMode::SHARE_DENYNONE | StreamMode::TRUNC); + SvStream* pOStm = aMedium.GetOutStream(); + + if( pOStm && aGfxLink.GetDataSize() && aGfxLink.GetData() ) + { + pOStm->WriteBytes(aGfxLink.GetData(), aGfxLink.GetDataSize()); + aMedium.Commit(); + + if( !aMedium.GetError() ) + return ERRCODE_NONE; + } + } + } + + OUString aFilter( rFilterName ); + bool bWriteTransGrf = ( aFilter.equalsIgnoreAsciiCase( "transgrf" ) ) || + ( aFilter.equalsIgnoreAsciiCase( "gif" ) ) || + ( nFlags & XOutFlags::UseGifIfPossible ) || + ( ( nFlags & XOutFlags::UseGifIfSensible ) && ( bAnimated || bTransparent ) ); + + // get filter and extension + if( bWriteTransGrf ) + aFilter = FORMAT_GIF; + + sal_uInt16 nFilter = rFilter.GetExportFormatNumberForShortName( aFilter ); + + if( GRFILTER_FORMAT_NOTFOUND == nFilter ) + { + nFilter = rFilter.GetExportFormatNumberForShortName( FORMAT_PNG ); + + if( GRFILTER_FORMAT_NOTFOUND == nFilter ) + nFilter = rFilter.GetExportFormatNumberForShortName( FORMAT_BMP ); + } + + if( GRFILTER_FORMAT_NOTFOUND != nFilter ) + { + aExt = rFilter.GetExportFormatShortName( nFilter ).toAsciiLowerCase(); + + if( bWriteTransGrf ) + { + if( bAnimated ) + aGraphic = rGraphic; + else + { + if( pMtfSize_100TH_MM && ( rGraphic.GetType() != GraphicType::Bitmap ) ) + { + ScopedVclPtrInstance< VirtualDevice > pVDev; + const Size aSize(pVDev->LogicToPixel(*pMtfSize_100TH_MM, MapMode(MapUnit::Map100thMM))); + + if( pVDev->SetOutputSizePixel( aSize ) ) + { + const Wallpaper aWallpaper( pVDev->GetBackground() ); + const Point aPt; + + pVDev->SetBackground( Wallpaper( COL_BLACK ) ); + pVDev->Erase(); + rGraphic.Draw(*pVDev, aPt, aSize); + + const Bitmap aBitmap( pVDev->GetBitmap( aPt, aSize ) ); + + pVDev->SetBackground( aWallpaper ); + pVDev->Erase(); + rGraphic.Draw(*pVDev, aPt, aSize); + + pVDev->SetRasterOp( RasterOp::Xor ); + pVDev->DrawBitmap( aPt, aSize, aBitmap ); + aGraphic = BitmapEx( aBitmap, pVDev->GetBitmap( aPt, aSize ) ); + } + else + aGraphic = rGraphic.GetBitmapEx(); + } + else + aGraphic = rGraphic.GetBitmapEx(); + } + } + else + { + if( pMtfSize_100TH_MM && ( rGraphic.GetType() != GraphicType::Bitmap ) ) + { + ScopedVclPtrInstance< VirtualDevice > pVDev; + const Size aSize(pVDev->LogicToPixel(*pMtfSize_100TH_MM, MapMode(MapUnit::Map100thMM))); + + if( pVDev->SetOutputSizePixel( aSize ) ) + { + rGraphic.Draw(*pVDev, Point(), aSize); + aGraphic = BitmapEx(pVDev->GetBitmap(Point(), aSize)); + } + else + aGraphic = rGraphic.GetBitmapEx(); + } + else + aGraphic = rGraphic.GetBitmapEx(); + } + + // mirror? + if( ( nFlags & XOutFlags::MirrorHorz ) || ( nFlags & XOutFlags::MirrorVert ) ) + { + BmpMirrorFlags nBmpMirrorFlags = BmpMirrorFlags::NONE; + if( nFlags & XOutFlags::MirrorHorz ) + nBmpMirrorFlags |= BmpMirrorFlags::Horizontal; + if( nFlags & XOutFlags::MirrorVert ) + nBmpMirrorFlags |= BmpMirrorFlags::Vertical; + aGraphic = MirrorGraphic( aGraphic, nBmpMirrorFlags ); + } + + if (aGraphic.GetType() != GraphicType::NONE) + { + if( !(nFlags & XOutFlags::DontAddExtension) ) + aURL.setExtension( aExt ); + rFileName = aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + nErr = ExportGraphic( aGraphic, aURL, rFilter, nFilter, pFilterData ); + } + } + + return nErr; +} + +bool XOutBitmap::GraphicToBase64(const Graphic& rGraphic, OUString& rOUString, bool bAddPrefix, + ConvertDataFormat aTargetFormat) +{ + SvMemoryStream aOStm; + GfxLink aLink = rGraphic.GetGfxLink(); + + if (aTargetFormat == ConvertDataFormat::Unknown) + { + switch (aLink.GetType()) + { + case GfxLinkType::NativeJpg: + aTargetFormat = ConvertDataFormat::JPG; + break; + case GfxLinkType::NativePng: + aTargetFormat = ConvertDataFormat::PNG; + break; + case GfxLinkType::NativeSvg: + aTargetFormat = ConvertDataFormat::SVG; + break; + default: + // save everything else (including gif) into png + aTargetFormat = ConvertDataFormat::PNG; + break; + } + } + + ErrCode nErr = GraphicConverter::Export(aOStm,rGraphic,aTargetFormat); + if ( nErr ) + { + SAL_WARN("svx", "XOutBitmap::GraphicToBase64() invalid Graphic? error: " << nErr ); + return false; + } + css::uno::Sequence aOStmSeq( static_cast(aOStm.GetData()),aOStm.TellEnd() ); + OUStringBuffer aStrBuffer; + ::comphelper::Base64::encode(aStrBuffer,aOStmSeq); + rOUString = aStrBuffer.makeStringAndClear(); + + if (bAddPrefix) + { + OUString aMimeType + = comphelper::GraphicMimeTypeHelper::GetMimeTypeForConvertDataFormat(aTargetFormat); + rOUString = aMimeType + ";base64," + rOUString; + } + + return true; +} + +ErrCode XOutBitmap::ExportGraphic( const Graphic& rGraphic, const INetURLObject& rURL, + GraphicFilter& rFilter, const sal_uInt16 nFormat, + const css::uno::Sequence< css::beans::PropertyValue >* pFilterData ) +{ + DBG_ASSERT( rURL.GetProtocol() != INetProtocol::NotValid, "XOutBitmap::ExportGraphic(...): invalid URL" ); + + SfxMedium aMedium( rURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), StreamMode::WRITE | StreamMode::SHARE_DENYNONE | StreamMode::TRUNC ); + SvStream* pOStm = aMedium.GetOutStream(); + ErrCode nRet = ERRCODE_GRFILTER_IOERROR; + + if( pOStm ) + { + nRet = rFilter.ExportGraphic( rGraphic, rURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), *pOStm, nFormat, pFilterData ); + + aMedium.Commit(); + + if( aMedium.GetError() && ( ERRCODE_NONE == nRet ) ) + nRet = ERRCODE_GRFILTER_IOERROR; + } + + return nRet; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/xoutdev/_xpoly.cxx b/svx/source/xoutdev/_xpoly.cxx new file mode 100644 index 000000000..4d556b1f9 --- /dev/null +++ b/svx/source/xoutdev/_xpoly.cxx @@ -0,0 +1,947 @@ +/* -*- 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 + +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + + +ImpXPolygon::ImpXPolygon(sal_uInt16 nInitSize, sal_uInt16 _nResize) + : pOldPointAry(nullptr) + , bDeleteOldPoints(false) + , nSize(0) + , nResize(_nResize) + , nPoints(0) +{ + Resize(nInitSize); +} + +ImpXPolygon::ImpXPolygon( const ImpXPolygon& rImpXPoly ) + : pOldPointAry(nullptr) + , bDeleteOldPoints(false) + , nSize(0) + , nResize(rImpXPoly.nResize) + , nPoints(0) +{ + rImpXPoly.CheckPointDelete(); + + Resize( rImpXPoly.nSize ); + + // copy + nPoints = rImpXPoly.nPoints; + memcpy( pPointAry.get(), rImpXPoly.pPointAry.get(), nSize*sizeof( Point ) ); + memcpy( pFlagAry.get(), rImpXPoly.pFlagAry.get(), nSize ); +} + +ImpXPolygon::~ImpXPolygon() +{ + pPointAry.reset(); + if ( bDeleteOldPoints ) + { + delete[] pOldPointAry; + pOldPointAry = nullptr; + } +} + +bool ImpXPolygon::operator==(const ImpXPolygon& rImpXPoly) const +{ + return nPoints==rImpXPoly.nPoints && + (nPoints==0 || + (memcmp(pPointAry.get(), rImpXPoly.pPointAry.get(), nPoints*sizeof(Point))==0 && + memcmp(pFlagAry.get(), rImpXPoly.pFlagAry.get(), nPoints)==0)); +} + +/** Change polygon size + * + * @param nNewSize the new size of the polygon + * @param bDeletePoints if FALSE, do not delete the point array directly but + * wait for the next call before doing so. This prevents + * errors with XPoly[n] = XPoly[0] where a resize might + * destroy the right side point array too early. + */ +void ImpXPolygon::Resize( sal_uInt16 nNewSize, bool bDeletePoints ) +{ + if( nNewSize == nSize ) + return; + + PolyFlags* pOldFlagAry = pFlagAry.release(); + sal_uInt16 nOldSize = nSize; + + CheckPointDelete(); + pOldPointAry = pPointAry.release(); + + // Round the new size to a multiple of nResize, if + // the object was not newly created (nSize != 0) + if ( nSize != 0 && nNewSize > nSize ) + { + DBG_ASSERT(nResize, "Trying to resize but nResize = 0 !"); + nNewSize = nSize + ((nNewSize-nSize-1) / nResize + 1) * nResize; + } + // create point array + nSize = nNewSize; + pPointAry.reset( new Point[ nSize ] ); + + // create flag array + pFlagAry.reset( new PolyFlags[ nSize ] ); + memset( pFlagAry.get(), 0, nSize ); + + // copy if needed + if (nOldSize) + { + if( nOldSize < nSize ) + { + memcpy( pPointAry.get(), pOldPointAry, nOldSize*sizeof( Point ) ); + memcpy( pFlagAry.get(), pOldFlagAry, nOldSize ); + } + else + { + memcpy( pPointAry.get(), pOldPointAry, nSize*sizeof( Point ) ); + memcpy( pFlagAry.get(), pOldFlagAry, nSize ); + + // adjust number of valid points + if( nPoints > nSize ) + nPoints = nSize; + } + } + if ( bDeletePoints ) + { + delete[] pOldPointAry; + pOldPointAry = nullptr; + } + else + bDeleteOldPoints = true; + delete[] pOldFlagAry; +} + +void ImpXPolygon::InsertSpace( sal_uInt16 nPos, sal_uInt16 nCount ) +{ + CheckPointDelete(); + + if ( nPos > nPoints ) + nPos = nPoints; + + // if the polygon is too small then enlarge it + if( (nPoints + nCount) > nSize ) + Resize( nPoints + nCount ); + + // If the insert is not at the last position, move everything after backwards + if( nPos < nPoints ) + { + sal_uInt16 nMove = nPoints - nPos; + memmove( &pPointAry[nPos+nCount], &pPointAry[nPos], + nMove * sizeof(Point) ); + memmove( &pFlagAry[nPos+nCount], &pFlagAry[nPos], nMove ); + } + std::fill(pPointAry.get() + nPos, pPointAry.get() + nPos + nCount, Point()); + memset( &pFlagAry [nPos], 0, nCount ); + + nPoints = nPoints + nCount; +} + +void ImpXPolygon::Remove( sal_uInt16 nPos, sal_uInt16 nCount ) +{ + CheckPointDelete(); + + if( (nPos + nCount) > nPoints ) + return; + + sal_uInt16 nMove = nPoints - nPos - nCount; + + if( nMove ) + { + memmove( &pPointAry[nPos], &pPointAry[nPos+nCount], + nMove * sizeof(Point) ); + memmove( &pFlagAry[nPos], &pFlagAry[nPos+nCount], nMove ); + } + std::fill(pPointAry.get() + (nPoints - nCount), pPointAry.get() + nPoints, Point()); + memset( &pFlagAry [nPoints - nCount], 0, nCount ); + nPoints = nPoints - nCount; +} + +void ImpXPolygon::CheckPointDelete() const +{ + if ( bDeleteOldPoints ) + { + delete[] pOldPointAry; + const_cast< ImpXPolygon* >(this)->pOldPointAry = nullptr; + const_cast< ImpXPolygon* >(this)->bDeleteOldPoints = false; + } +} + +XPolygon::XPolygon( sal_uInt16 nSize ) + : pImpXPolygon( ImpXPolygon( nSize, 16 ) ) +{ +} + +XPolygon::XPolygon( const XPolygon& ) = default; + +XPolygon::XPolygon( XPolygon&& ) = default; + +/// create a XPolygon out of a standard polygon +XPolygon::XPolygon( const tools::Polygon& rPoly ) + : pImpXPolygon( rPoly.GetSize() ) +{ + sal_uInt16 nSize = rPoly.GetSize(); + pImpXPolygon->nPoints = nSize; + + for( sal_uInt16 i = 0; i < nSize; i++ ) + { + pImpXPolygon->pPointAry[i] = rPoly[i]; + pImpXPolygon->pFlagAry[i] = rPoly.GetFlags( i ); + } +} + +/// create a rectangle (also with rounded corners) as a Bézier polygon +XPolygon::XPolygon(const tools::Rectangle& rRect, tools::Long nRx, tools::Long nRy) + : pImpXPolygon( 17 ) +{ + tools::Long nWh = (rRect.GetWidth() - 1) / 2; + tools::Long nHh = (rRect.GetHeight() - 1) / 2; + + if ( nRx > nWh ) nRx = nWh; + if ( nRy > nHh ) nRy = nHh; + + // negate Rx => circle clockwise + nRx = -nRx; + + // factor for control points of the Bézier curve: 8/3 * (sin(45g) - 0.5) + tools::Long nXHdl = static_cast(0.552284749 * nRx); + tools::Long nYHdl = static_cast(0.552284749 * nRy); + sal_uInt16 nPos = 0; + + if ( nRx && nRy ) + { + Point aCenter; + + for (sal_uInt16 nQuad = 0; nQuad < 4; nQuad++) + { + switch ( nQuad ) + { + case 0: aCenter = rRect.TopLeft(); + aCenter.AdjustX( -nRx ); + aCenter.AdjustY(nRy ); + break; + case 1: aCenter = rRect.TopRight(); + aCenter.AdjustX(nRx ); + aCenter.AdjustY(nRy ); + break; + case 2: aCenter = rRect.BottomRight(); + aCenter.AdjustX(nRx ); + aCenter.AdjustY( -nRy ); + break; + case 3: aCenter = rRect.BottomLeft(); + aCenter.AdjustX( -nRx ); + aCenter.AdjustY( -nRy ); + break; + } + GenBezArc(aCenter, nRx, nRy, nXHdl, nYHdl, 0_deg100, 9000_deg100, nQuad, nPos); + pImpXPolygon->pFlagAry[nPos ] = PolyFlags::Smooth; + pImpXPolygon->pFlagAry[nPos+3] = PolyFlags::Smooth; + nPos += 4; + } + } + else + { + pImpXPolygon->pPointAry[nPos++] = rRect.TopLeft(); + pImpXPolygon->pPointAry[nPos++] = rRect.TopRight(); + pImpXPolygon->pPointAry[nPos++] = rRect.BottomRight(); + pImpXPolygon->pPointAry[nPos++] = rRect.BottomLeft(); + } + pImpXPolygon->pPointAry[nPos] = pImpXPolygon->pPointAry[0]; + pImpXPolygon->nPoints = nPos + 1; +} + +/// create an ellipse (curve) as Bézier polygon +XPolygon::XPolygon(const Point& rCenter, tools::Long nRx, tools::Long nRy, + Degree100 nStartAngle, Degree100 nEndAngle, bool bClose) + : pImpXPolygon( 17 ) +{ + nStartAngle %= 36000_deg100; + if ( nEndAngle > 36000_deg100 ) nEndAngle %= 36000_deg100; + bool bFull = (nStartAngle == 0_deg100 && nEndAngle == 36000_deg100); + + // factor for control points of the Bézier curve: 8/3 * (sin(45g) - 0.5) + tools::Long nXHdl = static_cast(0.552284749 * nRx); + tools::Long nYHdl = static_cast(0.552284749 * nRy); + sal_uInt16 nPos = 0; + bool bLoopEnd = false; + + do + { + Degree100 nA1, nA2; + sal_uInt16 nQuad = nStartAngle.get() / 9000; + if ( nQuad == 4 ) nQuad = 0; + bLoopEnd = CheckAngles(nStartAngle, nEndAngle, nA1, nA2); + GenBezArc(rCenter, nRx, nRy, nXHdl, nYHdl, nA1, nA2, nQuad, nPos); + nPos += 3; + if ( !bLoopEnd ) + pImpXPolygon->pFlagAry[nPos] = PolyFlags::Smooth; + + } while ( !bLoopEnd ); + + // if not a full circle then connect edges with center point if necessary + if ( !bFull && bClose ) + pImpXPolygon->pPointAry[++nPos] = rCenter; + + if ( bFull ) + { + pImpXPolygon->pFlagAry[0 ] = PolyFlags::Smooth; + pImpXPolygon->pFlagAry[nPos] = PolyFlags::Smooth; + } + pImpXPolygon->nPoints = nPos + 1; +} + +XPolygon::~XPolygon() = default; + +void XPolygon::SetPointCount( sal_uInt16 nPoints ) +{ + std::as_const(pImpXPolygon)->CheckPointDelete(); + + if( pImpXPolygon->nSize < nPoints ) + pImpXPolygon->Resize( nPoints ); + + if ( nPoints < pImpXPolygon->nPoints ) + { + sal_uInt16 nSize = pImpXPolygon->nPoints - nPoints; + std::fill( + pImpXPolygon->pPointAry.get() + nPoints, pImpXPolygon->pPointAry.get() + nPoints + nSize, Point()); + memset( &pImpXPolygon->pFlagAry [nPoints], 0, nSize ); + } + pImpXPolygon->nPoints = nPoints; +} + +sal_uInt16 XPolygon::GetSize() const +{ + pImpXPolygon->CheckPointDelete(); + return pImpXPolygon->nSize; +} + +sal_uInt16 XPolygon::GetPointCount() const +{ + pImpXPolygon->CheckPointDelete(); + return pImpXPolygon->nPoints; +} + +void XPolygon::Insert( sal_uInt16 nPos, const Point& rPt, PolyFlags eFlags ) +{ + if (nPos>pImpXPolygon->nPoints) nPos=pImpXPolygon->nPoints; + pImpXPolygon->InsertSpace( nPos, 1 ); + pImpXPolygon->pPointAry[nPos] = rPt; + pImpXPolygon->pFlagAry[nPos] = eFlags; +} + +void XPolygon::Insert( sal_uInt16 nPos, const XPolygon& rXPoly ) +{ + if (nPos>pImpXPolygon->nPoints) nPos=pImpXPolygon->nPoints; + + sal_uInt16 nPoints = rXPoly.GetPointCount(); + + pImpXPolygon->InsertSpace( nPos, nPoints ); + + memcpy( &(pImpXPolygon->pPointAry[nPos]), + rXPoly.pImpXPolygon->pPointAry.get(), + nPoints*sizeof( Point ) ); + memcpy( &(pImpXPolygon->pFlagAry[nPos]), + rXPoly.pImpXPolygon->pFlagAry.get(), + nPoints ); +} + +void XPolygon::Remove( sal_uInt16 nPos, sal_uInt16 nCount ) +{ + pImpXPolygon->Remove( nPos, nCount ); +} + +void XPolygon::Move( tools::Long nHorzMove, tools::Long nVertMove ) +{ + if ( !nHorzMove && !nVertMove ) + return; + + // move points + sal_uInt16 nCount = pImpXPolygon->nPoints; + for ( sal_uInt16 i = 0; i < nCount; i++ ) + { + Point* pPt = &(pImpXPolygon->pPointAry[i]); + pPt->AdjustX( nHorzMove ); + pPt->AdjustY( nVertMove ); + } +} + +tools::Rectangle XPolygon::GetBoundRect() const +{ + pImpXPolygon->CheckPointDelete(); + tools::Rectangle aRetval; + + if(pImpXPolygon->nPoints) + { + // #i37709# + // For historical reasons the control points are not part of the + // BoundRect. This makes it necessary to subdivide the polygon to + // get a relatively correct BoundRect. Numerically, this is not + // correct and never was. + + const basegfx::B2DRange aPolygonRange(basegfx::utils::getRange(getB2DPolygon())); + aRetval = tools::Rectangle( + FRound(aPolygonRange.getMinX()), FRound(aPolygonRange.getMinY()), + FRound(aPolygonRange.getMaxX()), FRound(aPolygonRange.getMaxY())); + } + + return aRetval; +} + +const Point& XPolygon::operator[]( sal_uInt16 nPos ) const +{ + DBG_ASSERT(nPos < pImpXPolygon->nPoints, "Invalid index at const array access to XPolygon"); + + pImpXPolygon->CheckPointDelete(); + return pImpXPolygon->pPointAry[nPos]; +} + +Point& XPolygon::operator[]( sal_uInt16 nPos ) +{ + std::as_const(pImpXPolygon)->CheckPointDelete(); + + if( nPos >= pImpXPolygon->nSize ) + { + DBG_ASSERT(pImpXPolygon->nResize, "Invalid index at array access to XPolygon"); + pImpXPolygon->Resize(nPos + 1, false); + } + if( nPos >= pImpXPolygon->nPoints ) + pImpXPolygon->nPoints = nPos + 1; + + return pImpXPolygon->pPointAry[nPos]; +} + +XPolygon& XPolygon::operator=( const XPolygon& ) = default; + +XPolygon& XPolygon::operator=( XPolygon&& ) = default; + +bool XPolygon::operator==( const XPolygon& rXPoly ) const +{ + pImpXPolygon->CheckPointDelete(); + return rXPoly.pImpXPolygon == pImpXPolygon; +} + +/// get the flags for the point at the given position +PolyFlags XPolygon::GetFlags( sal_uInt16 nPos ) const +{ + pImpXPolygon->CheckPointDelete(); + return pImpXPolygon->pFlagAry[nPos]; +} + +/// set the flags for the point at the given position +void XPolygon::SetFlags( sal_uInt16 nPos, PolyFlags eFlags ) +{ + std::as_const(pImpXPolygon)->CheckPointDelete(); + pImpXPolygon->pFlagAry[nPos] = eFlags; +} + +/// short path to read the CONTROL flag directly (TODO: better explain what the sense behind this flag is!) +bool XPolygon::IsControl(sal_uInt16 nPos) const +{ + return pImpXPolygon->pFlagAry[nPos] == PolyFlags::Control; +} + +/// short path to read the SMOOTH and SYMMTR flag directly (TODO: better explain what the sense behind these flags is!) +bool XPolygon::IsSmooth(sal_uInt16 nPos) const +{ + PolyFlags eFlag = pImpXPolygon->pFlagAry[nPos]; + return ( eFlag == PolyFlags::Smooth || eFlag == PolyFlags::Symmetric ); +} + +/** calculate the euclidean distance between two points + * + * @param nP1 The first point + * @param nP2 The second point + */ +double XPolygon::CalcDistance(sal_uInt16 nP1, sal_uInt16 nP2) +{ + const Point& rP1 = pImpXPolygon->pPointAry[nP1]; + const Point& rP2 = pImpXPolygon->pPointAry[nP2]; + double fDx = rP2.X() - rP1.X(); + double fDy = rP2.Y() - rP1.Y(); + return std::hypot(fDx, fDy); +} + +void XPolygon::SubdivideBezier(sal_uInt16 nPos, bool bCalcFirst, double fT) +{ + Point* pPoints = pImpXPolygon->pPointAry.get(); + double fT2 = fT * fT; + double fT3 = fT * fT2; + double fU = 1.0 - fT; + double fU2 = fU * fU; + double fU3 = fU * fU2; + sal_uInt16 nIdx = nPos; + short nPosInc, nIdxInc; + + if ( bCalcFirst ) + { + nPos += 3; + nPosInc = -1; + nIdxInc = 0; + } + else + { + nPosInc = 1; + nIdxInc = 1; + } + pPoints[nPos].setX( static_cast(fU3 * pPoints[nIdx ].X() + + fT * fU2 * pPoints[nIdx+1].X() * 3 + + fT2 * fU * pPoints[nIdx+2].X() * 3 + + fT3 * pPoints[nIdx+3].X()) ); + pPoints[nPos].setY( static_cast(fU3 * pPoints[nIdx ].Y() + + fT * fU2 * pPoints[nIdx+1].Y() * 3 + + fT2 * fU * pPoints[nIdx+2].Y() * 3 + + fT3 * pPoints[nIdx+3].Y()) ); + nPos = nPos + nPosInc; + nIdx = nIdx + nIdxInc; + pPoints[nPos].setX( static_cast(fU2 * pPoints[nIdx ].X() + + fT * fU * pPoints[nIdx+1].X() * 2 + + fT2 * pPoints[nIdx+2].X()) ); + pPoints[nPos].setY( static_cast(fU2 * pPoints[nIdx ].Y() + + fT * fU * pPoints[nIdx+1].Y() * 2 + + fT2 * pPoints[nIdx+2].Y()) ); + nPos = nPos + nPosInc; + nIdx = nIdx + nIdxInc; + pPoints[nPos].setX( static_cast(fU * pPoints[nIdx ].X() + + fT * pPoints[nIdx+1].X()) ); + pPoints[nPos].setY( static_cast(fU * pPoints[nIdx ].Y() + + fT * pPoints[nIdx+1].Y()) ); +} + +/// Generate a Bézier arc +void XPolygon::GenBezArc(const Point& rCenter, tools::Long nRx, tools::Long nRy, + tools::Long nXHdl, tools::Long nYHdl, Degree100 nStart, Degree100 nEnd, + sal_uInt16 nQuad, sal_uInt16 nFirst) +{ + Point* pPoints = pImpXPolygon->pPointAry.get(); + pPoints[nFirst ] = rCenter; + pPoints[nFirst+3] = rCenter; + + if ( nQuad == 1 || nQuad == 2 ) + { + nRx = -nRx; nXHdl = -nXHdl; + } + if ( nQuad == 0 || nQuad == 1 ) + { + nRy = -nRy; nYHdl = -nYHdl; + } + + if ( nQuad == 0 || nQuad == 2 ) + { + pPoints[nFirst].AdjustX( nRx ); + pPoints[nFirst+3].AdjustY( nRy ); + } + else + { + pPoints[nFirst].AdjustY( nRy ); + pPoints[nFirst+3].AdjustX( nRx ); + } + pPoints[nFirst+1] = pPoints[nFirst]; + pPoints[nFirst+2] = pPoints[nFirst+3]; + + if ( nQuad == 0 || nQuad == 2 ) + { + pPoints[nFirst+1].AdjustY( nYHdl ); + pPoints[nFirst+2].AdjustX( nXHdl ); + } + else + { + pPoints[nFirst+1].AdjustX( nXHdl ); + pPoints[nFirst+2].AdjustY( nYHdl ); + } + if ( nStart > 0_deg100 ) + SubdivideBezier(nFirst, false, static_cast(nStart.get()) / 9000); + if ( nEnd < 9000_deg100 ) + SubdivideBezier(nFirst, true, static_cast((nEnd-nStart).get()) / (9000_deg100-nStart).get()); + SetFlags(nFirst+1, PolyFlags::Control); + SetFlags(nFirst+2, PolyFlags::Control); +} + +bool XPolygon::CheckAngles(Degree100& nStart, Degree100 nEnd, Degree100& nA1, Degree100& nA2) +{ + if ( nStart == 36000_deg100 ) nStart = 0_deg100; + if ( nEnd == 0_deg100 ) nEnd = 36000_deg100; + Degree100 nStPrev = nStart; + Degree100 nMax((nStart.get() / 9000 + 1) * 9000); + Degree100 nMin = nMax - 9000_deg100; + + if ( nEnd >= nMax || nEnd <= nStart ) nA2 = 9000_deg100; + else nA2 = nEnd - nMin; + nA1 = nStart - nMin; + nStart = nMax; + + // returns true when the last segment was calculated + return (nStPrev < nEnd && nStart >= nEnd); +} + +/** Calculate a smooth transition to connect two Bézier curves + * + * This is done by projecting the corresponding point onto a line between + * two other points. + * + * @param nCenter The point at the end or beginning of the curve. + * If nCenter is at the end of the polygon the point is moved + * to the opposite side. + * @param nDrag The moved point that specifies the relocation. + * @param nPnt The point to modify. + */ +void XPolygon::CalcSmoothJoin(sal_uInt16 nCenter, sal_uInt16 nDrag, sal_uInt16 nPnt) +{ + // If nPoint is no control point, i.e. cannot be moved, then + // move nDrag instead on the line between nCenter and nPnt + if ( !IsControl(nPnt) ) + { + sal_uInt16 nTmp = nDrag; + nDrag = nPnt; + nPnt = nTmp; + } + Point* pPoints = pImpXPolygon->pPointAry.get(); + Point aDiff = pPoints[nDrag] - pPoints[nCenter]; + double fDiv = CalcDistance(nCenter, nDrag); + + if ( fDiv ) + { + double fRatio = CalcDistance(nCenter, nPnt) / fDiv; + // keep the length if SMOOTH + if ( GetFlags(nCenter) == PolyFlags::Smooth || !IsControl(nDrag) ) + { + aDiff.setX( static_cast(fRatio * aDiff.X()) ); + aDiff.setY( static_cast(fRatio * aDiff.Y()) ); + } + pPoints[nPnt] = pPoints[nCenter] - aDiff; + } +} + +/** Calculate tangent between two Bézier curves + * + * @param nCenter start or end point of the curves + * @param nPrev previous reference point + * @param nNext next reference point + */ +void XPolygon::CalcTangent(sal_uInt16 nCenter, sal_uInt16 nPrev, sal_uInt16 nNext) +{ + double fAbsLen = CalcDistance(nNext, nPrev); + + if ( !fAbsLen ) + return; + + const Point& rCenter = pImpXPolygon->pPointAry[nCenter]; + Point& rNext = pImpXPolygon->pPointAry[nNext]; + Point& rPrev = pImpXPolygon->pPointAry[nPrev]; + Point aDiff = rNext - rPrev; + double fNextLen = CalcDistance(nCenter, nNext) / fAbsLen; + double fPrevLen = CalcDistance(nCenter, nPrev) / fAbsLen; + + // same length for both sides if SYMMTR + if ( GetFlags(nCenter) == PolyFlags::Symmetric ) + { + fPrevLen = (fNextLen + fPrevLen) / 2; + fNextLen = fPrevLen; + } + rNext.setX( rCenter.X() + static_cast(fNextLen * aDiff.X()) ); + rNext.setY( rCenter.Y() + static_cast(fNextLen * aDiff.Y()) ); + rPrev.setX( rCenter.X() - static_cast(fPrevLen * aDiff.X()) ); + rPrev.setY( rCenter.Y() - static_cast(fPrevLen * aDiff.Y()) ); +} + +/// convert four polygon points into a Bézier curve +void XPolygon::PointsToBezier(sal_uInt16 nFirst) +{ + double nFullLength, nPart1Length, nPart2Length; + double fX0, fY0, fX1, fY1, fX2, fY2, fX3, fY3; + double fTx1, fTx2, fTy1, fTy2; + double fT1, fU1, fT2, fU2, fV; + Point* pPoints = pImpXPolygon->pPointAry.get(); + + if ( nFirst > pImpXPolygon->nPoints - 4 || IsControl(nFirst) || + IsControl(nFirst+1) || IsControl(nFirst+2) || IsControl(nFirst+3) ) + return; + + fTx1 = pPoints[nFirst+1].X(); + fTy1 = pPoints[nFirst+1].Y(); + fTx2 = pPoints[nFirst+2].X(); + fTy2 = pPoints[nFirst+2].Y(); + fX0 = pPoints[nFirst ].X(); + fY0 = pPoints[nFirst ].Y(); + fX3 = pPoints[nFirst+3].X(); + fY3 = pPoints[nFirst+3].Y(); + + nPart1Length = CalcDistance(nFirst, nFirst+1); + nPart2Length = nPart1Length + CalcDistance(nFirst+1, nFirst+2); + nFullLength = nPart2Length + CalcDistance(nFirst+2, nFirst+3); + if ( nFullLength < 20 ) + return; + + if ( nPart2Length == nFullLength ) + nPart2Length -= 1; + if ( nPart1Length == nFullLength ) + nPart1Length = nPart2Length - 1; + if ( nPart1Length <= 0 ) + nPart1Length = 1; + if ( nPart2Length <= 0 || nPart2Length == nPart1Length ) + nPart2Length = nPart1Length + 1; + + fT1 = nPart1Length / nFullLength; + fU1 = 1.0 - fT1; + fT2 = nPart2Length / nFullLength; + fU2 = 1.0 - fT2; + fV = 3 * (1.0 - (fT1 * fU2) / (fT2 * fU1)); + + fX1 = fTx1 / (fT1 * fU1 * fU1) - fTx2 * fT1 / (fT2 * fT2 * fU1 * fU2); + fX1 /= fV; + fX1 -= fX0 * ( fU1 / fT1 + fU2 / fT2) / 3; + fX1 += fX3 * ( fT1 * fT2 / (fU1 * fU2)) / 3; + + fY1 = fTy1 / (fT1 * fU1 * fU1) - fTy2 * fT1 / (fT2 * fT2 * fU1 * fU2); + fY1 /= fV; + fY1 -= fY0 * ( fU1 / fT1 + fU2 / fT2) / 3; + fY1 += fY3 * ( fT1 * fT2 / (fU1 * fU2)) / 3; + + fX2 = fTx2 / (fT2 * fT2 * fU2 * 3) - fX0 * fU2 * fU2 / ( fT2 * fT2 * 3); + fX2 -= fX1 * fU2 / fT2; + fX2 -= fX3 * fT2 / (fU2 * 3); + + fY2 = fTy2 / (fT2 * fT2 * fU2 * 3) - fY0 * fU2 * fU2 / ( fT2 * fT2 * 3); + fY2 -= fY1 * fU2 / fT2; + fY2 -= fY3 * fT2 / (fU2 * 3); + + pPoints[nFirst+1] = Point(static_cast(fX1), static_cast(fY1)); + pPoints[nFirst+2] = Point(static_cast(fX2), static_cast(fY2)); + SetFlags(nFirst+1, PolyFlags::Control); + SetFlags(nFirst+2, PolyFlags::Control); +} + +/// scale in X- and/or Y-direction +void XPolygon::Scale(double fSx, double fSy) +{ + std::as_const(pImpXPolygon)->CheckPointDelete(); + + sal_uInt16 nPntCnt = pImpXPolygon->nPoints; + + for (sal_uInt16 i = 0; i < nPntCnt; i++) + { + Point& rPnt = pImpXPolygon->pPointAry[i]; + rPnt.setX( static_cast(fSx * rPnt.X()) ); + rPnt.setY( static_cast(fSy * rPnt.Y()) ); + } +} + +/** + * Distort a polygon by scaling its coordinates relative to a reference + * rectangle into an arbitrary rectangle. + * + * Mapping between polygon corners and reference rectangle: + * 0: top left 0----1 + * 1: top right | | + * 2: bottom right 3----2 + * 3: bottom left + */ +void XPolygon::Distort(const tools::Rectangle& rRefRect, + const XPolygon& rDistortedRect) +{ + std::as_const(pImpXPolygon)->CheckPointDelete(); + + tools::Long Xr, Wr; + tools::Long Yr, Hr; + + Xr = rRefRect.Left(); + Yr = rRefRect.Top(); + Wr = rRefRect.GetWidth(); + Hr = rRefRect.GetHeight(); + + if ( !Wr || !Hr ) + return; + + tools::Long X1, X2, X3, X4; + tools::Long Y1, Y2, Y3, Y4; + DBG_ASSERT(rDistortedRect.pImpXPolygon->nPoints >= 4, + "Distort: rectangle too small"); + + X1 = rDistortedRect[0].X(); + Y1 = rDistortedRect[0].Y(); + X2 = rDistortedRect[1].X(); + Y2 = rDistortedRect[1].Y(); + X3 = rDistortedRect[3].X(); + Y3 = rDistortedRect[3].Y(); + X4 = rDistortedRect[2].X(); + Y4 = rDistortedRect[2].Y(); + + sal_uInt16 nPntCnt = pImpXPolygon->nPoints; + + for (sal_uInt16 i = 0; i < nPntCnt; i++) + { + double fTx, fTy, fUx, fUy; + Point& rPnt = pImpXPolygon->pPointAry[i]; + + fTx = static_cast(rPnt.X() - Xr) / Wr; + fTy = static_cast(rPnt.Y() - Yr) / Hr; + fUx = 1.0 - fTx; + fUy = 1.0 - fTy; + + rPnt.setX( static_cast( fUy * (fUx * X1 + fTx * X2) + + fTy * (fUx * X3 + fTx * X4) ) ); + rPnt.setY( static_cast( fUx * (fUy * Y1 + fTy * Y3) + + fTx * (fUy * Y2 + fTy * Y4) ) ); + } +} + +basegfx::B2DPolygon XPolygon::getB2DPolygon() const +{ + // #i74631# use tools Polygon class for conversion to not have the code doubled + // here. This needs one more conversion but avoids different converters in + // the long run + const tools::Polygon aSource(GetPointCount(), pImpXPolygon->pPointAry.get(), pImpXPolygon->pFlagAry.get()); + + return aSource.getB2DPolygon(); +} + +XPolygon::XPolygon(const basegfx::B2DPolygon& rPolygon) + : pImpXPolygon( tools::Polygon( rPolygon ).GetSize() ) +{ + // #i74631# use tools Polygon class for conversion to not have the code doubled + // here. This needs one more conversion but avoids different converters in + // the long run + + const tools::Polygon aSource(rPolygon); + sal_uInt16 nSize = aSource.GetSize(); + pImpXPolygon->nPoints = nSize; + + for( sal_uInt16 i = 0; i < nSize; i++ ) + { + pImpXPolygon->pPointAry[i] = aSource[i]; + pImpXPolygon->pFlagAry[i] = aSource.GetFlags( i ); + } +} + +// XPolyPolygon +XPolyPolygon::XPolyPolygon() = default; + +XPolyPolygon::XPolyPolygon( const XPolyPolygon& ) = default; + +XPolyPolygon::XPolyPolygon( XPolyPolygon&& ) = default; + +XPolyPolygon::XPolyPolygon(const basegfx::B2DPolyPolygon& rPolyPolygon) +{ + for(auto const& rCandidate : rPolyPolygon) + { + Insert(XPolygon(rCandidate)); + } +} + +XPolyPolygon::~XPolyPolygon() = default; + +void XPolyPolygon::Insert( XPolygon&& rXPoly ) +{ + pImpXPolyPolygon->aXPolyList.emplace_back( std::move(rXPoly) ); +} + +/// insert all XPolygons of a XPolyPolygon +void XPolyPolygon::Insert( const XPolyPolygon& rXPolyPoly ) +{ + for ( size_t i = 0; i < rXPolyPoly.Count(); i++) + { + pImpXPolyPolygon->aXPolyList.emplace_back( rXPolyPoly[i] ); + } +} + +void XPolyPolygon::Remove( sal_uInt16 nPos ) +{ + pImpXPolyPolygon->aXPolyList.erase( pImpXPolyPolygon->aXPolyList.begin() + nPos ); +} + +const XPolygon& XPolyPolygon::GetObject( sal_uInt16 nPos ) const +{ + return pImpXPolyPolygon->aXPolyList[ nPos ]; +} + +void XPolyPolygon::Clear() +{ + pImpXPolyPolygon->aXPolyList.clear(); +} + +sal_uInt16 XPolyPolygon::Count() const +{ + return static_cast(pImpXPolyPolygon->aXPolyList.size()); +} + +tools::Rectangle XPolyPolygon::GetBoundRect() const +{ + size_t nXPoly = pImpXPolyPolygon->aXPolyList.size(); + tools::Rectangle aRect; + + for ( size_t n = 0; n < nXPoly; n++ ) + { + XPolygon const & rXPoly = pImpXPolyPolygon->aXPolyList[ n ]; + aRect.Union( rXPoly.GetBoundRect() ); + } + + return aRect; +} + +XPolygon& XPolyPolygon::operator[]( sal_uInt16 nPos ) +{ + return pImpXPolyPolygon->aXPolyList[ nPos ]; +} + +XPolyPolygon& XPolyPolygon::operator=( const XPolyPolygon& ) = default; + +XPolyPolygon& XPolyPolygon::operator=( XPolyPolygon&& ) = default; + +/** + * Distort a polygon by scaling its coordinates relative to a reference + * rectangle into an arbitrary rectangle. + * + * Mapping between polygon corners and reference rectangle: + * 0: top left 0----1 + * 1: top right | | + * 2: bottom right 3----2 + * 3: bottom left + */ +void XPolyPolygon::Distort(const tools::Rectangle& rRefRect, + const XPolygon& rDistortedRect) +{ + for (size_t i = 0; i < Count(); i++) + pImpXPolyPolygon->aXPolyList[ i ].Distort(rRefRect, rDistortedRect); +} + +basegfx::B2DPolyPolygon XPolyPolygon::getB2DPolyPolygon() const +{ + basegfx::B2DPolyPolygon aRetval; + + for(sal_uInt16 a(0); a < Count(); a++) + { + const XPolygon& rPoly = (*this)[a]; + aRetval.append(rPoly.getB2DPolygon()); + } + + return aRetval; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/xoutdev/xattr.cxx b/svx/source/xoutdev/xattr.cxx new file mode 100644 index 000000000..aceba42bb --- /dev/null +++ b/svx/source/xoutdev/xattr.cxx @@ -0,0 +1,3118 @@ +/* -*- 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 + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +using namespace ::com::sun::star; + +typedef std::map StringMap; + +NameOrIndex::NameOrIndex(TypedWhichId _nWhich, sal_Int32 nIndex) : + SfxStringItem(_nWhich, OUString()), + nPalIndex(nIndex) +{ +} + +NameOrIndex::NameOrIndex(TypedWhichId _nWhich, const OUString& rName) : + SfxStringItem(_nWhich, rName), + nPalIndex(-1) +{ +} + +NameOrIndex::NameOrIndex(const NameOrIndex& rNameOrIndex) : + SfxStringItem(rNameOrIndex), + nPalIndex(rNameOrIndex.nPalIndex) +{ +} + +bool NameOrIndex::operator==(const SfxPoolItem& rItem) const +{ + return ( SfxStringItem::operator==(rItem) && + static_cast(rItem).nPalIndex == nPalIndex ); +} + +NameOrIndex* NameOrIndex::Clone(SfxItemPool* /*pPool*/) const +{ + return new NameOrIndex(*this); +} + +/** this static checks if the given NameOrIndex item has a unique name for its value. + The returned String is a unique name for an item with this value in both given pools. + Argument pPool2 can be null. + If returned string equals NameOrIndex->GetName(), the name was already unique. +*/ +OUString NameOrIndex::CheckNamedItem( const NameOrIndex* pCheckItem, const sal_uInt16 nWhich, const SfxItemPool* pPool1, SvxCompareValueFunc pCompareValueFunc, TranslateId pPrefixResId, const XPropertyListRef &pDefaults ) +{ + bool bForceNew = false; + + OUString aUniqueName = SvxUnogetInternalNameForItem(nWhich, pCheckItem->GetName()); + + // 2. if we have a name check if there is already an item with the + // same name in the documents pool with a different line end or start + + if (!aUniqueName.isEmpty() && pPool1) + { + for (const SfxPoolItem* pItem : pPool1->GetItemSurrogates(nWhich)) + { + const NameOrIndex *pNameOrIndex = static_cast(pItem); + + if( pNameOrIndex->GetName() == pCheckItem->GetName() ) + { + // if there is already an item with the same name and the same + // value it's ok to set it + if( !pCompareValueFunc( pNameOrIndex, pCheckItem ) ) + { + // same name but different value, we need a new name for this item + aUniqueName.clear(); + bForceNew = true; + } + break; + } + } + } + + // if we have no name yet, find existing item with same content or + // create a unique name + if (aUniqueName.isEmpty()) + { + sal_Int32 nUserIndex = 1; + const OUString aUser(SvxResId(pPrefixResId) + " "); + + if( pDefaults ) + { + const int nCount = pDefaults->Count(); + int nIndex; + for( nIndex = 0; nIndex < nCount; nIndex++ ) + { + const XPropertyEntry* pEntry = pDefaults->Get(nIndex); + if( pEntry ) + { + bool bFound = false; + + switch( nWhich ) + { + case XATTR_FILLBITMAP: + { + const GraphicObject& rGraphicObjectA(static_cast(pCheckItem)->GetGraphicObject()); + const GraphicObject& rGraphicObjectB(static_cast(pEntry)->GetGraphicObject()); + + bFound = (rGraphicObjectA == rGraphicObjectB); + break; + } + case XATTR_LINEDASH: + bFound = static_cast(pCheckItem)->GetDashValue() == static_cast(pEntry)->GetDash(); + break; + case XATTR_LINESTART: + bFound = static_cast(pCheckItem)->GetLineStartValue() == static_cast(pEntry)->GetLineEnd(); + break; + case XATTR_LINEEND: + bFound = static_cast(pCheckItem)->GetLineEndValue() == static_cast(pEntry)->GetLineEnd(); + break; + case XATTR_FILLGRADIENT: + bFound = static_cast(pCheckItem)->GetGradientValue() == static_cast(pEntry)->GetGradient(); + break; + case XATTR_FILLHATCH: + bFound = static_cast(pCheckItem)->GetHatchValue() == static_cast(pEntry)->GetHatch(); + break; + } + + if( bFound ) + { + aUniqueName = pEntry->GetName(); + break; + } + else + { + const OUString& aEntryName = pEntry->GetName(); + if(aEntryName.getLength() >= aUser.getLength()) + { + sal_Int32 nThisIndex = o3tl::toInt32(aEntryName.subView( aUser.getLength() )); + if( nThisIndex >= nUserIndex ) + nUserIndex = nThisIndex + 1; + } + } + } + } + } + + if (aUniqueName.isEmpty() && pPool1) + { + for (const SfxPoolItem* pItem : pPool1->GetItemSurrogates(nWhich)) + { + const NameOrIndex *pNameOrIndex = static_cast(pItem); + + if( !pNameOrIndex->GetName().isEmpty() ) + { + if( !bForceNew && pCompareValueFunc( pNameOrIndex, pCheckItem ) ) + return pNameOrIndex->GetName(); + + if( pNameOrIndex->GetName().startsWith( aUser ) ) + { + sal_Int32 nThisIndex = o3tl::toInt32(pNameOrIndex->GetName().subView( aUser.getLength() )); + if( nThisIndex >= nUserIndex ) + nUserIndex = nThisIndex + 1; + } + } + } + aUniqueName = aUser + OUString::number( nUserIndex ); + } + } + + return aUniqueName; +} + +void NameOrIndex::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("NameOrIndex")); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr())); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("isIndex"), BAD_CAST(OString::boolean(IsIndex()).getStr())); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetName().toUtf8().getStr())); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"), BAD_CAST(OString::number(nPalIndex).getStr())); + (void)xmlTextWriterEndElement(pWriter); +} + +SfxPoolItem* XColorItem::CreateDefault() { return new XColorItem; } + +XColorItem::XColorItem(TypedWhichId _nWhich, sal_Int32 nIndex, const Color& rTheColor) : + NameOrIndex(_nWhich, nIndex), + aColor(rTheColor) +{ +} + +XColorItem::XColorItem(TypedWhichId _nWhich, const OUString& rName, const Color& rTheColor) : + NameOrIndex(_nWhich, rName), + aColor(rTheColor) +{ +} + +XColorItem::XColorItem(TypedWhichId _nWhich, const Color& rTheColor) + : NameOrIndex(_nWhich, OUString()) + , aColor(rTheColor) +{ +} + +XColorItem::XColorItem(const XColorItem& rItem) : + NameOrIndex(rItem), + aColor(rItem.aColor), + maThemeColor(rItem.maThemeColor) +{ +} + +XColorItem* XColorItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XColorItem(*this); +} + +bool XColorItem::operator==(const SfxPoolItem& rItem) const +{ + return ( NameOrIndex::operator==(rItem) && + static_cast(rItem).aColor == aColor ) && + static_cast(rItem).maThemeColor == maThemeColor; +} + +const Color& XColorItem::GetColorValue() const +{ + assert(!IsIndex()); + return aColor; + +} + +bool XColorItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= GetColorValue().GetRGBColor(); + return true; +} + +bool XColorItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + Color nValue; + rVal >>= nValue; + SetColorValue( nValue ); + + return true; +} + +void XColorItem::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XColorItem")); + if (Which() == SDRATTR_SHADOWCOLOR) + { + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWCOLOR")); + } + else if (Which() == XATTR_FILLCOLOR) + { + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("XATTR_FILLCOLOR")); + } + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aColor"), + BAD_CAST(aColor.AsRGBHexString().toUtf8().getStr())); + + NameOrIndex::dumpAsXml(pWriter); + + maThemeColor.dumpAsXml(pWriter); + + (void)xmlTextWriterEndElement(pWriter); +} + +// --- line attributes --- + + +SfxPoolItem* XLineStyleItem::CreateDefault() { return new XLineStyleItem; } + +XLineStyleItem::XLineStyleItem(css::drawing::LineStyle eTheLineStyle) : + SfxEnumItem(XATTR_LINESTYLE, eTheLineStyle) +{ +} + +XLineStyleItem* XLineStyleItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XLineStyleItem( *this ); +} + +bool XLineStyleItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText.clear(); + + TranslateId pId; + + switch( GetValue() ) + { + case css::drawing::LineStyle_NONE: + pId = RID_SVXSTR_INVISIBLE; + break; + case css::drawing::LineStyle_SOLID: + pId = RID_SVXSTR_SOLID; + break; + default: break; + } + + if (pId) + rText = SvxResId(pId); + return true; +} + +bool XLineStyleItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + css::drawing::LineStyle eLS = GetValue(); + rVal <<= eLS; + return true; +} + +bool XLineStyleItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + css::drawing::LineStyle eLS; + if(!(rVal >>= eLS )) + { + // also try an int (for Basic) + sal_Int32 nLS = 0; + if(!(rVal >>= nLS)) + return false; + eLS = static_cast(nLS); + } + + SetValue( eLS ); + return true; +} + +sal_uInt16 XLineStyleItem::GetValueCount() const +{ + return 3; +} + +XDash::XDash(css::drawing::DashStyle eTheDash, sal_uInt16 nTheDots, double nTheDotLen, + sal_uInt16 nTheDashes, double nTheDashLen, double nTheDistance) : + eDash(eTheDash), + nDots(nTheDots), + nDashes(nTheDashes), + nDotLen(nTheDotLen), + nDashLen(nTheDashLen), + nDistance(nTheDistance) +{ +} + +bool XDash::operator==(const XDash& rDash) const +{ + return ( eDash == rDash.eDash && + nDots == rDash.nDots && + nDotLen == rDash.nDotLen && + nDashes == rDash.nDashes && + nDashLen == rDash.nDashLen && + nDistance == rDash.nDistance ); +} + +// XDash is translated into an array of doubles which describe the lengths of the +// dashes, dots and empty passages. It returns the complete length of the full DashDot +// sequence and fills the given vetor of doubles accordingly (also resizing, so deleting it). +const double SMALLEST_DASH_WIDTH(26.95); + +double XDash::CreateDotDashArray(::std::vector< double >& rDotDashArray, double fLineWidth) const +{ + double fFullDotDashLen(0.0); + const sal_uInt16 nNumDotDashArray = (GetDots() + GetDashes()) * 2; + rDotDashArray.resize( nNumDotDashArray, 0.0 ); + sal_uInt16 a; + sal_uInt16 nIns(0); + double fDashDotDistance = GetDistance(); + double fSingleDashLen = GetDashLen(); + double fSingleDotLen = GetDotLen(); + + if (fLineWidth == 0.0) + fLineWidth = SMALLEST_DASH_WIDTH; + + if(GetDashStyle() == css::drawing::DashStyle_RECTRELATIVE || GetDashStyle() == css::drawing::DashStyle_ROUNDRELATIVE) + { + double fFactor = fLineWidth / 100.0; + + if(GetDashes()) + { + if(GetDashLen()) + { + // is a dash + fSingleDashLen *= fFactor; + } + else + { + // is a dot + fSingleDashLen = fLineWidth; + } + } + + if(GetDots()) + { + if(GetDotLen()) + { + // is a dash + fSingleDotLen *= fFactor; + } + else + { + // is a dot + fSingleDotLen = fLineWidth; + } + } + + if(GetDashes() || GetDots()) + { + if(GetDistance()) + { + // dash as distance + fDashDotDistance *= fFactor; + } + else + { + // dot as distance + fDashDotDistance = fLineWidth; + } + } + } + else + { + // absolute values + if(GetDashes()) + { + if(GetDashLen()) + { + // is a dash + if(fSingleDashLen < SMALLEST_DASH_WIDTH) + { + fSingleDashLen = SMALLEST_DASH_WIDTH; + } + } + else + { + // is a dot + if(fSingleDashLen < fLineWidth) + { + fSingleDashLen = fLineWidth; + } + } + } + + if(GetDots()) + { + if(GetDotLen()) + { + // is a dash + if(fSingleDotLen < SMALLEST_DASH_WIDTH) + { + fSingleDotLen = SMALLEST_DASH_WIDTH; + } + } + else + { + // is a dot + if(fSingleDotLen < fLineWidth) + { + fSingleDotLen = fLineWidth; + } + } + } + + if(GetDashes() || GetDots()) + { + if(GetDistance()) + { + // dash as distance + if(fDashDotDistance < SMALLEST_DASH_WIDTH) + { + fDashDotDistance = SMALLEST_DASH_WIDTH; + } + } + else + { + // dot as distance + if(fDashDotDistance < fLineWidth) + { + fDashDotDistance = fLineWidth; + } + } + } + } + + for(a=0;a(rItem).aDash ); +} + +bool XLineDashItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText = GetName(); + return true; +} + +bool XLineDashItem::HasMetrics() const +{ + return true; +} + +void XLineDashItem::ScaleMetrics(tools::Long nMul, tools::Long nDiv) +{ + aDash.SetDotLen( BigInt::Scale( aDash.GetDotLen(), nMul, nDiv ) ); + aDash.SetDashLen( BigInt::Scale( aDash.GetDashLen(), nMul, nDiv ) ); + aDash.SetDistance( BigInt::Scale( aDash.GetDistance(), nMul, nDiv ) ); +} + +bool XLineDashItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const +{ + nMemberId &= ~CONVERT_TWIPS; + + switch ( nMemberId ) + { + case 0: + { + css::drawing::LineDash aLineDash; + + const XDash& rXD = GetDashValue(); + aLineDash.Style = static_cast(static_cast(rXD.GetDashStyle())); + aLineDash.Dots = rXD.GetDots(); + aLineDash.DotLen = rXD.GetDotLen(); + aLineDash.Dashes = rXD.GetDashes(); + aLineDash.DashLen = rXD.GetDashLen(); + aLineDash.Distance = rXD.GetDistance(); + + uno::Sequence< beans::PropertyValue > aPropSeq{ + comphelper::makePropertyValue("Name", SvxUnogetApiNameForItem(Which(), GetName())), + comphelper::makePropertyValue("LineDash", aLineDash) + }; + rVal <<= aPropSeq; + break; + } + + case MID_NAME: + { + rVal <<= SvxUnogetApiNameForItem(Which(), GetName()); + break; + } + + case MID_LINEDASH: + { + const XDash& rXD = GetDashValue(); + + css::drawing::LineDash aLineDash; + + aLineDash.Style = static_cast(static_cast(rXD.GetDashStyle())); + aLineDash.Dots = rXD.GetDots(); + aLineDash.DotLen = rXD.GetDotLen(); + aLineDash.Dashes = rXD.GetDashes(); + aLineDash.DashLen = rXD.GetDashLen(); + aLineDash.Distance = rXD.GetDistance(); + + rVal <<= aLineDash; + break; + } + + case MID_LINEDASH_STYLE: + { + const XDash& rXD = GetDashValue(); + rVal <<= static_cast(static_cast(rXD.GetDashStyle())); + break; + } + + case MID_LINEDASH_DOTS: + { + const XDash& rXD = GetDashValue(); + rVal <<= rXD.GetDots(); + break; + } + + case MID_LINEDASH_DOTLEN: + { + const XDash& rXD = GetDashValue(); + rVal <<= rXD.GetDotLen(); + break; + } + + case MID_LINEDASH_DASHES: + { + const XDash& rXD = GetDashValue(); + rVal <<= rXD.GetDashes(); + break; + } + + case MID_LINEDASH_DASHLEN: + { + const XDash& rXD = GetDashValue(); + rVal <<= rXD.GetDashLen(); + break; + } + + case MID_LINEDASH_DISTANCE: + { + const XDash& rXD = GetDashValue(); + rVal <<= rXD.GetDistance(); + break; + } + + default: OSL_FAIL("Wrong MemberId!"); return false; + } + + return true; +} + +bool XLineDashItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) +{ + nMemberId &= ~CONVERT_TWIPS; + + switch ( nMemberId ) + { + case 0: + { + uno::Sequence< beans::PropertyValue > aPropSeq; + + if ( rVal >>= aPropSeq ) + { + css::drawing::LineDash aLineDash; + OUString aName; + bool bLineDash( false ); + for ( const auto& rProp : std::as_const(aPropSeq) ) + { + if ( rProp.Name == "Name" ) + rProp.Value >>= aName; + else if ( rProp.Name == "LineDash" ) + { + if ( rProp.Value >>= aLineDash ) + bLineDash = true; + } + } + + SetName( aName ); + if ( bLineDash ) + { + XDash aXDash; + + aXDash.SetDashStyle(static_cast(static_cast(aLineDash.Style))); + aXDash.SetDots(aLineDash.Dots); + aXDash.SetDotLen(aLineDash.DotLen); + aXDash.SetDashes(aLineDash.Dashes); + aXDash.SetDashLen(aLineDash.DashLen); + aXDash.SetDistance(aLineDash.Distance); + + if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes())) + aXDash.SetDots(1); + + SetDashValue( aXDash ); + } + + return true; + } + + return false; + } + + case MID_NAME: + { + OUString aName; + if (!(rVal >>= aName)) + return false; + SetName( aName ); + break; + } + + case MID_LINEDASH: + { + css::drawing::LineDash aLineDash; + if(!(rVal >>= aLineDash)) + return false; + + XDash aXDash; + + aXDash.SetDashStyle(static_cast(static_cast(aLineDash.Style))); + aXDash.SetDots(aLineDash.Dots); + aXDash.SetDotLen(aLineDash.DotLen); + aXDash.SetDashes(aLineDash.Dashes); + aXDash.SetDashLen(aLineDash.DashLen); + aXDash.SetDistance(aLineDash.Distance); + + if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes())) + aXDash.SetDots(1); + + SetDashValue( aXDash ); + break; + } + + case MID_LINEDASH_STYLE: + { + sal_Int16 nVal = sal_Int16(); + if(!(rVal >>= nVal)) + return false; + + XDash aXDash = GetDashValue(); + aXDash.SetDashStyle(static_cast(static_cast(nVal))); + + if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes())) + aXDash.SetDots(1); + + SetDashValue( aXDash ); + + break; + } + + case MID_LINEDASH_DOTS: + case MID_LINEDASH_DASHES: + { + sal_Int16 nVal = sal_Int16(); + if(!(rVal >>= nVal)) + return false; + + XDash aXDash = GetDashValue(); + if ( nMemberId == MID_LINEDASH_DOTS ) + aXDash.SetDots( nVal ); + else + aXDash.SetDashes( nVal ); + + if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes())) + aXDash.SetDots(1); + + SetDashValue( aXDash ); + break; + } + + case MID_LINEDASH_DOTLEN: + case MID_LINEDASH_DASHLEN: + case MID_LINEDASH_DISTANCE: + { + sal_uInt32 nVal = 0; + if(!(rVal >>= nVal)) + return false; + + XDash aXDash = GetDashValue(); + if ( nMemberId == MID_LINEDASH_DOTLEN ) + aXDash.SetDotLen( nVal ); + else if ( nMemberId == MID_LINEDASH_DASHLEN ) + aXDash.SetDashLen( nVal ); + else + aXDash.SetDistance( nVal ); + + if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes())) + aXDash.SetDots(1); + + SetDashValue( aXDash ); + break; + } + } + + return true; +} + +bool XLineDashItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 ) +{ + return static_cast(p1)->GetDashValue() == static_cast(p2)->GetDashValue(); +} + +std::unique_ptr XLineDashItem::checkForUniqueItem( SdrModel* pModel ) const +{ + if( pModel ) + { + const OUString aUniqueName = NameOrIndex::CheckNamedItem( + this, XATTR_LINEDASH, &pModel->GetItemPool(), + XLineDashItem::CompareValueFunc, RID_SVXSTR_DASH20, + pModel->GetPropertyList( XPropertyListType::Dash ) ); + + // if the given name is not valid, replace it! + if( aUniqueName != GetName() ) + return std::make_unique( aUniqueName, aDash ); + } + + return nullptr; +} + +SfxPoolItem* XLineWidthItem::CreateDefault() {return new XLineWidthItem;} + +XLineWidthItem::XLineWidthItem(tools::Long nWidth) : + SfxMetricItem(XATTR_LINEWIDTH, nWidth) +{ +} + +XLineWidthItem* XLineWidthItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XLineWidthItem(*this); +} + +bool XLineWidthItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit eCoreUnit, + MapUnit ePresUnit, + OUString& rText, const IntlWrapper& rIntl +) const +{ + rText = GetMetricText( static_cast(GetValue()), + eCoreUnit, ePresUnit, &rIntl) + + " " + EditResId( GetMetricId( ePresUnit) ); + return true; +} + +bool XLineWidthItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const +{ + sal_Int32 nValue = GetValue(); + if( 0 != (nMemberId&CONVERT_TWIPS) ) + nValue = convertTwipToMm100(nValue); + + rVal <<= nValue; + return true; +} + +bool XLineWidthItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) +{ + sal_Int32 nValue = 0; + rVal >>= nValue; + if( 0 != (nMemberId&CONVERT_TWIPS) ) + nValue = o3tl::toTwips(nValue, o3tl::Length::mm100); + + SetValue( nValue ); + return true; +} + +SfxPoolItem* XLineColorItem::CreateDefault() { return new XLineColorItem; } + +XLineColorItem::XLineColorItem(sal_Int32 nIndex, const Color& rTheColor) : + XColorItem(XATTR_LINECOLOR, nIndex, rTheColor) +{ +} + +XLineColorItem::XLineColorItem(const OUString& rName, const Color& rTheColor) : + XColorItem(XATTR_LINECOLOR, rName, rTheColor) +{ +} + +XLineColorItem* XLineColorItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XLineColorItem(*this); +} + +bool XLineColorItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText = GetName(); + return true; +} + +bool XLineColorItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= GetColorValue().GetRGBColor(); + return true; +} + +bool XLineColorItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + sal_Int32 nValue = 0; + if(!(rVal >>= nValue)) + return false; + + SetColorValue( Color(ColorTransparency, nValue) ); + return true; +} + + +SfxPoolItem* XLineStartItem::CreateDefault() {return new XLineStartItem;} + +XLineStartItem::XLineStartItem(sal_Int32 nIndex) +: NameOrIndex(XATTR_LINESTART, nIndex) +{ +} + +XLineStartItem::XLineStartItem(const OUString& rName, const basegfx::B2DPolyPolygon& rPolyPolygon) +: NameOrIndex(XATTR_LINESTART, rName), + maPolyPolygon(rPolyPolygon) +{ +} + +XLineStartItem::XLineStartItem(const XLineStartItem& rItem) +: NameOrIndex(rItem), + maPolyPolygon(rItem.maPolyPolygon) +{ +} + +XLineStartItem::XLineStartItem(const basegfx::B2DPolyPolygon& rPolyPolygon) +: NameOrIndex( XATTR_LINESTART, -1 ), + maPolyPolygon(rPolyPolygon) +{ +} + +XLineStartItem* XLineStartItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XLineStartItem(*this); +} + +bool XLineStartItem::operator==(const SfxPoolItem& rItem) const +{ + return ( NameOrIndex::operator==(rItem) && static_cast(rItem).maPolyPolygon == maPolyPolygon ); +} + +bool XLineStartItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText = GetName(); + return true; +} + +bool XLineStartItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const +{ + nMemberId &= ~CONVERT_TWIPS; + if( nMemberId == MID_NAME ) + { + rVal <<= SvxUnogetApiNameForItem(Which(), GetName()); + } + else + { + css::drawing::PolyPolygonBezierCoords aBezier; + basegfx::utils::B2DPolyPolygonToUnoPolyPolygonBezierCoords( maPolyPolygon, aBezier ); + rVal <<= aBezier; + } + + return true; +} + +bool XLineStartItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) +{ + nMemberId &= ~CONVERT_TWIPS; + if( nMemberId == MID_NAME ) + { + return false; + } + else + { + maPolyPolygon.clear(); + + if( rVal.hasValue() ) + { + auto pCoords = o3tl::tryAccess( + rVal); + if( !pCoords ) + return false; + + if( pCoords->Coordinates.getLength() > 0 ) + { + maPolyPolygon = basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon( *pCoords ); + // #i72807# close line start/end polygons hard + // maPolyPolygon.setClosed(true); + } + } + } + + return true; +} + +/** this function searches in both the models pool and the styles pool for XLineStartItem + and XLineEndItem with the same value or name and returns an item with the value of + this item and a unique name for an item with this value. */ +std::unique_ptr XLineStartItem::checkForUniqueItem( SdrModel* pModel ) const +{ + if( pModel ) + { + std::unique_ptr pTempItem; + const XLineStartItem* pLineStartItem = this; + + OUString aUniqueName( GetName() ); + + if( !maPolyPolygon.count() ) + { + // if the polygon is empty, check if the name is empty + if( aUniqueName.isEmpty() ) + return nullptr; + + // force empty name for empty polygons + return std::make_unique( "", maPolyPolygon ); + } + + if( maPolyPolygon.count() > 1 ) + { + // check if the polygon is closed + if(!maPolyPolygon.isClosed()) + { + // force a closed polygon + basegfx::B2DPolyPolygon aNew(maPolyPolygon); + aNew.setClosed(true); + pTempItem.reset(new XLineStartItem( aUniqueName, aNew )); + pLineStartItem = pTempItem.get(); + } + } + + bool bForceNew = false; + + // 2. if we have a name check if there is already an item with the + // same name in the documents pool with a different line end or start + + const SfxItemPool& rPool1 = pModel->GetItemPool(); + if (!aUniqueName.isEmpty()) + { + for (const SfxPoolItem* p : rPool1.GetItemSurrogates(XATTR_LINESTART)) + { + auto pItem = dynamic_cast(p); + + if( pItem && ( pItem->GetName() == pLineStartItem->GetName() ) ) + { + // if there is already an item with the same name and the same + // value it's ok to set it + if( pItem->GetLineStartValue() != pLineStartItem->GetLineStartValue() ) + { + // same name but different value, we need a new name for this item + aUniqueName.clear(); + bForceNew = true; + } + break; + } + } + + if( !bForceNew ) + { + for (const SfxPoolItem* p : rPool1.GetItemSurrogates(XATTR_LINEEND)) + { + auto pItem = dynamic_cast(p); + + if( pItem && ( pItem->GetName() == pLineStartItem->GetName() ) ) + { + // if there is already an item with the same name and the same + // value it's ok to set it + if( pItem->GetLineEndValue() != pLineStartItem->GetLineStartValue() ) + { + // same name but different value, we need a new name for this item + aUniqueName.clear(); + bForceNew = true; + } + break; + } + } + } + } + + const SfxItemPool* pPool2 = pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : nullptr; + if( !aUniqueName.isEmpty() && pPool2) + { + for (const SfxPoolItem* p : pPool2->GetItemSurrogates(XATTR_LINESTART)) + { + auto pItem = dynamic_cast(p); + + if( pItem && ( pItem->GetName() == pLineStartItem->GetName() ) ) + { + // if there is already an item with the same name and the same + // value it's ok to set it + if( pItem->GetLineStartValue() != pLineStartItem->GetLineStartValue() ) + { + // same name but different value, we need a new name for this item + aUniqueName.clear(); + bForceNew = true; + } + break; + } + } + + if( !bForceNew ) + { + for (const SfxPoolItem* p : pPool2->GetItemSurrogates(XATTR_LINEEND)) + { + auto pItem = dynamic_cast(p); + + if( pItem && ( pItem->GetName() == pLineStartItem->GetName() ) ) + { + // if there is already an item with the same name and the same + // value it's ok to set it + if( pItem->GetLineEndValue() != pLineStartItem->GetLineStartValue() ) + { + // same name but different value, we need a new name for this item + aUniqueName.clear(); + bForceNew = true; + } + break; + } + } + } + } + + // if we have no name yet, find existing item with same content or + // create a unique name + if( aUniqueName.isEmpty() ) + { + bool bFoundExisting = false; + + sal_Int32 nUserIndex = 1; + const OUString aUser(SvxResId(RID_SVXSTR_LINEEND)); + + for (const SfxPoolItem* p : rPool1.GetItemSurrogates(XATTR_LINESTART)) + { + auto pItem = dynamic_cast(p); + + if (pItem && !pItem->GetName().isEmpty()) + { + if (!bForceNew && pItem->GetLineStartValue() == pLineStartItem->GetLineStartValue()) + { + aUniqueName = pItem->GetName(); + bFoundExisting = true; + break; + } + + if (pItem->GetName().startsWith(aUser)) + { + sal_Int32 nThisIndex = o3tl::toInt32(pItem->GetName().subView(aUser.getLength())); + if (nThisIndex >= nUserIndex) + nUserIndex = nThisIndex + 1; + } + } + } + + for (const SfxPoolItem* p : rPool1.GetItemSurrogates(XATTR_LINEEND)) + { + auto pItem = dynamic_cast(p); + + if (pItem && !pItem->GetName().isEmpty()) + { + if (!bForceNew && pItem->GetLineEndValue() == pLineStartItem->GetLineStartValue()) + { + aUniqueName = pItem->GetName(); + bFoundExisting = true; + break; + } + + if (pItem->GetName().startsWith(aUser)) + { + sal_Int32 nThisIndex = o3tl::toInt32(pItem->GetName().subView(aUser.getLength())); + if (nThisIndex >= nUserIndex) + nUserIndex = nThisIndex + 1; + } + } + } + + if( !bFoundExisting ) + { + aUniqueName = aUser + " " + OUString::number( nUserIndex ); + } + } + + // if the given name is not valid, replace it! + if( aUniqueName != GetName() || pTempItem ) + { + if( pTempItem ) + { + pTempItem->SetName( aUniqueName ); + return pTempItem; + } + else + { + return std::make_unique( aUniqueName, maPolyPolygon ); + } + } + } + + return nullptr; +} + +SfxPoolItem* XLineEndItem::CreateDefault() {return new XLineEndItem;} + +XLineEndItem::XLineEndItem(sal_Int32 nIndex) +: NameOrIndex(XATTR_LINEEND, nIndex) +{ +} + +XLineEndItem::XLineEndItem(const OUString& rName, const basegfx::B2DPolyPolygon& rPolyPolygon) +: NameOrIndex(XATTR_LINEEND, rName), + maPolyPolygon(rPolyPolygon) +{ +} + +XLineEndItem::XLineEndItem(const XLineEndItem& rItem) +: NameOrIndex(rItem), + maPolyPolygon(rItem.maPolyPolygon) +{ +} + +XLineEndItem::XLineEndItem(const basegfx::B2DPolyPolygon& rPolyPolygon) +: NameOrIndex( XATTR_LINEEND, -1 ), + maPolyPolygon(rPolyPolygon) +{ +} + +XLineEndItem* XLineEndItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XLineEndItem(*this); +} + +bool XLineEndItem::operator==(const SfxPoolItem& rItem) const +{ + return ( NameOrIndex::operator==(rItem) && static_cast(rItem).maPolyPolygon == maPolyPolygon ); +} + + +/** this function searches in both the models pool and the styles pool for XLineStartItem + and XLineEndItem with the same value or name and returns an item with the value of + this item and a unique name for an item with this value. */ +std::unique_ptr XLineEndItem::checkForUniqueItem( SdrModel* pModel ) const +{ + if( pModel ) + { + std::unique_ptr pTempItem; + const XLineEndItem* pLineEndItem = this; + + OUString aUniqueName( GetName() ); + + if( !maPolyPolygon.count() ) + { + // if the polygon is empty, check if the name is empty + if( aUniqueName.isEmpty() ) + return nullptr; + + // force empty name for empty polygons + return std::make_unique( "", maPolyPolygon ); + } + + if( maPolyPolygon.count() > 1 ) + { + // check if the polygon is closed + if(!maPolyPolygon.isClosed()) + { + // force a closed polygon + basegfx::B2DPolyPolygon aNew(maPolyPolygon); + aNew.setClosed(true); + pTempItem.reset(new XLineEndItem( aUniqueName, aNew )); + pLineEndItem = pTempItem.get(); + } + } + + bool bForceNew = false; + + // 2. if we have a name check if there is already an item with the + // same name in the documents pool with a different line end or start + + const SfxItemPool& rPool1 = pModel->GetItemPool(); + if (!aUniqueName.isEmpty()) + { + for (const SfxPoolItem* p : rPool1.GetItemSurrogates(XATTR_LINESTART)) + { + auto pItem = dynamic_cast(p); + + if( pItem && ( pItem->GetName() == pLineEndItem->GetName() ) ) + { + // if there is already an item with the same name and the same + // value it's ok to set it + if( pItem->GetLineStartValue() != pLineEndItem->GetLineEndValue() ) + { + // same name but different value, we need a new name for this item + aUniqueName.clear(); + bForceNew = true; + } + break; + } + } + + if( !bForceNew ) + { + for (const SfxPoolItem* p : rPool1.GetItemSurrogates(XATTR_LINEEND)) + { + auto pItem = dynamic_cast(p); + + if( pItem && ( pItem->GetName() == pLineEndItem->GetName() ) ) + { + // if there is already an item with the same name and the same + // value it's ok to set it + if( pItem->GetLineEndValue() != pLineEndItem->GetLineEndValue() ) + { + // same name but different value, we need a new name for this item + aUniqueName.clear(); + bForceNew = true; + } + break; + } + } + } + } + + const SfxItemPool* pPool2 = pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : nullptr; + if( !aUniqueName.isEmpty() && pPool2) + { + for (const SfxPoolItem* p : pPool2->GetItemSurrogates(XATTR_LINESTART)) + { + auto pItem = dynamic_cast(p); + + if( pItem && ( pItem->GetName() == pLineEndItem->GetName() ) ) + { + // if there is already an item with the same name and the same + // value it's ok to set it + if( pItem->GetLineStartValue() != pLineEndItem->GetLineEndValue() ) + { + // same name but different value, we need a new name for this item + aUniqueName.clear(); + bForceNew = true; + } + break; + } + } + + if( !bForceNew ) + { + for (const SfxPoolItem* p : pPool2->GetItemSurrogates(XATTR_LINEEND)) + { + auto pItem = dynamic_cast(p); + + if( pItem && ( pItem->GetName() == pLineEndItem->GetName() ) ) + { + // if there is already an item with the same name and the same + // value it's ok to set it + if( pItem->GetLineEndValue() != pLineEndItem->GetLineEndValue() ) + { + // same name but different value, we need a new name for this item + aUniqueName.clear(); + bForceNew = true; + } + break; + } + } + } + } + + // if we have no name yet, find existing item with same content or + // create a unique name + if( aUniqueName.isEmpty() ) + { + bool bFoundExisting = false; + + sal_Int32 nUserIndex = 1; + const OUString aUser(SvxResId(RID_SVXSTR_LINEEND)); + + for (const SfxPoolItem* p : rPool1.GetItemSurrogates(XATTR_LINESTART)) + { + auto pItem = dynamic_cast(p); + + if (pItem && !pItem->GetName().isEmpty()) + { + if (!bForceNew && pItem->GetLineStartValue() == pLineEndItem->GetLineEndValue()) + { + aUniqueName = pItem->GetName(); + bFoundExisting = true; + break; + } + + if (pItem->GetName().startsWith(aUser)) + { + sal_Int32 nThisIndex = o3tl::toInt32(pItem->GetName().subView(aUser.getLength())); + if (nThisIndex >= nUserIndex) + nUserIndex = nThisIndex + 1; + } + } + } + + for (const SfxPoolItem* p : rPool1.GetItemSurrogates(XATTR_LINEEND)) + { + auto pItem = dynamic_cast(p); + + if (pItem && !pItem->GetName().isEmpty()) + { + if (!bForceNew && pItem->GetLineEndValue() == pLineEndItem->GetLineEndValue()) + { + aUniqueName = pItem->GetName(); + bFoundExisting = true; + break; + } + + if (pItem->GetName().startsWith(aUser)) + { + sal_Int32 nThisIndex = o3tl::toInt32(pItem->GetName().subView(aUser.getLength())); + if (nThisIndex >= nUserIndex) + nUserIndex = nThisIndex + 1; + } + } + } + + if( !bFoundExisting ) + { + aUniqueName = aUser + " " + OUString::number( nUserIndex ); + } + } + + // if the given name is not valid, replace it! + if( aUniqueName != GetName() || pTempItem ) + { + if( pTempItem ) + { + pTempItem->SetName( aUniqueName ); + return pTempItem; + } + else + { + return std::make_unique( aUniqueName, maPolyPolygon ); + } + } + } + + return nullptr; +} + +bool XLineEndItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText = GetName(); + return true; +} + +bool XLineEndItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const +{ + nMemberId &= ~CONVERT_TWIPS; + if( nMemberId == MID_NAME ) + { + rVal <<= SvxUnogetApiNameForItem(Which(), GetName()); + } + else + { + css::drawing::PolyPolygonBezierCoords aBezier; + basegfx::utils::B2DPolyPolygonToUnoPolyPolygonBezierCoords( maPolyPolygon, aBezier ); + rVal <<= aBezier; + } + return true; +} + +bool XLineEndItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) +{ + nMemberId &= ~CONVERT_TWIPS; + if( nMemberId == MID_NAME ) + { + return false; + } + else + { + maPolyPolygon.clear(); + + if( rVal.hasValue() ) + { + auto pCoords = o3tl::tryAccess( + rVal); + if( !pCoords ) + return false; + + if( pCoords->Coordinates.getLength() > 0 ) + { + maPolyPolygon = basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon( *pCoords ); + // #i72807# close line start/end polygons hard + // maPolyPolygon.setClosed(true); + } + } + } + + return true; +} + +XLineStartWidthItem::XLineStartWidthItem(tools::Long nWidth) : + SfxMetricItem(XATTR_LINESTARTWIDTH, nWidth) +{ +} + +XLineStartWidthItem* XLineStartWidthItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XLineStartWidthItem(*this); +} + +bool XLineStartWidthItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit eCoreUnit, + MapUnit ePresUnit, + OUString& rText, const IntlWrapper& rIntl +) const +{ + rText = GetMetricText( static_cast(GetValue()), + eCoreUnit, ePresUnit, &rIntl) + + " " + EditResId( GetMetricId( ePresUnit) ); + return true; +} + +bool XLineStartWidthItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= GetValue(); + return true; +} + +bool XLineStartWidthItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + sal_Int32 nValue = 0; + rVal >>= nValue; + SetValue( nValue ); + return true; +} + +XLineEndWidthItem::XLineEndWidthItem(tools::Long nWidth) : + SfxMetricItem(XATTR_LINEENDWIDTH, nWidth) +{ +} + +XLineEndWidthItem* XLineEndWidthItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XLineEndWidthItem(*this); +} + +bool XLineEndWidthItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit eCoreUnit, + MapUnit ePresUnit, + OUString& rText, const IntlWrapper& rIntl +) const +{ + rText = GetMetricText( static_cast(GetValue()), + eCoreUnit, ePresUnit, &rIntl) + + " " + EditResId( GetMetricId( ePresUnit) ); + return true; +} + +bool XLineEndWidthItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= GetValue(); + return true; +} + +bool XLineEndWidthItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + sal_Int32 nValue = 0; + rVal >>= nValue; + SetValue( nValue ); + return true; +} + +XLineStartCenterItem::XLineStartCenterItem(bool bStartCenter) : + SfxBoolItem(XATTR_LINESTARTCENTER, bStartCenter) +{ +} + +XLineStartCenterItem* XLineStartCenterItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XLineStartCenterItem(*this); +} + +bool XLineStartCenterItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText = SvxResId(GetValue() ? RID_SVXSTR_CENTERED : RID_SVXSTR_NOTCENTERED); + return true; +} + +bool XLineStartCenterItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + bool bValue = GetValue(); + rVal <<= bValue; + return true; +} + +bool XLineStartCenterItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + auto b = o3tl::tryAccess(rVal); + if( !b ) + return false; + + SetValue( *b ); + return true; +} + +XLineEndCenterItem::XLineEndCenterItem(bool bEndCenter) : + SfxBoolItem(XATTR_LINEENDCENTER, bEndCenter) +{ +} + +XLineEndCenterItem* XLineEndCenterItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XLineEndCenterItem(*this); +} + +bool XLineEndCenterItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText = SvxResId(GetValue() ? RID_SVXSTR_CENTERED : RID_SVXSTR_NOTCENTERED); + return true; +} + +bool XLineEndCenterItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + bool bValue = GetValue(); + rVal <<= bValue; + return true; +} + +bool XLineEndCenterItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + auto b = o3tl::tryAccess(rVal); + if( !b ) + return false; + + SetValue( *b ); + return true; +} + +// --- fill attributes --- + + +SfxPoolItem* XFillStyleItem::CreateDefault() { return new XFillStyleItem; } + +XFillStyleItem::XFillStyleItem(drawing::FillStyle eFillStyle) : + SfxEnumItem(XATTR_FILLSTYLE, eFillStyle) +{ +} + +XFillStyleItem* XFillStyleItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFillStyleItem( *this ); +} + +bool XFillStyleItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText.clear(); + + TranslateId pId; + + switch( GetValue() ) + { + case drawing::FillStyle_NONE: + pId = RID_SVXSTR_INVISIBLE; + break; + case drawing::FillStyle_SOLID: + pId = RID_SVXSTR_SOLID; + break; + case drawing::FillStyle_GRADIENT: + pId = RID_SVXSTR_GRADIENT; + break; + case drawing::FillStyle_HATCH: + pId = RID_SVXSTR_HATCH; + break; + case drawing::FillStyle_BITMAP: + pId = RID_SVXSTR_BITMAP; + break; + default: break; + } + + if (pId) + rText = SvxResId(pId); + return true; +} + +sal_uInt16 XFillStyleItem::GetValueCount() const +{ + return 5; +} + +bool XFillStyleItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + css::drawing::FillStyle eFS = GetValue(); + + rVal <<= eFS; + + return true; +} + +bool XFillStyleItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + css::drawing::FillStyle eFS; + if(!(rVal >>= eFS)) + { + // also try an int (for Basic) + sal_Int32 nFS = 0; + if(!(rVal >>= nFS)) + return false; + eFS = static_cast(nFS); + } + + SetValue( eFS ); + + return true; +} + +void XFillStyleItem::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillStyleItem")); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr())); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(static_cast(GetValue())).getStr())); + + OUString aPresentation; + IntlWrapper aIntlWrapper(SvtSysLocale().GetUILanguageTag()); + GetPresentation(SfxItemPresentation::Nameless, MapUnit::Map100thMM, MapUnit::Map100thMM, aPresentation, aIntlWrapper); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(aPresentation.toUtf8().getStr())); + + (void)xmlTextWriterEndElement(pWriter); +} + +boost::property_tree::ptree XFillStyleItem::dumpAsJSON() const +{ + boost::property_tree::ptree aTree = SfxPoolItem::dumpAsJSON(); + + if (Which() == XATTR_FILLSTYLE) + aTree.put("commandName", ".uno:FillStyle"); + + OUString sValue; + + switch( GetValue() ) + { + case drawing::FillStyle_NONE: + sValue = "NONE"; + break; + case drawing::FillStyle_SOLID: + sValue = "SOLID"; + break; + case drawing::FillStyle_GRADIENT: + sValue = "GRADIENT"; + break; + case drawing::FillStyle_HATCH: + sValue = "HATCH"; + break; + case drawing::FillStyle_BITMAP: + sValue = "BITMAP"; + break; + default: break; + } + + aTree.put("state", sValue); + + return aTree; +} + + +SfxPoolItem* XFillColorItem::CreateDefault() { return new XFillColorItem; } + +XFillColorItem::XFillColorItem(sal_Int32 nIndex, const Color& rTheColor) : + XColorItem(XATTR_FILLCOLOR, nIndex, rTheColor) +{ +} + +XFillColorItem::XFillColorItem(const OUString& rName, const Color& rTheColor) : + XColorItem(XATTR_FILLCOLOR, rName, rTheColor) +{ +} + +XFillColorItem* XFillColorItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFillColorItem(*this); +} + +bool XFillColorItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText = GetName(); + return true; +} + +bool XFillColorItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const +{ + nMemberId &= ~CONVERT_TWIPS; + switch (nMemberId) + { + case MID_COLOR_THEME_INDEX: + { + rVal <<= GetThemeColor().GetThemeIndex(); + break; + } + case MID_COLOR_LUM_MOD: + { + rVal <<= GetThemeColor().GetLumMod(); + break; + } + case MID_COLOR_LUM_OFF: + { + rVal <<= GetThemeColor().GetLumOff(); + break; + } + default: + { + rVal <<= GetColorValue().GetRGBColor(); + break; + } + } + + return true; +} + +bool XFillColorItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) +{ + nMemberId &= ~CONVERT_TWIPS; + switch(nMemberId) + { + case MID_COLOR_THEME_INDEX: + { + sal_Int16 nIndex = -1; + if (!(rVal >>= nIndex)) + return false; + GetThemeColor().SetThemeIndex(nIndex); + break; + } + case MID_COLOR_LUM_MOD: + { + sal_Int16 nLumMod = -1; + if (!(rVal >>= nLumMod)) + return false; + GetThemeColor().SetLumMod(nLumMod); + } + break; + case MID_COLOR_LUM_OFF: + { + sal_Int16 nLumOff = -1; + if (!(rVal >>= nLumOff)) + return false; + GetThemeColor().SetLumOff(nLumOff); + } + break; + default: + { + Color nValue; + if(!(rVal >>= nValue )) + return false; + + SetColorValue( nValue ); + break; + } + } + return true; +} + +void XFillColorItem::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillColorItem")); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr())); + + XColorItem::dumpAsXml(pWriter); + + (void)xmlTextWriterEndElement(pWriter); +} + +boost::property_tree::ptree XFillColorItem::dumpAsJSON() const +{ + boost::property_tree::ptree aTree = SfxPoolItem::dumpAsJSON(); + + if (Which() == XATTR_FILLCOLOR) + aTree.put("commandName", ".uno:FillPageColor"); + + aTree.put("state", GetColorValue().AsRGBHexString()); + + return aTree; +} + +XSecondaryFillColorItem::XSecondaryFillColorItem(const OUString& rName, const Color& rTheColor) : + XColorItem(XATTR_SECONDARYFILLCOLOR, rName, rTheColor) +{ +} + +XSecondaryFillColorItem* XSecondaryFillColorItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XSecondaryFillColorItem(*this); +} + +bool XSecondaryFillColorItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText = GetName(); + return true; +} + +std::string XGradient::GradientStyleToString(css::awt::GradientStyle eStyle) +{ + switch (eStyle) + { + case css::awt::GradientStyle::GradientStyle_LINEAR: + return "LINEAR"; + + case css::awt::GradientStyle::GradientStyle_AXIAL: + return "AXIAL"; + + case css::awt::GradientStyle::GradientStyle_RADIAL: + return "RADIAL"; + + case css::awt::GradientStyle::GradientStyle_ELLIPTICAL: + return "ELLIPTICAL"; + + case css::awt::GradientStyle::GradientStyle_SQUARE: + return "SQUARE"; + + case css::awt::GradientStyle::GradientStyle_RECT: + return "RECT"; + + case css::awt::GradientStyle::GradientStyle_MAKE_FIXED_SIZE: + return "MAKE_FIXED_SIZE"; + } + + return ""; +} + +namespace +{ + css::awt::GradientStyle lcl_getStyleFromString(std::u16string_view rStyle) + { + if (rStyle == u"LINEAR") + return css::awt::GradientStyle_LINEAR; + else if (rStyle == u"AXIAL") + return css::awt::GradientStyle_AXIAL; + else if (rStyle == u"RADIAL") + return css::awt::GradientStyle_RADIAL; + else if (rStyle == u"ELLIPTICAL") + return css::awt::GradientStyle_ELLIPTICAL; + else if (rStyle == u"SQUARE") + return css::awt::GradientStyle_SQUARE; + else if (rStyle == u"RECT") + return css::awt::GradientStyle_RECT; + + return css::awt::GradientStyle_LINEAR; + } + + StringMap lcl_jsonToStringMap(const OUString& rJSON) + { + StringMap aArgs; + if (rJSON.getLength() && rJSON[0] != '\0') + { + std::stringstream aStream(OUStringToOString(rJSON, RTL_TEXTENCODING_ASCII_US).getStr()); + boost::property_tree::ptree aTree; + boost::property_tree::read_json(aStream, aTree); + + for (const auto& rPair : aTree) + { + aArgs[OUString::fromUtf8(rPair.first.c_str())] = OUString::fromUtf8(rPair.second.get_value(".").c_str()); + } + } + return aArgs; + } + + XGradient lcl_buildGradientFromStringMap(StringMap& rMap) + { + XGradient aGradient; + + aGradient.SetStartColor(Color(ColorTransparency, rMap["startcolor"].toInt32(16))); + aGradient.SetEndColor(Color(ColorTransparency, rMap["endcolor"].toInt32(16))); + aGradient.SetGradientStyle(lcl_getStyleFromString(rMap["style"])); + aGradient.SetAngle(Degree10(rMap["angle"].toInt32())); + + return aGradient; + } +} + +XGradient XGradient::fromJSON(const OUString& rJSON) +{ + StringMap aMap(lcl_jsonToStringMap(rJSON)); + return lcl_buildGradientFromStringMap(aMap); +} + +css::awt::Gradient XGradient::toGradientUNO() const +{ + css::awt::Gradient aGradient; + + aGradient.Style = this->GetGradientStyle(); + aGradient.StartColor = static_cast(this->GetStartColor()); + aGradient.EndColor = static_cast(this->GetEndColor()); + aGradient.Angle = static_cast(this->GetAngle()); + aGradient.Border = this->GetBorder(); + aGradient.XOffset = this->GetXOffset(); + aGradient.YOffset = this->GetYOffset(); + aGradient.StartIntensity = this->GetStartIntens(); + aGradient.EndIntensity = this->GetEndIntens(); + aGradient.StepCount = this->GetSteps(); + + return aGradient; +} + +XGradient::XGradient() : + eStyle( css::awt::GradientStyle_LINEAR ), + aStartColor( COL_BLACK ), + aEndColor( COL_WHITE ), + nAngle( 0 ), + nBorder( 0 ), + nOfsX( 50 ), + nOfsY( 50 ), + nIntensStart( 100 ), + nIntensEnd( 100 ), + nStepCount( 0 ) +{ +} + +XGradient::XGradient(const Color& rStart, const Color& rEnd, + css::awt::GradientStyle eTheStyle, Degree10 nTheAngle, sal_uInt16 nXOfs, + sal_uInt16 nYOfs, sal_uInt16 nTheBorder, + sal_uInt16 nStartIntens, sal_uInt16 nEndIntens, + sal_uInt16 nSteps) : + eStyle(eTheStyle), + aStartColor(rStart), + aEndColor(rEnd), + nAngle(nTheAngle), + nBorder(nTheBorder), + nOfsX(nXOfs), + nOfsY(nYOfs), + nIntensStart(nStartIntens), + nIntensEnd(nEndIntens), + nStepCount(nSteps) +{ +} + +bool XGradient::operator==(const XGradient& rGradient) const +{ + return ( eStyle == rGradient.eStyle && + aStartColor == rGradient.aStartColor && + aEndColor == rGradient.aEndColor && + nAngle == rGradient.nAngle && + nBorder == rGradient.nBorder && + nOfsX == rGradient.nOfsX && + nOfsY == rGradient.nOfsY && + nIntensStart == rGradient.nIntensStart && + nIntensEnd == rGradient.nIntensEnd && + nStepCount == rGradient.nStepCount ); +} + +boost::property_tree::ptree XGradient::dumpAsJSON() const +{ + boost::property_tree::ptree aTree; + + aTree.put("style", XGradient::GradientStyleToString(eStyle)); + aTree.put("startcolor",aStartColor.AsRGBHexString()); + aTree.put("endcolor", aEndColor.AsRGBHexString()); + aTree.put("angle", std::to_string(nAngle.get())); + aTree.put("border", std::to_string(nBorder)); + aTree.put("x", std::to_string(nOfsX)); + aTree.put("y", std::to_string(nOfsY)); + aTree.put("intensstart", std::to_string(nIntensStart)); + aTree.put("intensend", std::to_string(nIntensEnd)); + aTree.put("stepcount", std::to_string(nStepCount)); + + return aTree; +} + +SfxPoolItem* XFillGradientItem::CreateDefault() { return new XFillGradientItem; } + +XFillGradientItem::XFillGradientItem(sal_Int32 nIndex, + const XGradient& rTheGradient) : + NameOrIndex(XATTR_FILLGRADIENT, nIndex), + aGradient(rTheGradient) +{ +} + +XFillGradientItem::XFillGradientItem(const OUString& rName, + const XGradient& rTheGradient, TypedWhichId nWhich) + : NameOrIndex(nWhich, rName) + , aGradient(rTheGradient) +{ +} + +XFillGradientItem::XFillGradientItem(const XFillGradientItem& rItem) : + NameOrIndex(rItem), + aGradient(rItem.aGradient) +{ +} + +XFillGradientItem::XFillGradientItem( const XGradient& rTheGradient ) +: NameOrIndex( XATTR_FILLGRADIENT, -1 ), + aGradient(rTheGradient) +{ +} + +XFillGradientItem* XFillGradientItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFillGradientItem(*this); +} + +bool XFillGradientItem::operator==(const SfxPoolItem& rItem) const +{ + return ( NameOrIndex::operator==(rItem) && + aGradient == static_cast(rItem).aGradient ); +} + +const XGradient& XFillGradientItem::GetGradientValue() const // GetValue -> GetGradientValue +{ + if (!IsIndex()) + return aGradient; + // ToDo: This should fail. We never called this code with a table so this should always + // have failed. Thus, I'm thinking that XFillGradientItem can't be an Index. + return aGradient; +} + +bool XFillGradientItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText = GetName(); + return true; +} + +bool XFillGradientItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const +{ + nMemberId &= ~CONVERT_TWIPS; + switch ( nMemberId ) + { + case 0: + { + css::awt::Gradient aGradient2; + + const XGradient& aXGradient = GetGradientValue(); + aGradient2.Style = aXGradient.GetGradientStyle(); + aGradient2.StartColor = static_cast(aXGradient.GetStartColor()); + aGradient2.EndColor = static_cast(aXGradient.GetEndColor()); + aGradient2.Angle = static_cast(aXGradient.GetAngle()); + aGradient2.Border = aXGradient.GetBorder(); + aGradient2.XOffset = aXGradient.GetXOffset(); + aGradient2.YOffset = aXGradient.GetYOffset(); + aGradient2.StartIntensity = aXGradient.GetStartIntens(); + aGradient2.EndIntensity = aXGradient.GetEndIntens(); + aGradient2.StepCount = aXGradient.GetSteps(); + + uno::Sequence< beans::PropertyValue > aPropSeq{ + comphelper::makePropertyValue("Name", SvxUnogetApiNameForItem(Which(), GetName())), + comphelper::makePropertyValue("FillGradient", aGradient2) + }; + rVal <<= aPropSeq; + break; + } + + case MID_FILLGRADIENT: + { + const XGradient& aXGradient = GetGradientValue(); + css::awt::Gradient aGradient2; + + aGradient2.Style = aXGradient.GetGradientStyle(); + aGradient2.StartColor = static_cast(aXGradient.GetStartColor()); + aGradient2.EndColor = static_cast(aXGradient.GetEndColor()); + aGradient2.Angle = static_cast(aXGradient.GetAngle()); + aGradient2.Border = aXGradient.GetBorder(); + aGradient2.XOffset = aXGradient.GetXOffset(); + aGradient2.YOffset = aXGradient.GetYOffset(); + aGradient2.StartIntensity = aXGradient.GetStartIntens(); + aGradient2.EndIntensity = aXGradient.GetEndIntens(); + aGradient2.StepCount = aXGradient.GetSteps(); + + rVal <<= aGradient2; + break; + } + + case MID_NAME: + { + rVal <<= SvxUnogetApiNameForItem(Which(), GetName()); + break; + } + + case MID_GRADIENT_STYLE: rVal <<= static_cast(GetGradientValue().GetGradientStyle()); break; + case MID_GRADIENT_STARTCOLOR: rVal <<= GetGradientValue().GetStartColor(); break; + case MID_GRADIENT_ENDCOLOR: rVal <<= GetGradientValue().GetEndColor(); break; + case MID_GRADIENT_ANGLE: rVal <<= static_cast(GetGradientValue().GetAngle()); break; + case MID_GRADIENT_BORDER: rVal <<= GetGradientValue().GetBorder(); break; + case MID_GRADIENT_XOFFSET: rVal <<= GetGradientValue().GetXOffset(); break; + case MID_GRADIENT_YOFFSET: rVal <<= GetGradientValue().GetYOffset(); break; + case MID_GRADIENT_STARTINTENSITY: rVal <<= GetGradientValue().GetStartIntens(); break; + case MID_GRADIENT_ENDINTENSITY: rVal <<= GetGradientValue().GetEndIntens(); break; + case MID_GRADIENT_STEPCOUNT: rVal <<= GetGradientValue().GetSteps(); break; + + default: OSL_FAIL("Wrong MemberId!"); return false; + } + + return true; +} + +bool XFillGradientItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) +{ + nMemberId &= ~CONVERT_TWIPS; + + switch ( nMemberId ) + { + case 0: + { + uno::Sequence< beans::PropertyValue > aPropSeq; + + if ( rVal >>= aPropSeq ) + { + css::awt::Gradient aGradient2; + OUString aName; + bool bGradient( false ); + for ( const auto& rProp : std::as_const(aPropSeq) ) + { + if ( rProp.Name == "Name" ) + rProp.Value >>= aName; + else if ( rProp.Name == "FillGradient" ) + { + if ( rProp.Value >>= aGradient2 ) + bGradient = true; + } + } + + SetName( aName ); + if ( bGradient ) + { + XGradient aXGradient; + + aXGradient.SetGradientStyle( aGradient2.Style ); + aXGradient.SetStartColor( Color(ColorTransparency, aGradient2.StartColor) ); + aXGradient.SetEndColor( Color(ColorTransparency, aGradient2.EndColor) ); + aXGradient.SetAngle( Degree10(aGradient2.Angle) ); + aXGradient.SetBorder( aGradient2.Border ); + aXGradient.SetXOffset( aGradient2.XOffset ); + aXGradient.SetYOffset( aGradient2.YOffset ); + aXGradient.SetStartIntens( aGradient2.StartIntensity ); + aXGradient.SetEndIntens( aGradient2.EndIntensity ); + aXGradient.SetSteps( aGradient2.StepCount ); + + SetGradientValue( aXGradient ); + } + + return true; + } + + return false; + } + + case MID_NAME: + { + OUString aName; + if (!(rVal >>= aName )) + return false; + SetName( aName ); + break; + } + + case MID_FILLGRADIENT: + { + css::awt::Gradient aGradient2; + if(!(rVal >>= aGradient2)) + return false; + + XGradient aXGradient; + + aXGradient.SetGradientStyle( aGradient2.Style ); + aXGradient.SetStartColor( Color(ColorTransparency, aGradient2.StartColor) ); + aXGradient.SetEndColor( Color(ColorTransparency, aGradient2.EndColor) ); + aXGradient.SetAngle( Degree10(aGradient2.Angle) ); + aXGradient.SetBorder( aGradient2.Border ); + aXGradient.SetXOffset( aGradient2.XOffset ); + aXGradient.SetYOffset( aGradient2.YOffset ); + aXGradient.SetStartIntens( aGradient2.StartIntensity ); + aXGradient.SetEndIntens( aGradient2.EndIntensity ); + aXGradient.SetSteps( aGradient2.StepCount ); + + SetGradientValue( aXGradient ); + break; + } + + case MID_GRADIENT_STARTCOLOR: + case MID_GRADIENT_ENDCOLOR: + { + Color nVal; + if(!(rVal >>= nVal )) + return false; + + XGradient aXGradient = GetGradientValue(); + + if ( nMemberId == MID_GRADIENT_STARTCOLOR ) + aXGradient.SetStartColor( nVal ); + else + aXGradient.SetEndColor( nVal ); + SetGradientValue( aXGradient ); + break; + } + + case MID_GRADIENT_STYLE: + case MID_GRADIENT_ANGLE: + case MID_GRADIENT_BORDER: + case MID_GRADIENT_STARTINTENSITY: + case MID_GRADIENT_ENDINTENSITY: + case MID_GRADIENT_STEPCOUNT: + case MID_GRADIENT_XOFFSET: + case MID_GRADIENT_YOFFSET: + { + sal_Int16 nVal = sal_Int16(); + if(!(rVal >>= nVal )) + return false; + + XGradient aXGradient = GetGradientValue(); + + switch ( nMemberId ) + { + case MID_GRADIENT_STYLE: + aXGradient.SetGradientStyle( static_cast(nVal) ); break; + case MID_GRADIENT_ANGLE: + aXGradient.SetAngle( Degree10(nVal) ); break; + case MID_GRADIENT_BORDER: + aXGradient.SetBorder( nVal ); break; + case MID_GRADIENT_STARTINTENSITY: + aXGradient.SetStartIntens( nVal ); break; + case MID_GRADIENT_ENDINTENSITY: + aXGradient.SetEndIntens( nVal ); break; + case MID_GRADIENT_STEPCOUNT: + aXGradient.SetSteps( nVal ); break; + case MID_GRADIENT_XOFFSET: + aXGradient.SetXOffset( nVal ); break; + case MID_GRADIENT_YOFFSET: + aXGradient.SetYOffset( nVal ); break; + } + + SetGradientValue( aXGradient ); + break; + } + } + + return true; +} + +bool XFillGradientItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 ) +{ + return static_cast(p1)->GetGradientValue() == static_cast(p2)->GetGradientValue(); +} + +std::unique_ptr XFillGradientItem::checkForUniqueItem( SdrModel* pModel ) const +{ + if( pModel ) + { + const OUString aUniqueName = NameOrIndex::CheckNamedItem( + this, Which(), &pModel->GetItemPool(), + XFillGradientItem::CompareValueFunc, RID_SVXSTR_GRADIENT, + pModel->GetPropertyList( XPropertyListType::Gradient ) ); + + // if the given name is not valid, replace it! + if( aUniqueName != GetName() ) + return std::make_unique( aUniqueName, aGradient, TypedWhichId(Which()) ); + } + + return nullptr; +} + +boost::property_tree::ptree XFillGradientItem::dumpAsJSON() const +{ + boost::property_tree::ptree aTree = SfxPoolItem::dumpAsJSON(); + + if (Which() == XATTR_FILLGRADIENT) + aTree.put("commandName", ".uno:FillGradient"); + + aTree.push_back(std::make_pair("state", GetGradientValue().dumpAsJSON())); + + return aTree; +} + + +SfxPoolItem* XFillFloatTransparenceItem::CreateDefault() { return new XFillFloatTransparenceItem; } + +XFillFloatTransparenceItem::XFillFloatTransparenceItem() : + bEnabled( false ) +{ + SetWhich( XATTR_FILLFLOATTRANSPARENCE ); +} + +XFillFloatTransparenceItem::XFillFloatTransparenceItem(const OUString& rName, const XGradient& rGradient, bool bEnable ) : + XFillGradientItem ( rName, rGradient ), + bEnabled ( bEnable ) +{ + SetWhich( XATTR_FILLFLOATTRANSPARENCE ); +} + +XFillFloatTransparenceItem::XFillFloatTransparenceItem( const XFillFloatTransparenceItem& rItem ) : + XFillGradientItem ( rItem ), + bEnabled ( rItem.bEnabled ) +{ + SetWhich( XATTR_FILLFLOATTRANSPARENCE ); +} + +XFillFloatTransparenceItem::XFillFloatTransparenceItem(const XGradient& rTheGradient, bool bEnable ) +: XFillGradientItem ( -1, rTheGradient ), + bEnabled ( bEnable ) +{ + SetWhich( XATTR_FILLFLOATTRANSPARENCE ); +} + +bool XFillFloatTransparenceItem::operator==( const SfxPoolItem& rItem ) const +{ + return ( NameOrIndex::operator==(rItem) ) && + ( GetGradientValue() == static_cast(rItem).GetGradientValue() ) && + ( bEnabled == static_cast(rItem).bEnabled ); +} + +XFillFloatTransparenceItem* XFillFloatTransparenceItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new XFillFloatTransparenceItem( *this ); +} + +bool XFillFloatTransparenceItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const +{ + return XFillGradientItem::QueryValue( rVal, nMemberId ); +} + +bool XFillFloatTransparenceItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) +{ + return XFillGradientItem::PutValue( rVal, nMemberId ); +} + +bool XFillFloatTransparenceItem::GetPresentation( SfxItemPresentation ePres, + MapUnit eCoreUnit, MapUnit ePresUnit, + OUString& rText, + const IntlWrapper& rIntlWrapper ) const +{ + return XFillGradientItem::GetPresentation( ePres, eCoreUnit, ePresUnit, rText, rIntlWrapper ); +} + +bool XFillFloatTransparenceItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 ) +{ + return static_cast(p1)->IsEnabled() == static_cast(p2)->IsEnabled() && + static_cast(p1)->GetGradientValue() == static_cast(p2)->GetGradientValue(); +} + +std::unique_ptr XFillFloatTransparenceItem::checkForUniqueItem( SdrModel* pModel ) const +{ + // #85953# unique name only necessary when enabled + if(IsEnabled()) + { + if( pModel ) + { + const OUString aUniqueName = NameOrIndex::CheckNamedItem( this, + XATTR_FILLFLOATTRANSPARENCE, + &pModel->GetItemPool(), + XFillFloatTransparenceItem::CompareValueFunc, + RID_SVXSTR_TRASNGR0, + XPropertyListRef() ); + + // if the given name is not valid, replace it! + if( aUniqueName != GetName() ) + { + return std::make_unique( aUniqueName, GetGradientValue(), true ); + } + } + } + else + { + // #85953# if disabled, force name to empty string + if( !GetName().isEmpty() ) + { + return std::make_unique(OUString(), GetGradientValue(), false); + } + } + + return nullptr; +} + +boost::property_tree::ptree XFillFloatTransparenceItem::dumpAsJSON() const +{ + boost::property_tree::ptree aTree = XFillGradientItem::dumpAsJSON(); + aTree.put("commandName", ".uno:FillFloatTransparence"); + + if (!bEnabled) + { + boost::property_tree::ptree& rState = aTree.get_child("state"); + // When gradient fill is disabled, the intensity fields contain the + // constant encoded percent-transparency. However we use that here to just + // distinguish between 'None' and 'Solid' types and correct the 'style' + // property appropriately. + if (GetGradientValue().GetStartIntens() == 100) + rState.put("style", "NONE"); + else + rState.put("style", "SOLID"); + } + + return aTree; +} + +XHatch::XHatch(const Color& rCol, css::drawing::HatchStyle eTheStyle, tools::Long nTheDistance, + Degree10 nTheAngle) : + eStyle(eTheStyle), + aColor(rCol), + nDistance(nTheDistance), + nAngle(nTheAngle) +{ +} + +bool XHatch::operator==(const XHatch& rHatch) const +{ + return ( eStyle == rHatch.eStyle && + aColor == rHatch.aColor && + nDistance == rHatch.nDistance && + nAngle == rHatch.nAngle ); +} + + +SfxPoolItem* XFillHatchItem::CreateDefault() { return new XFillHatchItem; } + +XFillHatchItem::XFillHatchItem(const OUString& rName, + const XHatch& rTheHatch) : + NameOrIndex(XATTR_FILLHATCH, rName), + aHatch(rTheHatch) +{ +} + +XFillHatchItem::XFillHatchItem(const XFillHatchItem& rItem) : + NameOrIndex(rItem), + aHatch(rItem.aHatch) +{ +} + +XFillHatchItem::XFillHatchItem(const XHatch& rTheHatch) +: NameOrIndex( XATTR_FILLHATCH, -1 ), + aHatch(rTheHatch) +{ +} + +XFillHatchItem* XFillHatchItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFillHatchItem(*this); +} + +bool XFillHatchItem::operator==(const SfxPoolItem& rItem) const +{ + return ( NameOrIndex::operator==(rItem) && + aHatch == static_cast(rItem).aHatch ); +} + +bool XFillHatchItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText = GetName(); + return true; +} + +bool XFillHatchItem::HasMetrics() const +{ + return true; +} + +void XFillHatchItem::ScaleMetrics(tools::Long nMul, tools::Long nDiv) +{ + aHatch.SetDistance( BigInt::Scale( aHatch.GetDistance(), nMul, nDiv ) ); +} + +bool XFillHatchItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const +{ + nMemberId &= ~CONVERT_TWIPS; + + switch ( nMemberId ) + { + case 0: + { + css::drawing::Hatch aUnoHatch; + + aUnoHatch.Style = aHatch.GetHatchStyle(); + aUnoHatch.Color = sal_Int32(aHatch.GetColor()); + aUnoHatch.Distance = aHatch.GetDistance(); + aUnoHatch.Angle = aHatch.GetAngle().get(); + + uno::Sequence< beans::PropertyValue > aPropSeq{ + comphelper::makePropertyValue("Name", SvxUnogetApiNameForItem(Which(), GetName())), + comphelper::makePropertyValue("FillHatch", aUnoHatch) + }; + rVal <<= aPropSeq; + break; + } + + case MID_FILLHATCH: + { + css::drawing::Hatch aUnoHatch; + + aUnoHatch.Style = aHatch.GetHatchStyle(); + aUnoHatch.Color = sal_Int32(aHatch.GetColor()); + aUnoHatch.Distance = aHatch.GetDistance(); + aUnoHatch.Angle = aHatch.GetAngle().get(); + rVal <<= aUnoHatch; + break; + } + + case MID_NAME: + { + rVal <<= SvxUnogetApiNameForItem(Which(), GetName()); + break; + } + + case MID_HATCH_STYLE: + rVal <<= aHatch.GetHatchStyle(); break; + case MID_HATCH_COLOR: + rVal <<= aHatch.GetColor(); break; + case MID_HATCH_DISTANCE: + rVal <<= aHatch.GetDistance(); break; + case MID_HATCH_ANGLE: + rVal <<= aHatch.GetAngle().get(); break; + + default: OSL_FAIL("Wrong MemberId!"); return false; + } + + return true; +} + +bool XFillHatchItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) +{ + nMemberId &= ~CONVERT_TWIPS; + + switch ( nMemberId ) + { + case 0: + { + uno::Sequence< beans::PropertyValue > aPropSeq; + if ( rVal >>= aPropSeq ) + { + css::drawing::Hatch aUnoHatch; + OUString aName; + bool bHatch( false ); + for ( const auto& rProp : std::as_const(aPropSeq) ) + { + if ( rProp.Name == "Name" ) + rProp.Value >>= aName; + else if ( rProp.Name == "FillHatch" ) + { + if ( rProp.Value >>= aUnoHatch ) + bHatch = true; + } + } + + SetName( aName ); + if ( bHatch ) + { + aHatch.SetHatchStyle( aUnoHatch.Style ); + aHatch.SetColor( Color(ColorTransparency, aUnoHatch.Color) ); + aHatch.SetDistance( aUnoHatch.Distance ); + aHatch.SetAngle( Degree10(aUnoHatch.Angle) ); + } + + return true; + } + + return false; + } + + case MID_FILLHATCH: + { + css::drawing::Hatch aUnoHatch; + if(!(rVal >>= aUnoHatch)) + return false; + + aHatch.SetHatchStyle( aUnoHatch.Style ); + aHatch.SetColor( Color(ColorTransparency, aUnoHatch.Color) ); + aHatch.SetDistance( aUnoHatch.Distance ); + aHatch.SetAngle( Degree10(aUnoHatch.Angle) ); + break; + } + + case MID_NAME: + { + OUString aName; + if (!(rVal >>= aName )) + return false; + SetName( aName ); + break; + } + + case MID_HATCH_STYLE: + { + sal_Int16 nVal = sal_Int16(); + if (!(rVal >>= nVal )) + return false; + aHatch.SetHatchStyle( static_cast(nVal) ); + break; + } + + case MID_HATCH_COLOR: + case MID_HATCH_DISTANCE: + case MID_HATCH_ANGLE: + { + sal_Int32 nVal = 0; + if (!(rVal >>= nVal )) + return false; + + if ( nMemberId == MID_HATCH_COLOR ) + aHatch.SetColor( Color(ColorTransparency, nVal) ); + else if ( nMemberId == MID_HATCH_DISTANCE ) + aHatch.SetDistance( nVal ); + else + aHatch.SetAngle( Degree10(nVal) ); + break; + } + + default: OSL_FAIL("Wrong MemberId!"); return false; + } + + return true; +} + +bool XFillHatchItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 ) +{ + return static_cast(p1)->GetHatchValue() == static_cast(p2)->GetHatchValue(); +} + +std::unique_ptr XFillHatchItem::checkForUniqueItem( SdrModel* pModel ) const +{ + if( pModel ) + { + const OUString aUniqueName = NameOrIndex::CheckNamedItem( + this, XATTR_FILLHATCH, &pModel->GetItemPool(), + XFillHatchItem::CompareValueFunc, RID_SVXSTR_HATCH10, + pModel->GetPropertyList( XPropertyListType::Hatch ) ); + + // if the given name is not valid, replace it! + if( aUniqueName != GetName() ) + return std::make_unique( aUniqueName, aHatch ); + } + + return nullptr; +} + +// --- form text attributes --- + + +SfxPoolItem* XFormTextStyleItem::CreateDefault() { return new XFormTextStyleItem; } + +XFormTextStyleItem::XFormTextStyleItem(XFormTextStyle eTheStyle) : + SfxEnumItem(XATTR_FORMTXTSTYLE, eTheStyle) +{ +} + +XFormTextStyleItem* XFormTextStyleItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFormTextStyleItem( *this ); +} + +sal_uInt16 XFormTextStyleItem::GetValueCount() const +{ + return 5; +} + +bool XFormTextStyleItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= static_cast(GetValue()); + return true; +} + +bool XFormTextStyleItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + sal_Int32 nValue = 0; + rVal >>= nValue; + SetValue(static_cast(nValue)); + + return true; +} + + +SfxPoolItem* XFormTextAdjustItem::CreateDefault() { return new XFormTextAdjustItem; } + +XFormTextAdjustItem::XFormTextAdjustItem(XFormTextAdjust eTheAdjust) : + SfxEnumItem(XATTR_FORMTXTADJUST, eTheAdjust) +{ +} + +XFormTextAdjustItem* XFormTextAdjustItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFormTextAdjustItem( *this ); +} + +sal_uInt16 XFormTextAdjustItem::GetValueCount() const +{ + return 4; +} + +bool XFormTextAdjustItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= static_cast(GetValue()); + return true; +} + +bool XFormTextAdjustItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + sal_Int32 nValue = 0; + rVal >>= nValue; + SetValue(static_cast(nValue)); + + return true; +} + + +SfxPoolItem* XFormTextDistanceItem::CreateDefault() { return new XFormTextDistanceItem; } + +XFormTextDistanceItem::XFormTextDistanceItem(tools::Long nDist) : + SfxMetricItem(XATTR_FORMTXTDISTANCE, nDist) +{ +} + +XFormTextDistanceItem* XFormTextDistanceItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFormTextDistanceItem(*this); +} + +SfxPoolItem* XFormTextStartItem::CreateDefault() { return new XFormTextStartItem; } + +XFormTextStartItem::XFormTextStartItem(tools::Long nStart) : + SfxMetricItem(XATTR_FORMTXTSTART, nStart) +{ +} + +XFormTextStartItem* XFormTextStartItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFormTextStartItem(*this); +} + +SfxPoolItem* XFormTextMirrorItem::CreateDefault() { return new XFormTextMirrorItem; } + +XFormTextMirrorItem::XFormTextMirrorItem(bool bMirror) : + SfxBoolItem(XATTR_FORMTXTMIRROR, bMirror) +{ +} + +XFormTextMirrorItem* XFormTextMirrorItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFormTextMirrorItem(*this); +} + +SfxPoolItem* XFormTextOutlineItem::CreateDefault() { return new XFormTextOutlineItem; } + +XFormTextOutlineItem::XFormTextOutlineItem(bool bOutline) : + SfxBoolItem(XATTR_FORMTXTOUTLINE, bOutline) +{ +} + +XFormTextOutlineItem* XFormTextOutlineItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFormTextOutlineItem(*this); +} + +SfxPoolItem* XFormTextShadowItem::CreateDefault() { return new XFormTextShadowItem; } + +XFormTextShadowItem::XFormTextShadowItem(XFormTextShadow eFormTextShadow) : + SfxEnumItem(XATTR_FORMTXTSHADOW, eFormTextShadow) +{ +} + +XFormTextShadowItem* XFormTextShadowItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFormTextShadowItem( *this ); +} + +sal_uInt16 XFormTextShadowItem::GetValueCount() const +{ + return 3; +} + +bool XFormTextShadowItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= static_cast(GetValue()); + return true; +} + +bool XFormTextShadowItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + sal_Int32 nValue = 0; + rVal >>= nValue; + SetValue(static_cast(nValue)); + + return true; +} + + +SfxPoolItem* XFormTextShadowColorItem::CreateDefault() { return new XFormTextShadowColorItem; } + +XFormTextShadowColorItem::XFormTextShadowColorItem(const OUString& rName, + const Color& rTheColor) : + XColorItem(XATTR_FORMTXTSHDWCOLOR, rName, rTheColor) +{ +} + +XFormTextShadowColorItem* XFormTextShadowColorItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFormTextShadowColorItem(*this); +} + +SfxPoolItem* XFormTextShadowXValItem::CreateDefault() { return new XFormTextShadowXValItem; } + +XFormTextShadowXValItem::XFormTextShadowXValItem(tools::Long nVal) : + SfxMetricItem(XATTR_FORMTXTSHDWXVAL, nVal) +{ +} + +XFormTextShadowXValItem* XFormTextShadowXValItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFormTextShadowXValItem(*this); +} + +SfxPoolItem* XFormTextShadowYValItem::CreateDefault() { return new XFormTextShadowYValItem; } + +XFormTextShadowYValItem::XFormTextShadowYValItem(tools::Long nVal) : + SfxMetricItem(XATTR_FORMTXTSHDWYVAL, nVal) +{ +} + +XFormTextShadowYValItem* XFormTextShadowYValItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFormTextShadowYValItem(*this); +} + +SfxPoolItem* XFormTextHideFormItem::CreateDefault() { return new XFormTextHideFormItem; } + +XFormTextHideFormItem::XFormTextHideFormItem(bool bHide) : + SfxBoolItem(XATTR_FORMTXTHIDEFORM, bHide) +{ +} + +XFormTextHideFormItem* XFormTextHideFormItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFormTextHideFormItem(*this); +} + +// --- SetItems --- + + +/// a line attribute set item +XLineAttrSetItem::XLineAttrSetItem( SfxItemSet&& pItemSet ) : + SfxSetItem( XATTRSET_LINE, std::move(pItemSet)) +{ +} + +XLineAttrSetItem::XLineAttrSetItem( SfxItemPool* pItemPool ) : + SfxSetItem( XATTRSET_LINE, + SfxItemSetFixed( *pItemPool )) +{ +} + +XLineAttrSetItem::XLineAttrSetItem( const XLineAttrSetItem& rLineAttr ) : + SfxSetItem( rLineAttr ) +{ +} + +XLineAttrSetItem::XLineAttrSetItem( const XLineAttrSetItem& rLineAttr, + SfxItemPool* pItemPool) : + SfxSetItem( rLineAttr, pItemPool ) +{ +} + +XLineAttrSetItem* XLineAttrSetItem::Clone( SfxItemPool* pPool ) const +{ + return new XLineAttrSetItem( *this, pPool ); +} + +/// fill attribute set item +XFillAttrSetItem::XFillAttrSetItem( SfxItemSet&& pItemSet ) : + SfxSetItem( XATTRSET_FILL, std::move(pItemSet)) +{ +} + +XFillAttrSetItem::XFillAttrSetItem( SfxItemPool* pItemPool ) : + SfxSetItem( XATTRSET_FILL, + SfxItemSetFixed( *pItemPool )) +{ +} + +XFillAttrSetItem::XFillAttrSetItem( const XFillAttrSetItem& rFillAttr ) : + SfxSetItem( rFillAttr ) +{ +} + +XFillAttrSetItem::XFillAttrSetItem( const XFillAttrSetItem& rFillAttr, + SfxItemPool* pItemPool ) : + SfxSetItem( rFillAttr, pItemPool ) +{ +} + +XFillAttrSetItem* XFillAttrSetItem::Clone( SfxItemPool* pPool ) const +{ + return new XFillAttrSetItem( *this, pPool ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/xoutdev/xattr2.cxx b/svx/source/xoutdev/xattr2.cxx new file mode 100644 index 000000000..ad1b3b295 --- /dev/null +++ b/svx/source/xoutdev/xattr2.cxx @@ -0,0 +1,731 @@ +/* -*- 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 +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +XLineTransparenceItem::XLineTransparenceItem(sal_uInt16 nLineTransparence) : + SfxUInt16Item(XATTR_LINETRANSPARENCE, nLineTransparence) +{ +} + +XLineTransparenceItem* XLineTransparenceItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XLineTransparenceItem(*this); +} + +bool XLineTransparenceItem::GetPresentation +( + SfxItemPresentation ePres, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText.clear(); + + switch ( ePres ) + { + case SfxItemPresentation::Complete: + rText = SvxResId(RID_SVXSTR_TRANSPARENCE) + ": "; + [[fallthrough]]; + case SfxItemPresentation::Nameless: + rText += unicode::formatPercent(GetValue(), + Application::GetSettings().GetUILanguageTag()); + return true; + default: + return false; + } +} + + +SfxPoolItem* XLineJointItem::CreateDefault() { return new XLineJointItem; } + +XLineJointItem::XLineJointItem( css::drawing::LineJoint eLineJoint ) : + SfxEnumItem(XATTR_LINEJOINT, eLineJoint) +{ +} + +XLineJointItem* XLineJointItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XLineJointItem( *this ); +} + +bool XLineJointItem::GetPresentation( SfxItemPresentation /*ePres*/, MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, OUString& rText, const IntlWrapper&) const +{ + rText.clear(); + + TranslateId pId; + + switch( GetValue() ) + { + case css::drawing::LineJoint::LineJoint_MAKE_FIXED_SIZE: + case css::drawing::LineJoint_NONE: + pId = comphelper::LibreOfficeKit::isActive() ? RID_SVXSTR_INVISIBLE : RID_SVXSTR_NONE; + break; + + case css::drawing::LineJoint_MIDDLE: + pId = RID_SVXSTR_LINEJOINT_MIDDLE; + break; + + + case css::drawing::LineJoint_BEVEL: + pId = RID_SVXSTR_LINEJOINT_BEVEL; + break; + + + case css::drawing::LineJoint_MITER: + pId = RID_SVXSTR_LINEJOINT_MITER; + break; + + + case css::drawing::LineJoint_ROUND: + pId = RID_SVXSTR_LINEJOINT_ROUND; + break; + } + + if (pId) + rText = SvxResId(pId); + + return true; +} + +bool XLineJointItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + const css::drawing::LineJoint eJoint = GetValue(); + rVal <<= eJoint; + return true; +} + +bool XLineJointItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + css::drawing::LineJoint eUnoJoint; + + if(!(rVal >>= eUnoJoint)) + { + // also try an int (for Basic) + sal_Int32 nLJ = 0; + if(!(rVal >>= nLJ)) + return false; + eUnoJoint = static_cast(nLJ); + } + + SetValue( eUnoJoint ); + + return true; +} + +sal_uInt16 XLineJointItem::GetValueCount() const +{ + // don't forget to update the api interface also + return 5; +} + + +AffineMatrixItem::AffineMatrixItem(const css::geometry::AffineMatrix2D* pMatrix) +: SfxPoolItem(SID_ATTR_TRANSFORM_MATRIX) +{ + if(pMatrix) + { + maMatrix = *pMatrix; + } + else + { + maMatrix.m00 = 1.0; + maMatrix.m01 = 0.0; + maMatrix.m02 = 0.0; + maMatrix.m10 = 0.0; + maMatrix.m11 = 1.0; + maMatrix.m12 = 0.0; + } +} + +AffineMatrixItem::AffineMatrixItem(const AffineMatrixItem& rRef) +: SfxPoolItem(rRef) +{ + maMatrix = rRef.maMatrix; +} + +AffineMatrixItem::~AffineMatrixItem() +{ +} + +bool AffineMatrixItem::operator==(const SfxPoolItem& rRef) const +{ + if(!SfxPoolItem::operator==(rRef)) + { + return false; + } + + const AffineMatrixItem* pRef = static_cast< const AffineMatrixItem* >(&rRef); + + if(!pRef) + { + return false; + } + + return (maMatrix.m00 == pRef->maMatrix.m00 + && maMatrix.m01 == pRef->maMatrix.m01 + && maMatrix.m02 == pRef->maMatrix.m02 + && maMatrix.m10 == pRef->maMatrix.m10 + && maMatrix.m11 == pRef->maMatrix.m11 + && maMatrix.m12 == pRef->maMatrix.m12); +} + +AffineMatrixItem* AffineMatrixItem::Clone( SfxItemPool* /*pPool*/ ) const +{ + return new AffineMatrixItem(*this); +} + +bool AffineMatrixItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const +{ + rVal <<= maMatrix; + return true; +} + +bool AffineMatrixItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) +{ + if (rVal >>= maMatrix) + { + return true; + } + + OSL_ENSURE(false, "AffineMatrixItem::PutValue - Wrong type!"); + return false; +} + + +SfxPoolItem* XLineCapItem::CreateDefault() { return new XLineCapItem; } + +XLineCapItem::XLineCapItem(css::drawing::LineCap eLineCap) +: SfxEnumItem(XATTR_LINECAP, eLineCap) +{ +} + +XLineCapItem* XLineCapItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XLineCapItem( *this ); +} + +bool XLineCapItem::GetPresentation( SfxItemPresentation /*ePres*/, MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, OUString& rText, const IntlWrapper&) const +{ + TranslateId pId; + + switch( GetValue() ) + { + default: /*css::drawing::LineCap_BUTT*/ + pId = RID_SVXSTR_LINECAP_BUTT; + break; + + case css::drawing::LineCap_ROUND: + pId = RID_SVXSTR_LINECAP_ROUND; + break; + + case css::drawing::LineCap_SQUARE: + pId = RID_SVXSTR_LINECAP_SQUARE; + break; + } + + rText = SvxResId(pId); + + return true; +} + +bool XLineCapItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + const css::drawing::LineCap eCap(GetValue()); + rVal <<= eCap; + return true; +} + +bool XLineCapItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + css::drawing::LineCap eUnoCap; + + if(!(rVal >>= eUnoCap)) + { + // also try an int (for Basic) + sal_Int32 nLJ(0); + + if(!(rVal >>= nLJ)) + { + return false; + } + + eUnoCap = static_cast(nLJ); + } + + OSL_ENSURE(css::drawing::LineCap_BUTT == eUnoCap + || css::drawing::LineCap_ROUND == eUnoCap + || css::drawing::LineCap_SQUARE == eUnoCap, "Unknown enum value in XATTR_LINECAP (!)"); + + SetValue(eUnoCap); + + return true; +} + +sal_uInt16 XLineCapItem::GetValueCount() const +{ + // don't forget to update the api interface also + return 3; +} + +css::drawing::LineCap XLineCapItem::GetValue() const +{ + const css::drawing::LineCap eRetval(SfxEnumItem::GetValue()); + OSL_ENSURE(css::drawing::LineCap_BUTT == eRetval + || css::drawing::LineCap_ROUND == eRetval + || css::drawing::LineCap_SQUARE == eRetval, "Unknown enum value in XATTR_LINECAP (!)"); + + return eRetval; +} + +XFillTransparenceItem::XFillTransparenceItem(sal_uInt16 nFillTransparence) : + SfxUInt16Item(XATTR_FILLTRANSPARENCE, nFillTransparence) +{ +} + +XFillTransparenceItem* XFillTransparenceItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFillTransparenceItem(*this); +} + +bool XFillTransparenceItem::GetPresentation +( + SfxItemPresentation ePres, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText.clear(); + + switch ( ePres ) + { + case SfxItemPresentation::Complete: + rText = SvxResId(RID_SVXSTR_TRANSPARENCE) + ": "; + [[fallthrough]]; + case SfxItemPresentation::Nameless: + rText += unicode::formatPercent(GetValue(), + Application::GetSettings().GetUILanguageTag()); + return true; + default: + return false; + } +} + +void XFillTransparenceItem::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillTransparenceItem")); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr())); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue()).getStr())); + (void)xmlTextWriterEndElement(pWriter); +} + + +XFormTextShadowTranspItem::XFormTextShadowTranspItem(sal_uInt16 nShdwTransparence) : + SfxUInt16Item(XATTR_FORMTXTSHDWTRANSP, nShdwTransparence) +{ +} + +XFormTextShadowTranspItem* XFormTextShadowTranspItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFormTextShadowTranspItem(*this); +} + + +XGradientStepCountItem::XGradientStepCountItem( sal_uInt16 nStepCount ) : + SfxUInt16Item( XATTR_GRADIENTSTEPCOUNT, nStepCount ) +{ +} + +XGradientStepCountItem* XGradientStepCountItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new XGradientStepCountItem( *this ); +} + +bool XGradientStepCountItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText.clear(); + + rText += OUString::number(GetValue()); + return true; +} + + +XFillBmpTileItem::XFillBmpTileItem( bool bTile ) : + SfxBoolItem( XATTR_FILLBMP_TILE, bTile ) +{ +} + +XFillBmpTileItem* XFillBmpTileItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new XFillBmpTileItem( *this ); +} + +bool XFillBmpTileItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText.clear(); + return true; +} + +void XFillBmpTileItem::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillBmpTileItem")); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr())); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr())); + (void)xmlTextWriterEndElement(pWriter); +} + + + +XFillBmpPosItem::XFillBmpPosItem( RectPoint eRP ) : + SfxEnumItem( XATTR_FILLBMP_POS, eRP ) +{ +} + +XFillBmpPosItem* XFillBmpPosItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new XFillBmpPosItem( *this ); +} + +bool XFillBmpPosItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText.clear(); + return true; +} + +sal_uInt16 XFillBmpPosItem::GetValueCount() const +{ + return 9; +} + +void XFillBmpPosItem::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillBmpPosItem")); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr())); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(static_cast(GetValue())).getStr())); + (void)xmlTextWriterEndElement(pWriter); +} + + +XFillBmpSizeXItem::XFillBmpSizeXItem( tools::Long nSizeX ) : + SfxMetricItem( XATTR_FILLBMP_SIZEX, nSizeX ) +{ +} + +XFillBmpSizeXItem* XFillBmpSizeXItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new XFillBmpSizeXItem( *this ); +} + +bool XFillBmpSizeXItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText.clear(); + return true; +} + +bool XFillBmpSizeXItem::HasMetrics() const +{ + return GetValue() > 0; +} + + + +XFillBmpSizeYItem::XFillBmpSizeYItem( tools::Long nSizeY ) : + SfxMetricItem( XATTR_FILLBMP_SIZEY, nSizeY ) +{ +} + +XFillBmpSizeYItem* XFillBmpSizeYItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new XFillBmpSizeYItem( *this ); +} + +bool XFillBmpSizeYItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText.clear(); + return true; +} + +bool XFillBmpSizeYItem::HasMetrics() const +{ + return GetValue() > 0; +} + + +XFillBmpSizeLogItem::XFillBmpSizeLogItem( bool bLog ) : + SfxBoolItem( XATTR_FILLBMP_SIZELOG, bLog ) +{ +} + +XFillBmpSizeLogItem* XFillBmpSizeLogItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new XFillBmpSizeLogItem( *this ); +} + +bool XFillBmpSizeLogItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText.clear(); + return true; +} + + + +XFillBmpTileOffsetXItem::XFillBmpTileOffsetXItem( sal_uInt16 nOffX ) : + SfxUInt16Item( XATTR_FILLBMP_TILEOFFSETX, nOffX ) +{ +} + +XFillBmpTileOffsetXItem* XFillBmpTileOffsetXItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new XFillBmpTileOffsetXItem( *this ); +} + +bool XFillBmpTileOffsetXItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText.clear(); + return true; +} + + +XFillBmpTileOffsetYItem::XFillBmpTileOffsetYItem( sal_uInt16 nOffY ) : + SfxUInt16Item( XATTR_FILLBMP_TILEOFFSETY, nOffY ) +{ +} + +XFillBmpTileOffsetYItem* XFillBmpTileOffsetYItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new XFillBmpTileOffsetYItem( *this ); +} + +bool XFillBmpTileOffsetYItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText.clear(); + return true; +} + +XFillBmpStretchItem::XFillBmpStretchItem( bool bStretch ) : + SfxBoolItem( XATTR_FILLBMP_STRETCH, bStretch ) +{ +} + +XFillBmpStretchItem* XFillBmpStretchItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new XFillBmpStretchItem( *this ); +} + +bool XFillBmpStretchItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText.clear(); + return true; +} + +void XFillBmpStretchItem::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillBmpStretchItem")); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr())); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr())); + (void)xmlTextWriterEndElement(pWriter); +} + + +XFillBmpPosOffsetXItem::XFillBmpPosOffsetXItem( sal_uInt16 nOffPosX ) : + SfxUInt16Item( XATTR_FILLBMP_POSOFFSETX, nOffPosX ) +{ +} + +XFillBmpPosOffsetXItem* XFillBmpPosOffsetXItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new XFillBmpPosOffsetXItem( *this ); +} + +bool XFillBmpPosOffsetXItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText.clear(); + return true; +} + + +XFillBmpPosOffsetYItem::XFillBmpPosOffsetYItem( sal_uInt16 nOffPosY ) : + SfxUInt16Item( XATTR_FILLBMP_POSOFFSETY, nOffPosY ) +{ +} + +XFillBmpPosOffsetYItem* XFillBmpPosOffsetYItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new XFillBmpPosOffsetYItem( *this ); +} + +bool XFillBmpPosOffsetYItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText.clear(); + return true; +} + +XFillBackgroundItem::XFillBackgroundItem( bool bFill ) : + SfxBoolItem( XATTR_FILLBACKGROUND, bFill ) +{ +} + +XFillBackgroundItem* XFillBackgroundItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new XFillBackgroundItem( *this ); +} + +bool XFillBackgroundItem::GetPresentation( SfxItemPresentation /*ePres*/, MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, OUString& rText, const IntlWrapper&) const +{ + rText.clear(); + return true; +} + +void XFillBackgroundItem::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillBackgroundItem")); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr())); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr())); + (void)xmlTextWriterEndElement(pWriter); +} + +XFillUseSlideBackgroundItem::XFillUseSlideBackgroundItem( bool bFill ) : + SfxBoolItem( XATTR_FILLUSESLIDEBACKGROUND, bFill ) +{ +} + +XFillUseSlideBackgroundItem* XFillUseSlideBackgroundItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new XFillUseSlideBackgroundItem( *this ); +} + +bool XFillUseSlideBackgroundItem::GetPresentation( SfxItemPresentation /*ePres*/, MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, OUString& rText, const IntlWrapper&) const +{ + rText.clear(); + return true; +} + +void XFillUseSlideBackgroundItem::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillUseSlideBackgroundItem")); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr())); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr())); + (void)xmlTextWriterEndElement(pWriter); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/xoutdev/xattrbmp.cxx b/svx/source/xoutdev/xattrbmp.cxx new file mode 100644 index 000000000..2401bb361 --- /dev/null +++ b/svx/source/xoutdev/xattrbmp.cxx @@ -0,0 +1,342 @@ +/* -*- 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 +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +using namespace ::com::sun::star; + +XOBitmap::XOBitmap( const BitmapEx& rBmp ) : + xGraphicObject (new GraphicObject(rBmp)), + bGraphicDirty ( false ) +{ +} + +XOBitmap::~XOBitmap() +{ +} + +BitmapEx XOBitmap::GetBitmap() const +{ + return GetGraphicObject().GetGraphic().GetBitmapEx(); +} + +const GraphicObject& XOBitmap::GetGraphicObject() const +{ + if( bGraphicDirty ) + const_cast(this)->Array2Bitmap(); + + return *xGraphicObject; +} + +void XOBitmap::Bitmap2Array() +{ + ScopedVclPtrInstance< VirtualDevice > pVDev; + bool bPixelColor = false; + const BitmapEx aBitmap( GetBitmap() ); + const sal_Int32 nLines = 8; // type dependent + + if( !pPixelArray ) + pPixelArray.reset( new sal_uInt16[ nLines * nLines ] ); + + pVDev->SetOutputSizePixel( aBitmap.GetSizePixel() ); + pVDev->DrawBitmapEx( Point(), aBitmap ); + aPixelColor = aBckgrColor = pVDev->GetPixel( Point() ); + + // create array and determine foreground and background color + for (sal_Int32 i = 0; i < nLines; ++i) + { + for (sal_Int32 j = 0; j < nLines; ++j) + { + if ( pVDev->GetPixel( Point( j, i ) ) == aBckgrColor ) + pPixelArray[ j + i * nLines ] = 0; + else + { + pPixelArray[ j + i * nLines ] = 1; + if( !bPixelColor ) + { + aPixelColor = pVDev->GetPixel( Point( j, i ) ); + bPixelColor = true; + } + } + } + } +} + +/// convert array, fore- and background color into a bitmap +void XOBitmap::Array2Bitmap() +{ + if (!pPixelArray) + return; + + ScopedVclPtrInstance< VirtualDevice > pVDev; + const sal_Int32 nLines = 8; // type dependent + + pVDev->SetOutputSizePixel( Size( nLines, nLines ) ); + + // create bitmap + for (sal_Int32 i = 0; i < nLines; ++i) + { + for (sal_Int32 j = 0; j < nLines; ++j) + { + if( pPixelArray[ j + i * nLines ] == 0 ) + pVDev->DrawPixel( Point( j, i ), aBckgrColor ); + else + pVDev->DrawPixel( Point( j, i ), aPixelColor ); + } + } + + xGraphicObject.reset(new GraphicObject(pVDev->GetBitmapEx(Point(), Size(nLines, nLines)))); + bGraphicDirty = false; +} + + +SfxPoolItem* XFillBitmapItem::CreateDefault() { return new XFillBitmapItem; } + +XFillBitmapItem::XFillBitmapItem(const OUString& rName, const GraphicObject& rGraphicObject) +: NameOrIndex(XATTR_FILLBITMAP, rName), + maGraphicObject(rGraphicObject) +{ +} + +XFillBitmapItem::XFillBitmapItem(const XFillBitmapItem& rItem) +: NameOrIndex(rItem), + maGraphicObject(rItem.maGraphicObject) +{ +} + +XFillBitmapItem::XFillBitmapItem(const GraphicObject& rGraphicObject) + : NameOrIndex(XATTR_FILLBITMAP, -1) + , maGraphicObject(rGraphicObject) +{ +} + +XFillBitmapItem* XFillBitmapItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new XFillBitmapItem(*this); +} + +bool XFillBitmapItem::operator==(const SfxPoolItem& rItem) const +{ + return (NameOrIndex::operator==(rItem) + && maGraphicObject == static_cast(rItem).maGraphicObject); +} + + +bool XFillBitmapItem::isPattern() const +{ + Color aBack, aFront; + return vcl::bitmap::isHistorical8x8(GetGraphicObject().GetGraphic().GetBitmapEx(), aBack, aFront); +} + +bool XFillBitmapItem::GetPresentation( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, + const IntlWrapper&) const +{ + rText += GetName(); + return true; +} + +bool XFillBitmapItem::QueryValue(css::uno::Any& rVal, sal_uInt8 nMemberId) const +{ + nMemberId &= ~CONVERT_TWIPS; + + // needed for MID_NAME + OUString aApiName; + // needed for complete item (MID 0) + OUString aInternalName; + + css::uno::Reference< css::awt::XBitmap > xBmp; + + if( nMemberId == MID_NAME ) + { + aApiName = SvxUnogetApiNameForItem(Which(), GetName()); + } + else if( nMemberId == 0 ) + { + aInternalName = GetName(); + } + + if (nMemberId == MID_BITMAP || + nMemberId == 0) + { + xBmp.set(GetGraphicObject().GetGraphic().GetXGraphic(), uno::UNO_QUERY); + } + + if( nMemberId == MID_NAME ) + rVal <<= aApiName; + else if( nMemberId == MID_BITMAP ) + rVal <<= xBmp; + else + { + // member-id 0 => complete item (e.g. for toolbars) + DBG_ASSERT( nMemberId == 0, "invalid member-id" ); + uno::Sequence< beans::PropertyValue > aPropSeq{ + comphelper::makePropertyValue("Name", aInternalName), + comphelper::makePropertyValue("Bitmap", xBmp) + }; + + rVal <<= aPropSeq; + } + + return true; +} + +bool XFillBitmapItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) +{ + nMemberId &= ~CONVERT_TWIPS; + + OUString aName; + OUString aURL; + css::uno::Reference< css::awt::XBitmap > xBmp; + css::uno::Reference< css::graphic::XGraphic > xGraphic; + + bool bSetURL = false; + bool bSetName = false; + bool bSetBitmap = false; + + if( nMemberId == MID_NAME ) + bSetName = (rVal >>= aName); + else if( nMemberId == MID_BITMAP ) + { + if (rVal.has()) + { + bSetURL = true; + aURL = rVal.get(); + } + else if (rVal.has>()) + { + bSetBitmap = true; + xBmp = rVal.get>(); + } + else if (rVal.has>()) + { + bSetBitmap = true; + xGraphic = rVal.get>(); + } + } + else + { + DBG_ASSERT( nMemberId == 0, "invalid member-id" ); + uno::Sequence< beans::PropertyValue > aPropSeq; + if( rVal >>= aPropSeq ) + { + for ( const auto& rProp : std::as_const(aPropSeq) ) + { + if ( rProp.Name == "Name" ) + bSetName = (rProp.Value >>= aName); + else if ( rProp.Name == "Bitmap" ) + bSetBitmap = (rProp.Value >>= xBmp); + else if ( rProp.Name == "FillBitmapURL" ) + bSetURL = (rProp.Value >>= aURL); + } + } + } + + if( bSetName ) + { + SetName( aName ); + } + if (bSetURL && !aURL.isEmpty()) + { + Graphic aGraphic = vcl::graphic::loadFromURL(aURL); + if (!aGraphic.IsNone()) + { + maGraphicObject.SetGraphic(aGraphic.GetXGraphic()); + } + } + else if( bSetBitmap ) + { + if (xBmp.is()) + { + xGraphic.set(xBmp, uno::UNO_QUERY); + } + if (xGraphic.is()) + { + maGraphicObject.SetGraphic(xGraphic); + } + } + + return (bSetURL || bSetName || bSetBitmap); +} + +bool XFillBitmapItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 ) +{ + const GraphicObject& aGraphicObjectA(static_cast(p1)->GetGraphicObject()); + const GraphicObject& aGraphicObjectB(static_cast(p2)->GetGraphicObject()); + + return aGraphicObjectA == aGraphicObjectB; +} + +std::unique_ptr XFillBitmapItem::checkForUniqueItem( SdrModel* pModel ) const +{ + if( pModel ) + { + XPropertyListType aListType = XPropertyListType::Bitmap; + if(isPattern()) + aListType = XPropertyListType::Pattern; + const OUString aUniqueName = NameOrIndex::CheckNamedItem( + this, XATTR_FILLBITMAP, &pModel->GetItemPool(), + XFillBitmapItem::CompareValueFunc, RID_SVXSTR_BMP21, + pModel->GetPropertyList( aListType ) ); + + // if the given name is not valid, replace it! + if( aUniqueName != GetName() ) + { + return std::make_unique(aUniqueName, maGraphicObject); + } + } + + return nullptr; +} + +void XFillBitmapItem::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillBitmapItem")); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr())); + + NameOrIndex::dumpAsXml(pWriter); + + (void)xmlTextWriterEndElement(pWriter); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/xoutdev/xpool.cxx b/svx/source/xoutdev/xpool.cxx new file mode 100644 index 000000000..b3e044e83 --- /dev/null +++ b/svx/source/xoutdev/xpool.cxx @@ -0,0 +1,219 @@ +/* -*- 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 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +XOutdevItemPool::XOutdevItemPool(SfxItemPool* _pMaster) + : SfxItemPool("XOutdevItemPool", SDRATTR_START, SDRATTR_END, nullptr, nullptr) + , mpLocalPoolDefaults(new std::vector(SDRATTR_END - SDRATTR_START + 1)) + , mpLocalItemInfos(new SfxItemInfo[SDRATTR_END - SDRATTR_START + 1]) +{ + // prepare some defaults + const OUString aNullStr; + const Graphic aNullGraphic; + const basegfx::B2DPolyPolygon aNullPol; + const Color aNullLineCol(COL_DEFAULT_SHAPE_STROKE); // #i121448# Use defined default color + const Color aNullFillCol(COL_DEFAULT_SHAPE_FILLING); // #i121448# Use defined default color + const Color aNullShadowCol(COL_LIGHTGRAY); + const XDash aNullDash; + const XHatch aNullHatch(aNullLineCol); + + // get master pointer, evtl. add myself to the end of the pools + if(!_pMaster) + { + _pMaster = this; + } + else + { + _pMaster->GetLastPoolInChain()->SetSecondaryPool(this); + } + + // prepare PoolDefaults + std::vector& rPoolDefaults = *mpLocalPoolDefaults; + rPoolDefaults[XATTR_LINESTYLE -XATTR_START] = new XLineStyleItem; + rPoolDefaults[XATTR_LINEDASH -XATTR_START] = new XLineDashItem(aNullDash); + rPoolDefaults[XATTR_LINEWIDTH -XATTR_START] = new XLineWidthItem; + rPoolDefaults[XATTR_LINECOLOR -XATTR_START] = new XLineColorItem(aNullStr,aNullLineCol); + rPoolDefaults[XATTR_LINESTART -XATTR_START] = new XLineStartItem(aNullPol); + rPoolDefaults[XATTR_LINEEND -XATTR_START] = new XLineEndItem (aNullPol); + rPoolDefaults[XATTR_LINESTARTWIDTH -XATTR_START] = new XLineStartWidthItem; + rPoolDefaults[XATTR_LINEENDWIDTH -XATTR_START] = new XLineEndWidthItem; + rPoolDefaults[XATTR_LINESTARTCENTER -XATTR_START] = new XLineStartCenterItem; + rPoolDefaults[XATTR_LINEENDCENTER -XATTR_START] = new XLineEndCenterItem; + rPoolDefaults[XATTR_LINETRANSPARENCE -XATTR_START] = new XLineTransparenceItem; + rPoolDefaults[XATTR_LINEJOINT -XATTR_START] = new XLineJointItem; + rPoolDefaults[XATTR_LINECAP -XATTR_START] = new XLineCapItem; + rPoolDefaults[XATTR_FILLSTYLE -XATTR_START] = new XFillStyleItem; + rPoolDefaults[XATTR_FILLCOLOR -XATTR_START] = new XFillColorItem (aNullStr,aNullFillCol); + rPoolDefaults[XATTR_FILLGRADIENT -XATTR_START] = new XFillGradientItem(XGradient(COL_BLACK, COL_WHITE)); + rPoolDefaults[XATTR_FILLHATCH -XATTR_START] = new XFillHatchItem (aNullHatch); + rPoolDefaults[XATTR_FILLBITMAP -XATTR_START] = new XFillBitmapItem (aNullGraphic); + rPoolDefaults[XATTR_FILLTRANSPARENCE -XATTR_START] = new XFillTransparenceItem; + rPoolDefaults[XATTR_GRADIENTSTEPCOUNT -XATTR_START] = new XGradientStepCountItem; + rPoolDefaults[XATTR_FILLBMP_TILE -XATTR_START] = new XFillBmpTileItem; + rPoolDefaults[XATTR_FILLBMP_POS -XATTR_START] = new XFillBmpPosItem; + rPoolDefaults[XATTR_FILLBMP_SIZEX -XATTR_START] = new XFillBmpSizeXItem; + rPoolDefaults[XATTR_FILLBMP_SIZEY -XATTR_START] = new XFillBmpSizeYItem; + rPoolDefaults[XATTR_FILLBMP_SIZELOG -XATTR_START] = new XFillBmpSizeLogItem; + rPoolDefaults[XATTR_FILLBMP_TILEOFFSETX -XATTR_START] = new XFillBmpTileOffsetXItem; + rPoolDefaults[XATTR_FILLBMP_TILEOFFSETY -XATTR_START] = new XFillBmpTileOffsetYItem; + rPoolDefaults[XATTR_FILLBMP_STRETCH -XATTR_START] = new XFillBmpStretchItem; + rPoolDefaults[XATTR_FILLBMP_POSOFFSETX -XATTR_START] = new XFillBmpPosOffsetXItem; + rPoolDefaults[XATTR_FILLBMP_POSOFFSETY -XATTR_START] = new XFillBmpPosOffsetYItem; + rPoolDefaults[XATTR_FILLFLOATTRANSPARENCE -XATTR_START] = new XFillFloatTransparenceItem( XGradient(COL_BLACK, COL_BLACK), false ); + rPoolDefaults[XATTR_SECONDARYFILLCOLOR -XATTR_START] = new XSecondaryFillColorItem(aNullStr, aNullFillCol); + rPoolDefaults[XATTR_FILLBACKGROUND -XATTR_START] = new XFillBackgroundItem; + rPoolDefaults[XATTR_FILLUSESLIDEBACKGROUND -XATTR_START] = new XFillUseSlideBackgroundItem; + rPoolDefaults[XATTR_FORMTXTSTYLE -XATTR_START] = new XFormTextStyleItem; + rPoolDefaults[XATTR_FORMTXTADJUST -XATTR_START] = new XFormTextAdjustItem; + rPoolDefaults[XATTR_FORMTXTDISTANCE -XATTR_START] = new XFormTextDistanceItem; + rPoolDefaults[XATTR_FORMTXTSTART -XATTR_START] = new XFormTextStartItem; + rPoolDefaults[XATTR_FORMTXTMIRROR -XATTR_START] = new XFormTextMirrorItem; + rPoolDefaults[XATTR_FORMTXTOUTLINE -XATTR_START] = new XFormTextOutlineItem; + rPoolDefaults[XATTR_FORMTXTSHADOW -XATTR_START] = new XFormTextShadowItem; + rPoolDefaults[XATTR_FORMTXTSHDWCOLOR -XATTR_START] = new XFormTextShadowColorItem(aNullStr,aNullShadowCol); + rPoolDefaults[XATTR_FORMTXTSHDWXVAL -XATTR_START] = new XFormTextShadowXValItem; + rPoolDefaults[XATTR_FORMTXTSHDWYVAL -XATTR_START] = new XFormTextShadowYValItem; + rPoolDefaults[XATTR_FORMTXTHIDEFORM -XATTR_START] = new XFormTextHideFormItem; + rPoolDefaults[XATTR_FORMTXTSHDWTRANSP -XATTR_START] = new XFormTextShadowTranspItem; + + // create SetItems + rPoolDefaults[XATTRSET_LINE - XATTR_START] = new XLineAttrSetItem( + SfxItemSetFixed( *_pMaster ) ); + rPoolDefaults[XATTRSET_FILL - XATTR_START] = new XFillAttrSetItem( + SfxItemSetFixed( *_pMaster ) ); + + // create ItemInfos + for(sal_uInt16 i(GetFirstWhich()); i <= GetLastWhich(); i++) + { + mpLocalItemInfos[i - XATTR_START]._nSID = 0; + mpLocalItemInfos[i - XATTR_START]._bPoolable = true; + } + + mpLocalItemInfos[XATTR_LINESTYLE -XATTR_START]._nSID = SID_ATTR_LINE_STYLE; + mpLocalItemInfos[XATTR_LINEDASH -XATTR_START]._nSID = SID_ATTR_LINE_DASH; + mpLocalItemInfos[XATTR_LINEWIDTH -XATTR_START]._nSID = SID_ATTR_LINE_WIDTH; + mpLocalItemInfos[XATTR_LINECOLOR -XATTR_START]._nSID = SID_ATTR_LINE_COLOR; + mpLocalItemInfos[XATTR_LINESTART -XATTR_START]._nSID = SID_ATTR_LINE_START; + mpLocalItemInfos[XATTR_LINEEND -XATTR_START]._nSID = SID_ATTR_LINE_END; + mpLocalItemInfos[XATTR_LINESTARTWIDTH -XATTR_START]._nSID = SID_ATTR_LINE_STARTWIDTH; + mpLocalItemInfos[XATTR_LINEENDWIDTH -XATTR_START]._nSID = SID_ATTR_LINE_ENDWIDTH; + mpLocalItemInfos[XATTR_LINESTARTCENTER -XATTR_START]._nSID = SID_ATTR_LINE_STARTCENTER; + mpLocalItemInfos[XATTR_LINEENDCENTER -XATTR_START]._nSID = SID_ATTR_LINE_ENDCENTER; + mpLocalItemInfos[XATTR_FILLSTYLE -XATTR_START]._nSID = SID_ATTR_FILL_STYLE; + mpLocalItemInfos[XATTR_FILLCOLOR -XATTR_START]._nSID = SID_ATTR_FILL_COLOR; + mpLocalItemInfos[XATTR_FILLGRADIENT -XATTR_START]._nSID = SID_ATTR_FILL_GRADIENT; + mpLocalItemInfos[XATTR_FILLHATCH -XATTR_START]._nSID = SID_ATTR_FILL_HATCH; + mpLocalItemInfos[XATTR_FILLBITMAP -XATTR_START]._nSID = SID_ATTR_FILL_BITMAP; + mpLocalItemInfos[XATTR_FORMTXTSTYLE -XATTR_START]._nSID = SID_FORMTEXT_STYLE; + mpLocalItemInfos[XATTR_FORMTXTADJUST -XATTR_START]._nSID = SID_FORMTEXT_ADJUST; + mpLocalItemInfos[XATTR_FORMTXTDISTANCE -XATTR_START]._nSID = SID_FORMTEXT_DISTANCE; + mpLocalItemInfos[XATTR_FORMTXTSTART -XATTR_START]._nSID = SID_FORMTEXT_START; + mpLocalItemInfos[XATTR_FORMTXTMIRROR -XATTR_START]._nSID = SID_FORMTEXT_MIRROR; + mpLocalItemInfos[XATTR_FORMTXTOUTLINE -XATTR_START]._nSID = SID_FORMTEXT_OUTLINE; + mpLocalItemInfos[XATTR_FORMTXTSHADOW -XATTR_START]._nSID = SID_FORMTEXT_SHADOW; + mpLocalItemInfos[XATTR_FORMTXTSHDWCOLOR -XATTR_START]._nSID = SID_FORMTEXT_SHDWCOLOR; + mpLocalItemInfos[XATTR_FORMTXTSHDWXVAL -XATTR_START]._nSID = SID_FORMTEXT_SHDWXVAL; + mpLocalItemInfos[XATTR_FORMTXTSHDWYVAL -XATTR_START]._nSID = SID_FORMTEXT_SHDWYVAL; + mpLocalItemInfos[XATTR_FORMTXTHIDEFORM -XATTR_START]._nSID = SID_FORMTEXT_HIDEFORM; + + // associate new slots for panels with known items + mpLocalItemInfos[XATTR_FILLUSESLIDEBACKGROUND - XATTR_START]._nSID = SID_ATTR_FILL_USE_SLIDE_BACKGROUND; + mpLocalItemInfos[XATTR_FILLTRANSPARENCE - XATTR_START]._nSID = SID_ATTR_FILL_TRANSPARENCE; + mpLocalItemInfos[XATTR_FILLFLOATTRANSPARENCE - XATTR_START]._nSID = SID_ATTR_FILL_FLOATTRANSPARENCE; + mpLocalItemInfos[XATTR_LINETRANSPARENCE - XATTR_START]._nSID = SID_ATTR_LINE_TRANSPARENCE; + mpLocalItemInfos[XATTR_LINEJOINT - XATTR_START]._nSID = SID_ATTR_LINE_JOINT; + mpLocalItemInfos[XATTR_LINECAP - XATTR_START]._nSID = SID_ATTR_LINE_CAP; + + // if it's my own creation level, set Defaults and ItemInfos + if(XATTR_START == GetFirstWhich() && XATTR_END == GetLastWhich()) + { + SetDefaults(mpLocalPoolDefaults); + SetItemInfos(mpLocalItemInfos.get()); + } +} + +// copy ctor, clones all static defaults +XOutdevItemPool::XOutdevItemPool(const XOutdevItemPool& rPool) +: SfxItemPool(rPool, true), + mpLocalPoolDefaults(nullptr) +{ +} + +rtl::Reference XOutdevItemPool::Clone() const +{ + return new XOutdevItemPool(*this); +} + +XOutdevItemPool::~XOutdevItemPool() +{ + Delete(); + // release and delete static pool default items + ReleaseDefaults(true); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/xoutdev/xtabbtmp.cxx b/svx/source/xoutdev/xtabbtmp.cxx new file mode 100644 index 000000000..178ba8ab2 --- /dev/null +++ b/svx/source/xoutdev/xtabbtmp.cxx @@ -0,0 +1,114 @@ +/* -*- 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 + +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +XBitmapEntry* XBitmapList::GetBitmap(tools::Long nIndex) const +{ + return static_cast( XPropertyList::Get(nIndex) ); +} + +uno::Reference< container::XNameContainer > XBitmapList::createInstance() +{ + return SvxUnoXBitmapTable_createInstance( *this ); +} + +bool XBitmapList::Create() +{ + return true; +} + +BitmapEx XBitmapList::CreateBitmap( tools::Long nIndex, const Size& rSize ) const +{ + OSL_ENSURE( nIndex < Count(), "Access out of range" ); + + if(nIndex < Count()) + { + BitmapEx rBitmapEx = GetBitmap( nIndex )->GetGraphicObject().GetGraphic().GetBitmapEx(); + ScopedVclPtrInstance< VirtualDevice > pVirtualDevice; + pVirtualDevice->SetOutputSizePixel(rSize); + + if(rBitmapEx.IsAlpha()) + { + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + + if(rStyleSettings.GetPreviewUsesCheckeredBackground()) + { + const Point aNull(0, 0); + static const sal_uInt32 nLen(8); + static const Color aW(COL_WHITE); + static const Color aG(0xef, 0xef, 0xef); + + pVirtualDevice->DrawCheckered(aNull, rSize, nLen, aW, aG); + } + else + { + pVirtualDevice->SetBackground(rStyleSettings.GetFieldColor()); + pVirtualDevice->Erase(); + } + } + + if(rBitmapEx.GetSizePixel().Width() >= rSize.Width() && rBitmapEx.GetSizePixel().Height() >= rSize.Height()) + { + rBitmapEx.Scale(rSize); + pVirtualDevice->DrawBitmapEx(Point(0, 0), rBitmapEx); + } + else + { + const Size aBitmapSize(rBitmapEx.GetSizePixel()); + + for(tools::Long y(0); y < rSize.Height(); y += aBitmapSize.Height()) + { + for(tools::Long x(0); x < rSize.Width(); x += aBitmapSize.Width()) + { + pVirtualDevice->DrawBitmapEx( + Point(x, y), + rBitmapEx); + } + } + } + rBitmapEx = pVirtualDevice->GetBitmapEx(Point(0, 0), rSize); + return rBitmapEx; + } + else + return BitmapEx(); +} + +BitmapEx XBitmapList::CreateBitmapForUI( tools::Long nIndex ) +{ + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + const Size& rSize = rStyleSettings.GetListBoxPreviewDefaultPixelSize(); + return CreateBitmap(nIndex, rSize); +} + +BitmapEx XBitmapList::GetBitmapForPreview( tools::Long nIndex, const Size& rSize ) +{ + return CreateBitmap(nIndex, rSize); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/xoutdev/xtabcolr.cxx b/svx/source/xoutdev/xtabcolr.cxx new file mode 100644 index 000000000..e952d6f8a --- /dev/null +++ b/svx/source/xoutdev/xtabcolr.cxx @@ -0,0 +1,172 @@ +/* -*- 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 +#include +#include +#include + +#include +#include +#include + +using namespace com::sun::star; + +XColorListRef XColorList::CreateStdColorList() +{ + return XPropertyList::AsColorList( + XPropertyList::CreatePropertyList( + XPropertyListType::Color, !utl::ConfigManager::IsFuzzing() ? + SvtPathOptions().GetPalettePath() : + "", "")); +} + +XColorListRef XColorList::GetStdColorList() +{ + XColorListRef aTable( CreateStdColorList() ); + return aTable; +} + +void XColorList::Replace(tools::Long nIndex, std::unique_ptr pEntry) +{ + XPropertyList::Replace(std::move(pEntry), nIndex); +} +XColorEntry* XColorList::GetColor(tools::Long nIndex) const +{ + return static_cast( XPropertyList::Get(nIndex) ); +} + +uno::Reference< container::XNameContainer > XColorList::createInstance() +{ + return SvxUnoXColorTable_createInstance( *this ); +} + +bool XColorList::Create() +{ + sal_uInt32 a(0); + sal_uInt32 b(0); + + // + const OUString aStrGrey( SvxResId( RID_SVXSTR_COLOR_GREY ) ); + + Insert( std::make_unique( Color( 0xff, 0xff, 0xff ), SvxResId( RID_SVXSTR_COLOR_WHITE ) ) ); + Insert( std::make_unique( Color( 0xee, 0xee, 0xee ), aStrGrey + " 1" ) ); + Insert( std::make_unique( Color( 0xdd, 0xdd, 0xdd ), aStrGrey + " 2" ) ); + Insert( std::make_unique( Color( 0xcc, 0xcc, 0xcc ), aStrGrey + " 3" ) ); + Insert( std::make_unique( Color( 0xb2, 0xb2, 0xb2 ), aStrGrey + " 4" ) ); + Insert( std::make_unique( Color( 0x99, 0x99, 0x99 ), aStrGrey + " 5" ) ); + Insert( std::make_unique( Color( 0x80, 0x80, 0x80 ), aStrGrey + " 6" ) ); + Insert( std::make_unique( Color( 0x66, 0x66, 0x66 ), aStrGrey + " 7" ) ); + Insert( std::make_unique( Color( 0x33, 0x33, 0x33 ), aStrGrey + " 8" ) ); + Insert( std::make_unique( Color( 0x1c, 0x1c, 0x1c ), aStrGrey + " 9" ) ); + Insert( std::make_unique( Color( 0x11, 0x11, 0x11 ), aStrGrey + " 10") ); + Insert( std::make_unique( Color( 0x00, 0x00, 0x00 ), SvxResId( RID_SVXSTR_COLOR_BLACK ) ) ); + + // + const sal_uInt32 nNumColorsInGroup(12); + const sal_uInt32 nNumGroups(11); + const OUString aStrCol[nNumColorsInGroup] = { + SvxResId(RID_SVXSTR_COLOR_YELLOW), + SvxResId(RID_SVXSTR_COLOR_ORANGE), + SvxResId(RID_SVXSTR_COLOR_RED), + SvxResId(RID_SVXSTR_COLOR_PINK), + SvxResId(RID_SVXSTR_COLOR_MAGENTA), + SvxResId(RID_SVXSTR_COLOR_PURPLE), + SvxResId(RID_SVXSTR_COLOR_BLUE), + SvxResId(RID_SVXSTR_COLOR_SKYBLUE), + SvxResId(RID_SVXSTR_COLOR_CYAN), + SvxResId(RID_SVXSTR_COLOR_TURQUOISE), + SvxResId(RID_SVXSTR_COLOR_GREEN), + SvxResId(RID_SVXSTR_COLOR_YELLOWGREEN) }; + static const sal_uInt32 aStdCol[nNumColorsInGroup * nNumGroups] = { + 0xffff99, 0xff6600, 0xff3333, 0xff00cc, 0xff33ff, 0x9900ff, 0x6666ff, 0x00ccff, 0x66ffff, 0x33ff99, 0x99ff66, 0xccff00, + 0xffff66, 0xffcc00, 0xff9999, 0xff66cc, 0xff99ff, 0xcc66ff, 0x9999ff, 0x9999ff, 0x99ffff, 0x66ff99, 0x99ff99, 0xccff66, + 0xffff00, 0xff9900, 0xff6666, 0xff3399, 0xff66ff, 0x9933ff, 0x3333ff, 0x3399ff, 0x00ffff, 0x00ff66, 0x66ff66, 0x99ff33, + 0xcc9900, 0xff3300, 0xff0000, 0xff0066, 0xff00ff, 0x6600ff, 0x0000ff, 0x0066ff, 0x00cccc, 0x00cc33, 0x00cc00, 0x66ff00, + 0x996600, 0xcc3300, 0xcc0000, 0xcc0066, 0xcc00cc, 0x6600cc, 0x0000cc, 0x0066cc, 0x009999, 0x009933, 0x009900, 0x66cc00, + 0x663300, 0x801900, 0x990000, 0x990066, 0x990099, 0x330099, 0x000099, 0x006699, 0x006666, 0x007826, 0x006600, 0x669900, + 0x333300, 0x461900, 0x330000, 0x330033, 0x660066, 0x000033, 0x000066, 0x000080, 0x003333, 0x00331a, 0x003300, 0x193300, + 0x666633, 0x661900, 0x663333, 0x660033, 0x663366, 0x330066, 0x333366, 0x003366, 0x336666, 0x006633, 0x336633, 0x336600, + 0x999966, 0x996633, 0x996666, 0x993366, 0x996699, 0x663399, 0x666699, 0x336699, 0x669999, 0x339966, 0x669966, 0x669933, + 0xcccc99, 0xcc9966, 0xcc9999, 0xcc6699, 0xcc99cc, 0x9966cc, 0x9999cc, 0x6699cc, 0x99cccc, 0x66cc99, 0x99cc99, 0x99cc66, + 0xffffcc, 0xffcc99, 0xffcccc, 0xff99cc, 0xffccff, 0xcc99ff, 0xccccff, 0x99ccff, 0xccffff, 0x99ffcc, 0xccffcc, 0xccff99 }; + + for(a = 0; a < nNumGroups; a++) + { + OUString aSuffix; + if (a > 0) aSuffix = OUString::number(a); + + const sal_uInt32 nOffset(a * nNumColorsInGroup); + + for(b = 0; b < nNumColorsInGroup; b++) + { + Insert( std::make_unique( Color(ColorTransparency, aStdCol[nOffset + b]), aStrCol[b] + aSuffix ) ); + } + } + + // + Insert( std::make_unique( Color( 0xe6, 0xe6, 0xff ), SvxResId( RID_SVXSTR_COLOR_BLUEGREY) ) ); + Insert( std::make_unique( Color( 0xCF, 0xE7, 0xF5 ), SvxResId( RID_SVXSTR_COLOR_BLUE_CLASSIC ) ) ); + + // + Insert( std::make_unique( Color( 0x99, 0x99, 0xff ), SvxResId( RID_SVXSTR_COLOR_VIOLET ) ) ); + Insert( std::make_unique( Color( 0x99, 0x33, 0x66 ), SvxResId( RID_SVXSTR_COLOR_BORDEAUX ) ) ); + Insert( std::make_unique( Color( 0xff, 0xff, 0xcc ), SvxResId( RID_SVXSTR_COLOR_PALE_YELLOW ) ) ); + Insert( std::make_unique( Color( 0xcc, 0xff, 0xff ), SvxResId( RID_SVXSTR_COLOR_PALE_GREEN ) ) ); + Insert( std::make_unique( Color( 0x66, 0x00, 0x66 ), SvxResId( RID_SVXSTR_COLOR_DARKVIOLET ) ) ); + Insert( std::make_unique( Color( 0xff, 0x80, 0x80 ), SvxResId( RID_SVXSTR_COLOR_SALMON ) ) ); + Insert( std::make_unique( Color( 0x00, 0x66, 0xcc ), SvxResId( RID_SVXSTR_COLOR_SEABLUE ) ) ); + + // + const OUString aStrChart( SvxResId( RID_SVXSTR_COLOR_CHART ) ); + Insert( std::make_unique( Color( 0x00, 0x45, 0x86 ), aStrChart + " 1" ) ); + Insert( std::make_unique( Color( 0xff, 0x42, 0x0e ), aStrChart + " 2" ) ); + Insert( std::make_unique( Color( 0xff, 0xd3, 0x20 ), aStrChart + " 3" ) ); + Insert( std::make_unique( Color( 0x57, 0x9d, 0x1c ), aStrChart + " 4" ) ); + Insert( std::make_unique( Color( 0x7e, 0x00, 0x21 ), aStrChart + " 5" ) ); + Insert( std::make_unique( Color( 0x83, 0xca, 0xff ), aStrChart + " 6" ) ); + Insert( std::make_unique( Color( 0x31, 0x40, 0x04 ), aStrChart + " 7" ) ); + Insert( std::make_unique( Color( 0xae, 0xcf, 0x00 ), aStrChart + " 8" ) ); + Insert( std::make_unique( Color( 0x4b, 0x1f, 0x6f ), aStrChart + " 9" ) ); + Insert( std::make_unique( Color( 0xff, 0x95, 0x0e ), aStrChart + " 10" ) ); + Insert( std::make_unique( Color( 0xc5, 0x00, 0x0b ), aStrChart + " 11" ) ); + Insert( std::make_unique( Color( 0x00, 0x84, 0xd1 ), aStrChart + " 12" ) ); + + return(165 == Count()); +} + +BitmapEx XColorList::CreateBitmapForUI( tools::Long /*nIndex*/ ) +{ + return BitmapEx(); +} + +tools::Long XColorList::GetIndexOfColor( const Color& rColor ) const +{ + for( tools::Long i = 0, n = maList.size(); i < n; ++i ) + { + const Color aColor = static_cast( maList[i].get() )->GetColor(); + + if (aColor == rColor ) + return i; + } + + return -1; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/xoutdev/xtabdash.cxx b/svx/source/xoutdev/xtabdash.cxx new file mode 100644 index 000000000..da5ec20a3 --- /dev/null +++ b/svx/source/xoutdev/xtabdash.cxx @@ -0,0 +1,220 @@ +/* -*- 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 + +#include +#include + +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +XDashList::XDashList(const OUString& rPath, const OUString& rReferer) + : XPropertyList(XPropertyListType::Dash, rPath, rReferer) +{ +} + +XDashList::~XDashList() +{ +} + +void XDashList::Replace(std::unique_ptr pEntry, tools::Long nIndex) +{ + XPropertyList::Replace(std::move(pEntry), nIndex); +} + +XDashEntry* XDashList::GetDash(tools::Long nIndex) const +{ + return static_cast( XPropertyList::Get(nIndex) ); +} + +uno::Reference< container::XNameContainer > XDashList::createInstance() +{ + return SvxUnoXDashTable_createInstance( *this ); +} + +bool XDashList::Create() +{ + const OUString aStr(SvxResId(RID_SVXSTR_LINESTYLE)); + + Insert(std::make_unique(XDash(css::drawing::DashStyle_RECT,1, 50,1, 50, 50),aStr + " 1")); + Insert(std::make_unique(XDash(css::drawing::DashStyle_RECT,1,500,1,500,500),aStr + " 2")); + Insert(std::make_unique(XDash(css::drawing::DashStyle_RECT,2, 50,3,250,120),aStr + " 3")); + + return true; +} + +BitmapEx XDashList::ImpCreateBitmapForXDash(const XDash* pDash) +{ + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + const Size& rSize = rStyleSettings.GetListBoxPreviewDefaultPixelSize(); + const sal_uInt32 nFactor(2); + const Size aSize((rSize.Width() * 5 * 2) / 2, rSize.Height() * nFactor); + + // prepare polygon geometry for line + basegfx::B2DPolygon aLine; + + aLine.append(basegfx::B2DPoint(0.0, aSize.Height() / 2.0)); + aLine.append(basegfx::B2DPoint(aSize.Width(), aSize.Height() / 2.0)); + + // prepare LineAttribute + const basegfx::BColor aLineColor(rStyleSettings.GetFieldTextColor().getBColor()); + const double fLineWidth(StyleSettings::GetListBoxPreviewDefaultLineWidth() * (nFactor * 1.1)); + const drawinglayer::attribute::LineAttribute aLineAttribute( + aLineColor, + fLineWidth); + + // prepare StrokeAttribute + ::std::vector< double > aDotDashArray; + double fFullDotDashLen(0.0); + + if(pDash && (pDash->GetDots() || pDash->GetDashes())) + { + const basegfx::B2DHomMatrix aScaleMatrix(OutputDevice::LogicToLogic(MapMode(MapUnit::Map100thMM), MapMode(MapUnit::MapPixel))); + const basegfx::B2DVector aScaleVector(aScaleMatrix * basegfx::B2DVector(1.0, 0.0)); + const double fScaleValue(aScaleVector.getLength() * (nFactor * (1.4 / 2.0))); + const double fLineWidthInUnits(fLineWidth / fScaleValue); + + fFullDotDashLen = pDash->CreateDotDashArray(aDotDashArray, fLineWidthInUnits); + + if(!aDotDashArray.empty()) + { + for(double & a : aDotDashArray) + { + a *= fScaleValue; + // ~zero length dash is a dot-like dot (with line width size round cap), so show it + if (a < 0.1) + a += 1.0; + } + + fFullDotDashLen *= fScaleValue; + } + } + + const drawinglayer::attribute::StrokeAttribute aStrokeAttribute( + std::move(aDotDashArray), + fFullDotDashLen); + + // create LinePrimitive + const drawinglayer::primitive2d::Primitive2DReference aLinePrimitive( + new drawinglayer::primitive2d::PolygonStrokePrimitive2D( + aLine, + aLineAttribute, + aStrokeAttribute)); + + // prepare VirtualDevice + ScopedVclPtrInstance< VirtualDevice > pVirtualDevice; + const drawinglayer::geometry::ViewInformation2D aNewViewInformation2D; + + pVirtualDevice->SetOutputSizePixel(aSize); + pVirtualDevice->SetDrawMode(rStyleSettings.GetHighContrastMode() + ? DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill | DrawModeFlags::SettingsText | DrawModeFlags::SettingsGradient + : DrawModeFlags::Default); + + if(rStyleSettings.GetPreviewUsesCheckeredBackground()) + { + const Point aNull(0, 0); + static const sal_uInt32 nLen(8 * nFactor); + static const Color aW(COL_WHITE); + static const Color aG(0xef, 0xef, 0xef); + + pVirtualDevice->DrawCheckered(aNull, aSize, nLen, aW, aG); + } + else + { + pVirtualDevice->SetBackground(rStyleSettings.GetFieldColor()); + pVirtualDevice->Erase(); + } + + // create processor and draw primitives + std::unique_ptr pProcessor2D(drawinglayer::processor2d::createPixelProcessor2DFromOutputDevice( + *pVirtualDevice, + aNewViewInformation2D)); + + const drawinglayer::primitive2d::Primitive2DContainer aSequence { aLinePrimitive }; + + pProcessor2D->process(aSequence); + pProcessor2D.reset(); + + // get result bitmap and scale + BitmapEx aRetval(pVirtualDevice->GetBitmapEx(Point(0, 0), pVirtualDevice->GetOutputSizePixel())); + + if(1 != nFactor) + { + aRetval.Scale(Size((rSize.Width() * 5) / 2, rSize.Height())); + } + + return aRetval; +} + +BitmapEx XDashList::CreateBitmapForUI( tools::Long nIndex ) +{ + const XDash& rDash = GetDash(nIndex)->GetDash(); + + return ImpCreateBitmapForXDash(&rDash); +} + +BitmapEx const & XDashList::GetBitmapForUISolidLine() const +{ + if(maBitmapSolidLine.IsEmpty()) + { + const_cast< XDashList* >(this)->maBitmapSolidLine = XDashList::ImpCreateBitmapForXDash(nullptr); + } + + return maBitmapSolidLine; +} + +OUString const & XDashList::GetStringForUiSolidLine() const +{ + if(maStringSolidLine.isEmpty()) + { + const_cast< XDashList* >(this)->maStringSolidLine = SvxResId(RID_SVXSTR_SOLID); + } + + return maStringSolidLine; +} + +OUString const & XDashList::GetStringForUiNoLine() const +{ + if(maStringNoLine.isEmpty()) + { + // formerly was RID_SVXSTR_INVISIBLE, but to make equal + // everywhere, use RID_SVXSTR_NONE + const_cast< XDashList* >(this)->maStringNoLine = comphelper::LibreOfficeKit::isActive() ? SvxResId(RID_SVXSTR_INVISIBLE) : + SvxResId(RID_SVXSTR_NONE); + } + + return maStringNoLine; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/xoutdev/xtabgrdt.cxx b/svx/source/xoutdev/xtabgrdt.cxx new file mode 100644 index 000000000..3d2acb574 --- /dev/null +++ b/svx/source/xoutdev/xtabgrdt.cxx @@ -0,0 +1,216 @@ +/* -*- 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 + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +XGradientList::XGradientList( const OUString& rPath, const OUString& rReferer ) +: XPropertyList( XPropertyListType::Gradient, rPath, rReferer ) +{ +} + +XGradientList::~XGradientList() +{ +} + +void XGradientList::Replace(std::unique_ptr pEntry, tools::Long nIndex) +{ + XPropertyList::Replace(std::move(pEntry), nIndex); +} + +XGradientEntry* XGradientList::GetGradient(tools::Long nIndex) const +{ + return static_cast( XPropertyList::Get( nIndex ) ); +} + +uno::Reference< container::XNameContainer > XGradientList::createInstance() +{ + return SvxUnoXGradientTable_createInstance( *this ); +} + +bool XGradientList::Create() +{ + OUStringBuffer aStr(SvxResId(RID_SVXSTR_GRADIENT)); + aStr.append(" 1"); + sal_Int32 nLen = aStr.getLength() - 1; + Insert(std::make_unique(XGradient(COL_BLACK, COL_WHITE, css::awt::GradientStyle_LINEAR , 0_deg10,10,10, 0,100,100),aStr.toString())); + aStr[nLen] = '2'; + Insert(std::make_unique(XGradient(COL_BLUE, COL_RED, css::awt::GradientStyle_AXIAL , 300_deg10,20,20,10,100,100),aStr.toString())); + aStr[nLen] = '3'; + Insert(std::make_unique(XGradient(COL_RED, COL_YELLOW,css::awt::GradientStyle_RADIAL , 600_deg10,30,30,20,100,100),aStr.toString())); + aStr[nLen] = '4'; + Insert(std::make_unique(XGradient(COL_YELLOW , COL_GREEN, css::awt::GradientStyle_ELLIPTICAL, 900_deg10,40,40,30,100,100),aStr.toString())); + aStr[nLen] = '5'; + Insert(std::make_unique(XGradient(COL_GREEN , COL_MAGENTA,css::awt::GradientStyle_SQUARE , 1200_deg10,50,50,40,100,100),aStr.toString())); + aStr[nLen] = '6'; + Insert(std::make_unique(XGradient(COL_MAGENTA, COL_YELLOW ,css::awt::GradientStyle_RECT , 1900_deg10,60,60,50,100,100),aStr.toString())); + + return true; +} + +BitmapEx XGradientList::CreateBitmap( tools::Long nIndex, const Size& rSize ) const +{ + BitmapEx aRetval; + + OSL_ENSURE(nIndex < Count(), "OOps, access out of range (!)"); + + if(nIndex < Count()) + { + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + // prepare polygon geometry for rectangle + const basegfx::B2DPolygon aRectangle( + basegfx::utils::createPolygonFromRect( + basegfx::B2DRange(0.0, 0.0, rSize.Width(), rSize.Height()))); + + const XGradient& rGradient = GetGradient(nIndex)->GetGradient(); + const sal_uInt16 nStartIntens(rGradient.GetStartIntens()); + basegfx::BColor aStart(rGradient.GetStartColor().getBColor()); + + if(nStartIntens != 100) + { + const basegfx::BColor aBlack; + aStart = interpolate(aBlack, aStart, static_cast(nStartIntens) * 0.01); + } + + const sal_uInt16 nEndIntens(rGradient.GetEndIntens()); + basegfx::BColor aEnd(rGradient.GetEndColor().getBColor()); + + if(nEndIntens != 100) + { + const basegfx::BColor aBlack; + aEnd = interpolate(aBlack, aEnd, static_cast(nEndIntens) * 0.01); + } + + drawinglayer::attribute::GradientStyle aGradientStyle(drawinglayer::attribute::GradientStyle::Rect); + + switch(rGradient.GetGradientStyle()) + { + case css::awt::GradientStyle_LINEAR : + { + aGradientStyle = drawinglayer::attribute::GradientStyle::Linear; + break; + } + case css::awt::GradientStyle_AXIAL : + { + aGradientStyle = drawinglayer::attribute::GradientStyle::Axial; + break; + } + case css::awt::GradientStyle_RADIAL : + { + aGradientStyle = drawinglayer::attribute::GradientStyle::Radial; + break; + } + case css::awt::GradientStyle_ELLIPTICAL : + { + aGradientStyle = drawinglayer::attribute::GradientStyle::Elliptical; + break; + } + case css::awt::GradientStyle_SQUARE : + { + aGradientStyle = drawinglayer::attribute::GradientStyle::Square; + break; + } + default : + { + aGradientStyle = drawinglayer::attribute::GradientStyle::Rect; // css::awt::GradientStyle_RECT + break; + } + } + + const drawinglayer::attribute::FillGradientAttribute aFillGradient( + aGradientStyle, + static_cast(rGradient.GetBorder()) * 0.01, + static_cast(rGradient.GetXOffset()) * 0.01, + static_cast(rGradient.GetYOffset()) * 0.01, + toRadians(rGradient.GetAngle()), + aStart, + aEnd); + + const drawinglayer::primitive2d::Primitive2DReference aGradientPrimitive( + new drawinglayer::primitive2d::PolyPolygonGradientPrimitive2D( + basegfx::B2DPolyPolygon(aRectangle), + aFillGradient)); + + const basegfx::BColor aBlack(0.0, 0.0, 0.0); + const drawinglayer::primitive2d::Primitive2DReference aBlackRectanglePrimitive( + new drawinglayer::primitive2d::PolygonHairlinePrimitive2D( + aRectangle, + aBlack)); + + // prepare VirtualDevice + ScopedVclPtrInstance< VirtualDevice > pVirtualDevice; + const drawinglayer::geometry::ViewInformation2D aNewViewInformation2D; + + pVirtualDevice->SetOutputSizePixel(rSize); + pVirtualDevice->SetDrawMode(rStyleSettings.GetHighContrastMode() + ? DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill | DrawModeFlags::SettingsText | DrawModeFlags::SettingsGradient + : DrawModeFlags::Default); + + // create processor and draw primitives + std::unique_ptr pProcessor2D(drawinglayer::processor2d::createPixelProcessor2DFromOutputDevice( + *pVirtualDevice, + aNewViewInformation2D)); + + drawinglayer::primitive2d::Primitive2DContainer aSequence(2); + + aSequence[0] = aGradientPrimitive; + aSequence[1] = aBlackRectanglePrimitive; + + pProcessor2D->process(aSequence); + pProcessor2D.reset(); + + // get result bitmap and scale + aRetval = pVirtualDevice->GetBitmapEx(Point(0, 0), pVirtualDevice->GetOutputSizePixel()); + } + + return aRetval; +} + +BitmapEx XGradientList::CreateBitmapForUI(tools::Long nIndex) +{ + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + const Size& rSize = rStyleSettings.GetListBoxPreviewDefaultPixelSize(); + return CreateBitmap(nIndex, rSize); +} + +BitmapEx XGradientList::GetBitmapForPreview(tools::Long nIndex, const Size& rSize) +{ + return CreateBitmap(nIndex, rSize); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/xoutdev/xtabhtch.cxx b/svx/source/xoutdev/xtabhtch.cxx new file mode 100644 index 000000000..4fc97727b --- /dev/null +++ b/svx/source/xoutdev/xtabhtch.cxx @@ -0,0 +1,195 @@ +/* -*- 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 +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; + +XHatchList::XHatchList(const OUString& rPath, const OUString& rReferer) + : XPropertyList( XPropertyListType::Hatch, rPath, rReferer ) +{ +} + +XHatchList::~XHatchList() +{ +} + +void XHatchList::Replace(std::unique_ptr pEntry, tools::Long nIndex) +{ + XPropertyList::Replace(std::move(pEntry), nIndex); +} + +XHatchEntry* XHatchList::GetHatch(tools::Long nIndex) const +{ + return static_cast( XPropertyList::Get(nIndex) ); +} + +uno::Reference< container::XNameContainer > XHatchList::createInstance() +{ + return SvxUnoXHatchTable_createInstance( *this ); +} + +bool XHatchList::Create() +{ + OUStringBuffer aStr(SvxResId(RID_SVXSTR_HATCH)); + aStr.append(" 1"); + + sal_Int32 nLen = aStr.getLength() - 1; + Insert(std::make_unique(XHatch(COL_BLACK,css::drawing::HatchStyle_SINGLE,100, 0_deg10),aStr.toString())); + aStr[nLen] = '2'; + Insert(std::make_unique(XHatch(COL_RED ,css::drawing::HatchStyle_DOUBLE, 80,450_deg10),aStr.toString())); + aStr[nLen] = '3'; + Insert(std::make_unique(XHatch(COL_BLUE ,css::drawing::HatchStyle_TRIPLE,120, 0_deg10),aStr.toString())); + + return true; +} + +BitmapEx XHatchList::CreateBitmap( tools::Long nIndex, const Size& rSize) const +{ + BitmapEx aRetval; + OSL_ENSURE(nIndex < Count(), "OOps, access out of range (!)"); + + if(nIndex < Count()) + { + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + + // prepare polygon geometry for rectangle + const basegfx::B2DPolygon aRectangle( + basegfx::utils::createPolygonFromRect( + basegfx::B2DRange(0.0, 0.0, rSize.Width(), rSize.Height()))); + + const XHatch& rHatch = GetHatch(nIndex)->GetHatch(); + drawinglayer::attribute::HatchStyle aHatchStyle(drawinglayer::attribute::HatchStyle::Triple); + + switch(rHatch.GetHatchStyle()) + { + case css::drawing::HatchStyle_SINGLE : + { + aHatchStyle = drawinglayer::attribute::HatchStyle::Single; + break; + } + case css::drawing::HatchStyle_DOUBLE : + { + aHatchStyle = drawinglayer::attribute::HatchStyle::Double; + break; + } + default : + { + aHatchStyle = drawinglayer::attribute::HatchStyle::Triple; // css::drawing::HatchStyle_TRIPLE + break; + } + } + + const basegfx::B2DHomMatrix aScaleMatrix(OutputDevice::LogicToLogic(MapMode(MapUnit::Map100thMM), MapMode(MapUnit::MapPixel))); + const basegfx::B2DVector aScaleVector(aScaleMatrix * basegfx::B2DVector(1.0, 0.0)); + const double fScaleValue(aScaleVector.getLength()); + + const drawinglayer::attribute::FillHatchAttribute aFillHatch( + aHatchStyle, + static_cast(rHatch.GetDistance()) * fScaleValue, + toRadians(rHatch.GetAngle()), + rHatch.GetColor().getBColor(), + 3, // same default as VCL, a minimum of three discrete units (pixels) offset + false); + + const basegfx::BColor aBlack(0.0, 0.0, 0.0); + const drawinglayer::primitive2d::Primitive2DReference aHatchPrimitive( + new drawinglayer::primitive2d::PolyPolygonHatchPrimitive2D( + basegfx::B2DPolyPolygon(aRectangle), + aBlack, + aFillHatch)); + + const drawinglayer::primitive2d::Primitive2DReference aBlackRectanglePrimitive( + new drawinglayer::primitive2d::PolygonHairlinePrimitive2D( + aRectangle, + aBlack)); + + // prepare VirtualDevice + ScopedVclPtrInstance< VirtualDevice > pVirtualDevice; + const drawinglayer::geometry::ViewInformation2D aNewViewInformation2D; + + pVirtualDevice->SetOutputSizePixel(rSize); + pVirtualDevice->SetDrawMode(rStyleSettings.GetHighContrastMode() + ? DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill | DrawModeFlags::SettingsText | DrawModeFlags::SettingsGradient + : DrawModeFlags::Default); + + if(rStyleSettings.GetPreviewUsesCheckeredBackground()) + { + const Point aNull(0, 0); + static const sal_uInt32 nLen(8); + static const Color aW(COL_WHITE); + static const Color aG(0xef, 0xef, 0xef); + pVirtualDevice->DrawCheckered(aNull, rSize, nLen, aW, aG); + } + else + { + pVirtualDevice->SetBackground(rStyleSettings.GetFieldColor()); + pVirtualDevice->Erase(); + } + + // create processor and draw primitives + std::unique_ptr pProcessor2D(drawinglayer::processor2d::createPixelProcessor2DFromOutputDevice( + *pVirtualDevice, + aNewViewInformation2D)); + + drawinglayer::primitive2d::Primitive2DContainer aSequence(2); + + aSequence[0] = aHatchPrimitive; + aSequence[1] = aBlackRectanglePrimitive; + pProcessor2D->process(aSequence); + pProcessor2D.reset(); + + // get result bitmap and scale + aRetval = pVirtualDevice->GetBitmapEx(Point(0, 0), pVirtualDevice->GetOutputSizePixel()); + } + + return aRetval; +} + +BitmapEx XHatchList::CreateBitmapForUI(tools::Long nIndex) +{ + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + const Size& rSize = rStyleSettings.GetListBoxPreviewDefaultPixelSize(); + BitmapEx aRetVal = CreateBitmap(nIndex, rSize); + return aRetVal; +} + +BitmapEx XHatchList::GetBitmapForPreview(tools::Long nIndex, const Size& rSize) +{ + return CreateBitmap(nIndex, rSize); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/xoutdev/xtable.cxx b/svx/source/xoutdev/xtable.cxx new file mode 100644 index 000000000..016dd261b --- /dev/null +++ b/svx/source/xoutdev/xtable.cxx @@ -0,0 +1,392 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +XColorEntry::XColorEntry(const Color& rColor, const OUString& rName) +: XPropertyEntry(rName), + aColor(rColor) +{ +} + +XLineEndEntry::XLineEndEntry(const basegfx::B2DPolyPolygon& rB2DPolyPolygon, const OUString& rName) +: XPropertyEntry(rName), + aB2DPolyPolygon(rB2DPolyPolygon) +{ +} + +XLineEndEntry::XLineEndEntry(const XLineEndEntry& rOther) +: XPropertyEntry(rOther), + aB2DPolyPolygon(rOther.aB2DPolyPolygon) +{ +} + +XDashEntry::XDashEntry(const XDash& rDash, const OUString& rName) +: XPropertyEntry(rName), + aDash(rDash) +{ +} + +XDashEntry::XDashEntry(const XDashEntry& rOther) +: XPropertyEntry(rOther), +aDash(rOther.aDash) +{ +} + +XHatchEntry::XHatchEntry(const XHatch& rHatch, const OUString& rName) +: XPropertyEntry(rName), + aHatch(rHatch) +{ +} + +XHatchEntry::XHatchEntry(const XHatchEntry& rOther) +: XPropertyEntry(rOther), + aHatch(rOther.aHatch) +{ +} + +XGradientEntry::XGradientEntry(const XGradient& rGradient, const OUString& rName) +: XPropertyEntry(rName), + aGradient(rGradient) +{ +} + +XGradientEntry::XGradientEntry(const XGradientEntry& rOther) +: XPropertyEntry(rOther), + aGradient(rOther.aGradient) +{ +} + +XBitmapEntry::XBitmapEntry(const GraphicObject& rGraphicObject, const OUString& rName) +: XPropertyEntry(rName), + maGraphicObject(rGraphicObject) +{ +} + +XBitmapEntry::XBitmapEntry(const XBitmapEntry& rOther) +: XPropertyEntry(rOther), + maGraphicObject(rOther.maGraphicObject) +{ +} + +XPropertyList::XPropertyList( + XPropertyListType type, + const OUString& rPath, const OUString& rReferer +) : meType ( type ), + maName ( "standard" ), + maPath ( rPath ), + maReferer ( rReferer ), + mbListDirty ( true ), + mbEmbedInDocument( false ) +{ +// fprintf (stderr, "Create type %d count %d\n", (int)meType, count++); +} + +bool XPropertyList::isValidIdx(tools::Long nIndex) const +{ + return (nIndex >= 0 && o3tl::make_unsigned(nIndex) < maList.size()); +} + + +XPropertyList::~XPropertyList() +{ +} + +tools::Long XPropertyList::Count() const +{ + if( mbListDirty ) + { + if( !const_cast(this)->Load() ) + const_cast(this)->Create(); + } + return maList.size(); +} + +XPropertyEntry* XPropertyList::Get( tools::Long nIndex ) const +{ + if( mbListDirty ) + { + if( !const_cast(this)->Load() ) + const_cast(this)->Create(); + } + if (!isValidIdx(nIndex)) + return nullptr; + + return maList[nIndex].get(); +} + +tools::Long XPropertyList::GetIndex(std::u16string_view rName) const +{ + if( mbListDirty ) + { + if( !const_cast(this)->Load() ) + const_cast(this)->Create(); + } + + for( tools::Long i = 0, n = maList.size(); i < n; ++i ) { + if (rName == maList[ i ]->GetName()) { + return i; + } + } + return -1; +} + +BitmapEx XPropertyList::GetUiBitmap( tools::Long nIndex ) const +{ + BitmapEx aRetval; + if (!isValidIdx(nIndex)) + return aRetval; + + XPropertyEntry* pEntry = maList[nIndex].get(); + aRetval = pEntry->GetUiBitmap(); + + if(aRetval.IsEmpty()) + { + aRetval = const_cast< XPropertyList* >(this)->CreateBitmapForUI(nIndex); + pEntry->SetUiBitmap(aRetval); + } + return aRetval; +} + +void XPropertyList::Insert(std::unique_ptr pEntry, tools::Long nIndex) +{ + if (!pEntry) + { + assert(!"empty XPropertyEntry not allowed in XPropertyList"); + return; + } + + if (isValidIdx(nIndex)) { + maList.insert( maList.begin()+nIndex, std::move(pEntry) ); + } else { + maList.push_back( std::move(pEntry) ); + } +} + +void XPropertyList::Replace(std::unique_ptr pEntry, tools::Long nIndex) +{ + if (!pEntry) + { + assert(!"empty XPropertyEntry not allowed in XPropertyList"); + return; + } + if (!isValidIdx(nIndex)) + { + assert(!"trying to replace invalid entry in XPropertyList"); + return; + } + + maList[nIndex] = std::move(pEntry); +} + +void XPropertyList::Remove(tools::Long nIndex) +{ + if (!isValidIdx(nIndex)) + { + assert(!"trying to remove invalid entry in XPropertyList"); + return; + } + + maList.erase(maList.begin() + nIndex); +} + +void XPropertyList::SetName( const OUString& rString ) +{ + if(!rString.isEmpty()) + { + maName = rString; + } +} + +bool XPropertyList::Load() +{ + if( mbListDirty ) + { + mbListDirty = false; + std::stack aDirs; + + sal_Int32 nIndex = 0; + do + { + aDirs.push(maPath.getToken(0, ';', nIndex)); + } + while (nIndex >= 0); + + //try all entries palette path list working back to front until one + //succeeds + while (!aDirs.empty()) + { + OUString aPath(aDirs.top()); + aDirs.pop(); + + INetURLObject aURL(aPath); + + if( INetProtocol::NotValid == aURL.GetProtocol() ) + { + DBG_ASSERT( aPath.isEmpty(), "invalid URL" ); + return false; + } + + aURL.Append( maName ); + + if( aURL.getExtension().isEmpty() ) + aURL.setExtension( GetDefaultExt() ); + + bool bRet = SvxXMLXTableImport::load(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), + maReferer, uno::Reference < embed::XStorage >(), + createInstance(), nullptr ); + if (bRet) + return bRet; + } + } + return false; +} + +bool XPropertyList::LoadFrom( const uno::Reference < embed::XStorage > &xStorage, + const OUString &rURL, const OUString &rReferer ) +{ + if( !mbListDirty ) + return false; + mbListDirty = false; + return SvxXMLXTableImport::load( rURL, rReferer, xStorage, createInstance(), &mbEmbedInDocument ); +} + +bool XPropertyList::Save() +{ + //save to the last path in the palette path list + OUString aLastDir; + sal_Int32 nIndex = 0; + do + { + aLastDir = maPath.getToken(0, ';', nIndex); + } + while (nIndex >= 0); + + INetURLObject aURL(aLastDir); + + if( INetProtocol::NotValid == aURL.GetProtocol() ) + { + DBG_ASSERT( aLastDir.isEmpty(), "invalid URL" ); + return false; + } + + aURL.Append( maName ); + + if( aURL.getExtension().isEmpty() ) + aURL.setExtension( GetDefaultExt() ); + + return SvxXMLXTableExportComponent::save( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), + createInstance(), + uno::Reference< embed::XStorage >(), nullptr ); +} + +bool XPropertyList::SaveTo( const uno::Reference< embed::XStorage > &xStorage, + const OUString &rURL, OUString *pOptName ) +{ + return SvxXMLXTableExportComponent::save( rURL, createInstance(), xStorage, pOptName ); +} + +XPropertyListRef XPropertyList::CreatePropertyList( XPropertyListType aType, + const OUString& rPath, + const OUString& rReferer ) +{ + XPropertyListRef pRet; + + switch (aType) { + case XPropertyListType::Color: + pRet = XPropertyListRef(new XColorList(rPath, rReferer)); + break; + case XPropertyListType::LineEnd: + pRet = XPropertyListRef(new XLineEndList(rPath, rReferer)); + break; + case XPropertyListType::Dash: + pRet = XPropertyListRef(new XDashList(rPath, rReferer)); + break; + case XPropertyListType::Hatch: + pRet = XPropertyListRef(new XHatchList(rPath, rReferer)); + break; + case XPropertyListType::Gradient: + pRet = XPropertyListRef(new XGradientList(rPath, rReferer)); + break; + case XPropertyListType::Bitmap: + pRet = XPropertyListRef(new XBitmapList(rPath, rReferer)); + break; + case XPropertyListType::Pattern: + pRet = XPropertyListRef(new XPatternList(rPath, rReferer)); + break; + default: + OSL_FAIL("unknown xproperty type"); + break; + } + OSL_ASSERT( !pRet.is() || pRet->meType == aType ); + + return pRet; +} + +XPropertyListRef +XPropertyList::CreatePropertyListFromURL( XPropertyListType t, + std::u16string_view rURLStr ) +{ + INetURLObject aURL( rURLStr ); + INetURLObject aPathURL( aURL ); + + aPathURL.removeSegment(); + aPathURL.removeFinalSlash(); + + XPropertyListRef pList = XPropertyList::CreatePropertyList( + t, aPathURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), "" ); + pList->SetName( aURL.getName() ); + + return pList; +} + +struct { + XPropertyListType t; + const char *pExt; +} const pExtnMap[] = { + { XPropertyListType::Color, "soc" }, + { XPropertyListType::LineEnd, "soe" }, + { XPropertyListType::Dash, "sod" }, + { XPropertyListType::Hatch, "soh" }, + { XPropertyListType::Gradient, "sog" }, + { XPropertyListType::Bitmap, "sob" }, + { XPropertyListType::Pattern, "sop"} +}; + +OUString XPropertyList::GetDefaultExt( XPropertyListType t ) +{ + for (const auto & i : pExtnMap) + { + if( i.t == t ) + return OUString::createFromAscii( i.pExt ); + } + return OUString(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/xoutdev/xtablend.cxx b/svx/source/xoutdev/xtablend.cxx new file mode 100644 index 000000000..fcca05960 --- /dev/null +++ b/svx/source/xoutdev/xtablend.cxx @@ -0,0 +1,163 @@ +/* -*- 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 +#include + +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +XLineEndList::XLineEndList( const OUString& rPath, const OUString& rReferer ) + : XPropertyList( XPropertyListType::LineEnd, rPath, rReferer ) +{ +} + +XLineEndList::~XLineEndList() +{ +} + +XLineEndEntry* XLineEndList::GetLineEnd(tools::Long nIndex) const +{ + return static_cast( XPropertyList::Get(nIndex) ); +} + +uno::Reference< container::XNameContainer > XLineEndList::createInstance() +{ + return SvxUnoXLineEndTable_createInstance( *this ); +} + +bool XLineEndList::Create() +{ + basegfx::B2DPolygon aTriangle; + aTriangle.append(basegfx::B2DPoint(10.0, 0.0)); + aTriangle.append(basegfx::B2DPoint(0.0, 30.0)); + aTriangle.append(basegfx::B2DPoint(20.0, 30.0)); + aTriangle.setClosed(true); + Insert( std::make_unique( basegfx::B2DPolyPolygon(aTriangle), SvxResId( RID_SVXSTR_ARROW ) ) ); + + basegfx::B2DPolygon aSquare; + aSquare.append(basegfx::B2DPoint(0.0, 0.0)); + aSquare.append(basegfx::B2DPoint(10.0, 0.0)); + aSquare.append(basegfx::B2DPoint(10.0, 10.0)); + aSquare.append(basegfx::B2DPoint(0.0, 10.0)); + aSquare.setClosed(true); + Insert( std::make_unique( basegfx::B2DPolyPolygon(aSquare), SvxResId( RID_SVXSTR_SQUARE ) ) ); + + basegfx::B2DPolygon aCircle(basegfx::utils::createPolygonFromCircle(basegfx::B2DPoint(0.0, 0.0), 100.0)); + Insert( std::make_unique( basegfx::B2DPolyPolygon(aCircle), SvxResId( RID_SVXSTR_CIRCLE ) ) ); + + return true; +} + +BitmapEx XLineEndList::CreateBitmapForUI( tools::Long nIndex ) +{ + BitmapEx aRetval; + OSL_ENSURE(nIndex < Count(), "OOps, access out of range (!)"); + + if(nIndex < Count()) + { + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + const Size& rSize = rStyleSettings.GetListBoxPreviewDefaultPixelSize(); + + const Size aSize(rSize.Width() * 2, rSize.Height()); + + // prepare line geometry + basegfx::B2DPolygon aLine; + const double fBorderDistance(aSize.Height() * 0.1); + + aLine.append(basegfx::B2DPoint(fBorderDistance, aSize.Height() / 2)); + aLine.append(basegfx::B2DPoint(aSize.Width() - fBorderDistance, aSize.Height() / 2)); + + // prepare LineAttribute + const basegfx::BColor aLineColor(rStyleSettings.GetFieldTextColor().getBColor()); + const double fLineWidth(StyleSettings::GetListBoxPreviewDefaultLineWidth() * 1.1); + const drawinglayer::attribute::LineAttribute aLineAttribute( + aLineColor, + fLineWidth); + + const basegfx::B2DPolyPolygon aLineEnd(GetLineEnd(nIndex)->GetLineEnd()); + const double fArrowHeight(aSize.Height() - (2.0 * fBorderDistance)); + const drawinglayer::attribute::LineStartEndAttribute aLineStartEndAttribute( + fArrowHeight, + aLineEnd, + false); + + // prepare line primitive + const drawinglayer::primitive2d::Primitive2DReference aLineStartEndPrimitive( + new drawinglayer::primitive2d::PolygonStrokeArrowPrimitive2D( + aLine, + aLineAttribute, + aLineStartEndAttribute, + aLineStartEndAttribute)); + + // prepare VirtualDevice + ScopedVclPtrInstance< VirtualDevice > pVirtualDevice; + const drawinglayer::geometry::ViewInformation2D aNewViewInformation2D; + + pVirtualDevice->SetOutputSizePixel(aSize); + pVirtualDevice->SetDrawMode(rStyleSettings.GetHighContrastMode() + ? DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill | DrawModeFlags::SettingsText | DrawModeFlags::SettingsGradient + : DrawModeFlags::Default); + + if(rStyleSettings.GetPreviewUsesCheckeredBackground()) + { + const Point aNull(0, 0); + static const sal_uInt32 nLen(8); + static const Color aW(COL_WHITE); + static const Color aG(0xef, 0xef, 0xef); + pVirtualDevice->DrawCheckered(aNull, aSize, nLen, aW, aG); + } + else + { + pVirtualDevice->SetBackground(rStyleSettings.GetFieldColor()); + pVirtualDevice->Erase(); + } + + // create processor and draw primitives + std::unique_ptr pProcessor2D(drawinglayer::processor2d::createPixelProcessor2DFromOutputDevice( + *pVirtualDevice, + aNewViewInformation2D)); + + const drawinglayer::primitive2d::Primitive2DContainer aSequence { aLineStartEndPrimitive }; + + pProcessor2D->process(aSequence); + pProcessor2D.reset(); + + // get result bitmap and scale + aRetval = pVirtualDevice->GetBitmapEx(Point(0, 0), pVirtualDevice->GetOutputSizePixel()); + } + + return aRetval; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/xoutdev/xtabptrn.cxx b/svx/source/xoutdev/xtabptrn.cxx new file mode 100644 index 000000000..29697880f --- /dev/null +++ b/svx/source/xoutdev/xtabptrn.cxx @@ -0,0 +1,149 @@ +/* -*- 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 + +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +XBitmapEntry* XPatternList::GetBitmap(tools::Long nIndex) const +{ + return static_cast( XPropertyList::Get(nIndex) ); +} + +uno::Reference< container::XNameContainer > XPatternList::createInstance() +{ + return SvxUnoXBitmapTable_createInstance( *this ); +} + +bool XPatternList::Create() +{ + OUStringBuffer aStr(SvxResId(RID_SVXSTR_PATTERN)); + std::array aArray; + BitmapEx aBitmap; + const sal_Int32 nLen(aStr.getLength() - 1); + + aArray.fill(0); + + // white/white bitmap + aStr.append(" 1"); + aBitmap = vcl::bitmap::createHistorical8x8FromArray(aArray, COL_WHITE, COL_WHITE); + Insert(std::make_unique(Graphic(aBitmap), aStr.toString())); + + // black/white bitmap + aArray[ 0] = 1; aArray[ 9] = 1; aArray[18] = 1; aArray[27] = 1; + aArray[36] = 1; aArray[45] = 1; aArray[54] = 1; aArray[63] = 1; + aStr[nLen] = '2'; + aBitmap = vcl::bitmap::createHistorical8x8FromArray(aArray, COL_BLACK, COL_WHITE); + Insert(std::make_unique(Graphic(aBitmap), aStr.toString())); + + // lightred/white bitmap + aArray[ 7] = 1; aArray[14] = 1; aArray[21] = 1; aArray[28] = 1; + aArray[35] = 1; aArray[42] = 1; aArray[49] = 1; aArray[56] = 1; + aStr[nLen] = '3'; + aBitmap = vcl::bitmap::createHistorical8x8FromArray(aArray, COL_LIGHTRED, COL_WHITE); + Insert(std::make_unique(Graphic(aBitmap), aStr.toString())); + + // lightblue/white bitmap + aArray[24] = 1; aArray[25] = 1; aArray[26] = 1; + aArray[29] = 1; aArray[30] = 1; aArray[31] = 1; + aStr[nLen] = '4'; + aBitmap = vcl::bitmap::createHistorical8x8FromArray(aArray, COL_LIGHTBLUE, COL_WHITE); + Insert(std::make_unique(Graphic(aBitmap), aStr.toString())); + + return true; +} + +BitmapEx XPatternList::CreateBitmap( tools::Long nIndex, const Size& rSize ) const +{ + assert( nIndex < Count() ); + + if(nIndex < Count()) + { + BitmapEx rBitmapEx = GetBitmap( nIndex )->GetGraphicObject().GetGraphic().GetBitmapEx(); + ScopedVclPtrInstance< VirtualDevice > pVirtualDevice; + pVirtualDevice->SetOutputSizePixel(rSize); + + if(rBitmapEx.IsAlpha()) + { + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + + if(rStyleSettings.GetPreviewUsesCheckeredBackground()) + { + const Point aNull(0, 0); + static const sal_uInt32 nLen(8); + static const Color aW(COL_WHITE); + static const Color aG(0xef, 0xef, 0xef); + + pVirtualDevice->DrawCheckered(aNull, rSize, nLen, aW, aG); + } + else + { + pVirtualDevice->SetBackground(rStyleSettings.GetFieldColor()); + pVirtualDevice->Erase(); + } + } + + if(rBitmapEx.GetSizePixel().Width() >= rSize.Width() && rBitmapEx.GetSizePixel().Height() >= rSize.Height()) + { + rBitmapEx.Scale(rSize); + pVirtualDevice->DrawBitmapEx(Point(0, 0), rBitmapEx); + } + else + { + const Size aBitmapSize(rBitmapEx.GetSizePixel()); + + for(tools::Long y(0); y < rSize.Height(); y += aBitmapSize.Height()) + { + for(tools::Long x(0); x < rSize.Width(); x += aBitmapSize.Width()) + { + pVirtualDevice->DrawBitmapEx( + Point(x, y), + rBitmapEx); + } + } + } + rBitmapEx = pVirtualDevice->GetBitmapEx(Point(0, 0), rSize); + return rBitmapEx; + } + else + return BitmapEx(); +} + +BitmapEx XPatternList::CreateBitmapForUI( tools::Long nIndex ) +{ + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + const Size& rSize = rStyleSettings.GetListBoxPreviewDefaultPixelSize(); + return CreateBitmap(nIndex, rSize); +} + +BitmapEx XPatternList::GetBitmapForPreview( tools::Long nIndex, const Size& rSize ) +{ + return CreateBitmap(nIndex, rSize); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit v1.2.3