diff options
Diffstat (limited to 'include/vcl')
291 files changed, 48074 insertions, 0 deletions
diff --git a/include/vcl/AccessibleBrowseBoxObjType.hxx b/include/vcl/AccessibleBrowseBoxObjType.hxx new file mode 100644 index 000000000..481c41435 --- /dev/null +++ b/include/vcl/AccessibleBrowseBoxObjType.hxx @@ -0,0 +1,35 @@ +/* -*- 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 . + */ +#pragma once + +/** This enumeration contains a constant for each kind of accessible object of + a BrowseBox. */ +enum class AccessibleBrowseBoxObjType +{ + BrowseBox, /// The BrowseBox itself. + Table, /// The data table. + RowHeaderBar, /// The row header bar ("handle column"). + ColumnHeaderBar, /// The horizontal column header bar. + TableCell, /// A cell of the data table. + RowHeaderCell, /// A cell of the row header bar. + ColumnHeaderCell, /// A cell of the column header bar. + CheckBoxCell /// A cell with a checkbox. +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BinaryDataContainer.hxx b/include/vcl/BinaryDataContainer.hxx new file mode 100644 index 000000000..b7421e987 --- /dev/null +++ b/include/vcl/BinaryDataContainer.hxx @@ -0,0 +1,66 @@ +/* -*- 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/. + * + */ + +#pragma once + +#include <vcl/dllapi.h> +#include <vector> +#include <memory> + +/** Container for the binary data, whose responsibility is to manage the + * make it as simple as possible to manage the binary data. The binary + * data can be anything, but typically it is a in-memory data from + * files (i.e. files of graphic formats). + */ +class VCL_DLLPUBLIC BinaryDataContainer final +{ +private: + // the binary data + std::shared_ptr<std::vector<sal_uInt8>> mpData; + +public: + BinaryDataContainer(); + BinaryDataContainer(const sal_uInt8* pData, size_t nSize); + BinaryDataContainer(std::unique_ptr<std::vector<sal_uInt8>> rData); + + BinaryDataContainer(const BinaryDataContainer& rBinaryDataContainer) + : mpData(rBinaryDataContainer.mpData) + { + } + + BinaryDataContainer(BinaryDataContainer&& rBinaryDataContainer) noexcept + : mpData(std::move(rBinaryDataContainer.mpData)) + { + } + + BinaryDataContainer& operator=(const BinaryDataContainer& rBinaryDataContainer) + { + mpData = rBinaryDataContainer.mpData; + return *this; + } + + BinaryDataContainer& operator=(BinaryDataContainer&& rBinaryDataContainer) noexcept + { + mpData = std::move(rBinaryDataContainer.mpData); + return *this; + } + + size_t getSize() const { return mpData ? mpData->size() : 0; } + bool isEmpty() const { return !mpData || mpData->empty(); } + const sal_uInt8* getData() const { return mpData ? mpData->data() : nullptr; } + + size_t calculateHash() const; + + auto cbegin() const { return mpData->cbegin(); } + + auto cend() const { return mpData->cend(); } +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BinaryDataContainerTools.hxx b/include/vcl/BinaryDataContainerTools.hxx new file mode 100644 index 000000000..3d50379a8 --- /dev/null +++ b/include/vcl/BinaryDataContainerTools.hxx @@ -0,0 +1,23 @@ +/* -*- 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/. + * + */ + +#pragma once + +#include <vcl/dllapi.h> +#include <vcl/BinaryDataContainer.hxx> +#include <com/sun/star/util/XBinaryDataContainer.hpp> + +namespace vcl +{ +VCL_DLLPUBLIC BinaryDataContainer convertUnoBinaryDataContainer( + css::uno::Reference<css::util::XBinaryDataContainer> const& rxBinaryDataContainer); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapAccessMode.hxx b/include/vcl/BitmapAccessMode.hxx new file mode 100644 index 000000000..66cc2b56b --- /dev/null +++ b/include/vcl/BitmapAccessMode.hxx @@ -0,0 +1,32 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_BITMAPACCESSMODE_HXX +#define INCLUDED_VCL_BITMAPACCESSMODE_HXX + +enum class BitmapAccessMode +{ + Info, + Read, + Write +}; + +#endif // INCLUDED_VCL_BITMAPACCESSMODE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapAlphaClampFilter.hxx b/include/vcl/BitmapAlphaClampFilter.hxx new file mode 100644 index 000000000..6926c3274 --- /dev/null +++ b/include/vcl/BitmapAlphaClampFilter.hxx @@ -0,0 +1,34 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_INCLUDE_VCL_BITMAPALPHACLAMPFILTER_HXX +#define INCLUDED_INCLUDE_VCL_BITMAPALPHACLAMPFILTER_HXX + +#include <vcl/BitmapFilter.hxx> + +/** If the alpha is beyond a certain threshold, make it fully transparent + */ +class VCL_DLLPUBLIC BitmapAlphaClampFilter final : public BitmapFilter +{ +public: + BitmapAlphaClampFilter(sal_uInt8 cThreshold) + : mcThreshold(cThreshold) + { + } + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; + +private: + sal_uInt8 mcThreshold; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapBasicMorphologyFilter.hxx b/include/vcl/BitmapBasicMorphologyFilter.hxx new file mode 100644 index 000000000..055e1e14e --- /dev/null +++ b/include/vcl/BitmapBasicMorphologyFilter.hxx @@ -0,0 +1,71 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_BITMAPBASICMORPHOLOGYFILTER_HXX +#define INCLUDED_VCL_BITMAPBASICMORPHOLOGYFILTER_HXX + +#include <vcl/bitmap.hxx> +#include <vcl/bitmapex.hxx> +#include <vcl/BitmapFilter.hxx> + +enum class BasicMorphologyOp +{ + erode, + dilate +}; + +/* Black is foreground, white is background */ +class VCL_DLLPUBLIC BitmapBasicMorphologyFilter : public BitmapFilter +{ +public: + BitmapBasicMorphologyFilter(BasicMorphologyOp op, sal_Int32 nRadius); + BitmapBasicMorphologyFilter(BasicMorphologyOp op, sal_Int32 nRadius, sal_uInt8 nValueOutside); + virtual ~BitmapBasicMorphologyFilter(); + + virtual BitmapEx execute(BitmapEx const& rBitmap) const override; + +private: + Bitmap filter(Bitmap const& rBitmap) const; + + BasicMorphologyOp m_eOp; + sal_Int32 m_nRadius; + sal_uInt8 m_nValueOutside = 0; + bool m_bUseValueOutside = false; +}; + +class BitmapErodeFilter final : public BitmapBasicMorphologyFilter +{ +public: + BitmapErodeFilter(sal_Int32 nRadius) + : BitmapBasicMorphologyFilter(BasicMorphologyOp::erode, nRadius) + { + } + BitmapErodeFilter(sal_Int32 nRadius, sal_uInt8 nValueOutside) + : BitmapBasicMorphologyFilter(BasicMorphologyOp::erode, nRadius, nValueOutside) + { + } +}; + +class BitmapDilateFilter final : public BitmapBasicMorphologyFilter +{ +public: + BitmapDilateFilter(sal_Int32 nRadius) + : BitmapBasicMorphologyFilter(BasicMorphologyOp::dilate, nRadius) + { + } + BitmapDilateFilter(sal_Int32 nRadius, sal_uInt8 nValueOutside) + : BitmapBasicMorphologyFilter(BasicMorphologyOp::dilate, nRadius, nValueOutside) + { + } +}; + +#endif // INCLUDED_VCL_BITMAPBASICMORPHOLOGYFILTER_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapBuffer.hxx b/include/vcl/BitmapBuffer.hxx new file mode 100644 index 000000000..54efeea5e --- /dev/null +++ b/include/vcl/BitmapBuffer.hxx @@ -0,0 +1,54 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_BITMAPBUFFER_HXX +#define INCLUDED_VCL_BITMAPBUFFER_HXX + +#include <sal/config.h> + +#include <memory> +#include <optional> + +#include <vcl/dllapi.h> +#include <vcl/BitmapPalette.hxx> +#include <vcl/ColorMask.hxx> +#include <vcl/Scanline.hxx> +#include <tools/long.hxx> + +struct SalTwoRect; + +struct VCL_DLLPUBLIC BitmapBuffer +{ + tools::Long mnWidth; + tools::Long mnHeight; + tools::Long mnScanlineSize; + BitmapPalette maPalette; + sal_uInt8* mpBits; + ScanlineFormat mnFormat; + ColorMask maColorMask; + sal_uInt16 mnBitCount; +}; + +VCL_DLLPUBLIC std::unique_ptr<BitmapBuffer> StretchAndConvert( + const BitmapBuffer& rSrcBuffer, const SalTwoRect& rTwoRect, + ScanlineFormat nDstBitmapFormat, std::optional<BitmapPalette> pDstPal = std::nullopt, const ColorMask* pDstMask = nullptr ); + +#endif // INCLUDED_VCL_BITMAPBUFFER_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapColor.hxx b/include/vcl/BitmapColor.hxx new file mode 100644 index 000000000..b5364b4d1 --- /dev/null +++ b/include/vcl/BitmapColor.hxx @@ -0,0 +1,82 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_BITMAPCOLOR_HXX +#define INCLUDED_VCL_BITMAPCOLOR_HXX + +#include <vcl/dllapi.h> +#include <tools/color.hxx> + +class VCL_DLLPUBLIC BitmapColor final : public Color +{ +public: + inline BitmapColor(); + constexpr BitmapColor( sal_uInt8 cRed, sal_uInt8 cGreen, sal_uInt8 cBlue ); + constexpr BitmapColor( ColorTransparencyTag, sal_uInt8 cRed, sal_uInt8 cGreen, sal_uInt8 cBlue, sal_uInt8 cTransparency ); + constexpr BitmapColor( ColorAlphaTag, sal_uInt8 cRed, sal_uInt8 cGreen, sal_uInt8 cBlue, sal_uInt8 cAlpha ); + + inline BitmapColor( const Color& rColor ); + explicit inline BitmapColor( sal_uInt8 cIndex ); + + inline sal_uInt8 GetIndex() const; + inline void SetIndex( sal_uInt8 cIndex ); +}; + +inline BitmapColor::BitmapColor() +{ +} + +inline BitmapColor::BitmapColor( const Color& rColor ) + : Color(rColor) +{ +} + +constexpr BitmapColor::BitmapColor(sal_uInt8 cRed, sal_uInt8 cGreen, sal_uInt8 cBlue) + : Color(cRed, cGreen, cBlue) +{ +} + +constexpr BitmapColor::BitmapColor(ColorTransparencyTag, sal_uInt8 cRed, sal_uInt8 cGreen, sal_uInt8 cBlue, sal_uInt8 cTransparency) + : Color(ColorTransparency, cTransparency, cRed, cGreen, cBlue) +{ +} + +constexpr BitmapColor::BitmapColor(ColorAlphaTag, sal_uInt8 cRed, sal_uInt8 cGreen, sal_uInt8 cBlue, sal_uInt8 cAlpha) + : Color(ColorAlpha, cAlpha, cRed, cGreen, cBlue) +{ +} + +inline BitmapColor::BitmapColor( sal_uInt8 cIndex ) +{ + SetIndex(cIndex); +} + +inline sal_uInt8 BitmapColor::GetIndex() const +{ + return GetBlue(); +} + +inline void BitmapColor::SetIndex( sal_uInt8 cIndex ) +{ + SetBlue(cIndex); +} + +#endif // INCLUDED_VCL_BITMAPCOLOR_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapColorQuantizationFilter.hxx b/include/vcl/BitmapColorQuantizationFilter.hxx new file mode 100644 index 000000000..266a384a3 --- /dev/null +++ b/include/vcl/BitmapColorQuantizationFilter.hxx @@ -0,0 +1,43 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_INCLUDE_VCL_BITMAPCOLORQUANTIZATIONFILTER_HXX +#define INCLUDED_INCLUDE_VCL_BITMAPCOLORQUANTIZATIONFILTER_HXX + +#include <vcl/BitmapFilter.hxx> + +class VCL_DLLPUBLIC BitmapColorQuantizationFilter final : public BitmapFilter +{ +public: + /** Reduce number of colors for the bitmap using the POPULAR algorithm + + @param nNewColorCount + Maximal number of bitmap colors after the reduce operation + */ + BitmapColorQuantizationFilter(sal_uInt16 nNewColorCount) + : mnNewColorCount(nNewColorCount) + { + } + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; + +private: + sal_uInt16 mnNewColorCount; + + struct PopularColorCount + { + sal_uInt32 mnIndex; + sal_uInt32 mnCount; + }; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapConvolutionMatrixFilter.hxx b/include/vcl/BitmapConvolutionMatrixFilter.hxx new file mode 100644 index 000000000..a504ff0ee --- /dev/null +++ b/include/vcl/BitmapConvolutionMatrixFilter.hxx @@ -0,0 +1,36 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_BITMAPCONVOLUTIONMATRIXFILTER_HXX +#define INCLUDED_VCL_BITMAPCONVOLUTIONMATRIXFILTER_HXX + +#include <vcl/BitmapFilter.hxx> + +class BitmapEx; + +/** Filter image based on a 3x3 convolution matrix + */ +class VCL_DLLPUBLIC BitmapConvolutionMatrixFilter : public BitmapFilter +{ +public: + BitmapConvolutionMatrixFilter(const sal_Int32 (&rMatrix)[9]) + : mrMatrix(rMatrix) + { + } + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; + +private: + const sal_Int32 (&mrMatrix)[9]; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapDuoToneFilter.hxx b/include/vcl/BitmapDuoToneFilter.hxx new file mode 100644 index 000000000..27ade1cb2 --- /dev/null +++ b/include/vcl/BitmapDuoToneFilter.hxx @@ -0,0 +1,36 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_BITMAPDUOTONEFILTER_HXX +#define INCLUDED_VCL_BITMAPDUOTONEFILTER_HXX + +#include <vcl/BitmapFilter.hxx> + +class BitmapEx; + +class BitmapDuoToneFilter final : public BitmapFilter +{ +public: + BitmapDuoToneFilter(Color nColorOne, Color nColorTwo) + : mnColorOne(nColorOne) + , mnColorTwo(nColorTwo) + { + } + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; + +private: + Color mnColorOne; + Color mnColorTwo; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapEmbossGreyFilter.hxx b/include/vcl/BitmapEmbossGreyFilter.hxx new file mode 100644 index 000000000..2f1d309e0 --- /dev/null +++ b/include/vcl/BitmapEmbossGreyFilter.hxx @@ -0,0 +1,36 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_BITMAPEMBOSSGREYFILTER_HXX +#define INCLUDED_VCL_BITMAPEMBOSSGREYFILTER_HXX + +#include <vcl/BitmapFilter.hxx> + +class BitmapEx; + +class VCL_DLLPUBLIC BitmapEmbossGreyFilter final : public BitmapFilter +{ +public: + BitmapEmbossGreyFilter(sal_uInt16 nAzimuthAngle100, sal_uInt16 nElevationAngle100) + : mnAzimuthAngle100(nAzimuthAngle100) + , mnElevationAngle100(nElevationAngle100) + { + } + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; + +private: + sal_uInt16 mnAzimuthAngle100; + sal_uInt16 mnElevationAngle100; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapFilter.hxx b/include/vcl/BitmapFilter.hxx new file mode 100644 index 000000000..c19d83b2d --- /dev/null +++ b/include/vcl/BitmapFilter.hxx @@ -0,0 +1,60 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_BITMAPFILTER_HXX +#define INCLUDED_VCL_BITMAPFILTER_HXX + +#include <vcl/bitmapex.hxx> +#include <functional> + +class Animation; + +namespace vcl::bitmap +{ +// Generates strip ranges and run the input function with the start and +// end as parameters. The additional parameter bLast denotes if the +// iteration is the last one. +// +// Example: +// first = 0, last = 100, STRIP_SIZE = 32 +// this will generate: +// [0, 31, false], [32, 63, false], [64, 95, false], [96, 100, true] +template <int STRIP_SIZE> +void generateStripRanges( + tools::Long nFirst, tools::Long nLast, + std::function<void(tools::Long const nStart, tools::Long const nEnd, bool const bLast)> + aFunction) +{ + tools::Long nStart = nFirst; + for (; nStart < nLast - STRIP_SIZE; nStart += STRIP_SIZE) + { + tools::Long nEnd = nStart + STRIP_SIZE - 1; + aFunction(nStart, nEnd, false); + } + aFunction(nStart, nLast, true); +} + +} // end vcl::bitmap + +class VCL_DLLPUBLIC BitmapFilter +{ +public: + BitmapFilter(); + virtual ~BitmapFilter(); + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const = 0; + + static bool Filter(BitmapEx& rBmpEx, BitmapFilter const& rFilter); + static bool Filter(Animation& rBmpEx, BitmapFilter const& rFilter); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapFilterStackBlur.hxx b/include/vcl/BitmapFilterStackBlur.hxx new file mode 100644 index 000000000..2fdb78b0b --- /dev/null +++ b/include/vcl/BitmapFilterStackBlur.hxx @@ -0,0 +1,33 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_BITMAPFILTERSTACKBLUR_HXX +#define INCLUDED_VCL_BITMAPFILTERSTACKBLUR_HXX + +#include <vcl/bitmap.hxx> +#include <vcl/bitmapex.hxx> +#include <vcl/BitmapFilter.hxx> + +class VCL_DLLPUBLIC BitmapFilterStackBlur final : public BitmapFilter +{ + sal_Int32 mnRadius; + +public: + BitmapFilterStackBlur(sal_Int32 nRadius); + virtual ~BitmapFilterStackBlur(); + + virtual BitmapEx execute(BitmapEx const& rBitmap) const override; + + Bitmap filter(Bitmap const& rBitmap) const; +}; + +#endif // INCLUDED_VCL_BITMAPFILTERSTACKBLUR_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapGaussianSeparableBlurFilter.hxx b/include/vcl/BitmapGaussianSeparableBlurFilter.hxx new file mode 100644 index 000000000..72b3fdb81 --- /dev/null +++ b/include/vcl/BitmapGaussianSeparableBlurFilter.hxx @@ -0,0 +1,52 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_BITMAPGAUSSIANSEPARABLEBLURFILTER_HXX +#define INCLUDED_VCL_BITMAPGAUSSIANSEPARABLEBLURFILTER_HXX + +#include <vcl/BitmapFilter.hxx> +#include <vector> + +class BitmapEx; + +class BitmapGaussianSeparableBlurFilter final : public BitmapFilter +{ +public: + BitmapGaussianSeparableBlurFilter(double fRadius) + : mfRadius(fRadius) + { + } + + /** Separable Gaussian Blur filter and accepts a blur radius + as a parameter so the user can change the strength of the blur. + Radius of 1.0 is 3 * standard deviation of gauss function. + + Separable Blur implementation uses 2x separable 1D convolution + to process the image. + */ + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; + +private: + double mfRadius; + + static bool convolutionPass(const Bitmap& rBitmap, Bitmap& aNewBitmap, + BitmapReadAccess const* pReadAcc, int aNumberOfContributions, + const double* pWeights, int const* pPixels, const int* pCount); + + static std::vector<double> makeBlurKernel(const double radius, int& rows); + static void blurContributions(const int aSize, const int aNumberOfContributions, + const std::vector<double>& rBlurVector, + std::vector<double>& rWeights, std::vector<int>& rPixels, + std::vector<int>& rCounts); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapInfoAccess.hxx b/include/vcl/BitmapInfoAccess.hxx new file mode 100644 index 000000000..c0ef7fb5b --- /dev/null +++ b/include/vcl/BitmapInfoAccess.hxx @@ -0,0 +1,148 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_BITMAPINFOACCESS_HXX +#define INCLUDED_VCL_BITMAPINFOACCESS_HXX + +#include <vcl/dllapi.h> +#include <vcl/bitmap.hxx> +#include <vcl/Scanline.hxx> +#include <vcl/BitmapBuffer.hxx> +#include <vcl/BitmapColor.hxx> +#include <vcl/BitmapAccessMode.hxx> + +bool Bitmap32IsPreMultipled(); + +typedef BitmapColor (*FncGetPixel)(ConstScanline pScanline, tools::Long nX, const ColorMask& rMask); +typedef void (*FncSetPixel)(Scanline pScanline, tools::Long nX, const BitmapColor& rBitmapColor, + const ColorMask& rMask); + +class VCL_DLLPUBLIC BitmapInfoAccess +{ + friend class BitmapReadAccess; + +public: + BitmapInfoAccess(Bitmap& rBitmap, BitmapAccessMode nMode = BitmapAccessMode::Info); + virtual ~BitmapInfoAccess(); + + bool operator!() const { return mpBuffer == nullptr; } + + tools::Long Width() const { return mpBuffer ? mpBuffer->mnWidth : 0L; } + + tools::Long Height() const { return mpBuffer ? mpBuffer->mnHeight : 0L; } + + bool IsTopDown() const + { + assert(mpBuffer && "Access is not valid!"); + + return mpBuffer && (mpBuffer->mnFormat & ScanlineFormat::TopDown); + } + + bool IsBottomUp() const { return !IsTopDown(); } + + ScanlineFormat GetScanlineFormat() const + { + assert(mpBuffer && "Access is not valid!"); + + return mpBuffer ? RemoveScanline(mpBuffer->mnFormat) : ScanlineFormat::NONE; + } + + sal_uInt32 GetScanlineSize() const + { + assert(mpBuffer && "Access is not valid!"); + + return mpBuffer ? mpBuffer->mnScanlineSize : 0; + } + + sal_uInt16 GetBitCount() const + { + assert(mpBuffer && "Access is not valid!"); + + return mpBuffer ? mpBuffer->mnBitCount : 0; + } + + BitmapColor GetBestMatchingColor(const BitmapColor& rBitmapColor) const + { + if (HasPalette()) + return BitmapColor(static_cast<sal_uInt8>(GetBestPaletteIndex(rBitmapColor))); + else + return rBitmapColor; + } + + bool HasPalette() const + { + const BitmapBuffer* pBuffer = mpBuffer; + + assert(pBuffer && "Access is not valid!"); + + return pBuffer && !!pBuffer->maPalette; + } + + const BitmapPalette& GetPalette() const + { + const BitmapBuffer* pBuffer = mpBuffer; + + assert(pBuffer && "Access is not valid!"); + + return pBuffer->maPalette; + } + + sal_uInt16 GetPaletteEntryCount() const + { + const BitmapBuffer* pBuffer = mpBuffer; + + assert(HasPalette() && "Bitmap has no palette!"); + + return HasPalette() ? pBuffer->maPalette.GetEntryCount() : 0; + } + + const BitmapColor& GetPaletteColor(sal_uInt16 nColor) const + { + const BitmapBuffer* pBuffer = mpBuffer; + assert(pBuffer && "Access is not valid!"); + assert(HasPalette() && "Bitmap has no palette!"); + + return pBuffer->maPalette[nColor]; + } + + sal_uInt16 GetBestPaletteIndex(const BitmapColor& rBitmapColor) const; + + const ColorMask& GetColorMask() const + { + const BitmapBuffer* pBuffer = mpBuffer; + + assert(pBuffer && "Access is not valid!"); + + return pBuffer->maColorMask; + } + +private: + BitmapInfoAccess(const BitmapInfoAccess&) = delete; + BitmapInfoAccess& operator=(const BitmapInfoAccess&) = delete; + +protected: + Bitmap maBitmap; + BitmapBuffer* mpBuffer; + ColorMask maColorMask; + BitmapAccessMode mnAccessMode; +}; + +#endif // INCLUDED_VCL_BITMAPINFOACCESS_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapMedianFilter.hxx b/include/vcl/BitmapMedianFilter.hxx new file mode 100644 index 000000000..941ba0dae --- /dev/null +++ b/include/vcl/BitmapMedianFilter.hxx @@ -0,0 +1,28 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_BITMAPMEDIANFILTER_HXX +#define INCLUDED_VCL_BITMAPMEDIANFILTER_HXX + +#include <vcl/BitmapFilter.hxx> + +class BitmapEx; + +class VCL_DLLPUBLIC BitmapMedianFilter final : public BitmapFilter +{ +public: + BitmapMedianFilter() {} + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapMonochromeFilter.hxx b/include/vcl/BitmapMonochromeFilter.hxx new file mode 100644 index 000000000..81a505e1f --- /dev/null +++ b/include/vcl/BitmapMonochromeFilter.hxx @@ -0,0 +1,43 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_INCLUDE_VCL_BITMAPMONOCHROMEFILTER_HXX +#define INCLUDED_INCLUDE_VCL_BITMAPMONOCHROMEFILTER_HXX + +#include <vcl/BitmapFilter.hxx> + +class VCL_DLLPUBLIC BitmapMonochromeFilter final : public BitmapFilter +{ +public: + /** Convert to 2 color bitmap. + + Converts to a 2 color indexed bitmap - note that we don't change to black + and white monochrome, but we pick the closest color to black and white in + the bitmap. + + @param cThreshold + Luminance value that determines whether the colour should be black (or + closest color to black) or white (or closest color to white). + + */ + BitmapMonochromeFilter(sal_uInt8 cThreshold) + : mcThreshold(cThreshold) + { + } + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; + +private: + sal_uInt8 mcThreshold; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapMosaicFilter.hxx b/include/vcl/BitmapMosaicFilter.hxx new file mode 100644 index 000000000..92a5afda4 --- /dev/null +++ b/include/vcl/BitmapMosaicFilter.hxx @@ -0,0 +1,40 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_BITMAPMOSAICFILTER_HXX +#define INCLUDED_VCL_BITMAPMOSAICFILTER_HXX + +#include <sal/config.h> + +#include <algorithm> + +#include <vcl/BitmapFilter.hxx> + +class BitmapEx; + +class VCL_DLLPUBLIC BitmapMosaicFilter final : public BitmapFilter +{ +public: + BitmapMosaicFilter(sal_Int32 nTileWidth, sal_Int32 nTileHeight) + : mnTileWidth(std::max(nTileWidth, sal_Int32(1))) + , mnTileHeight(std::max(nTileHeight, sal_Int32(1))) + { + } + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; + +private: + sal_Int32 mnTileWidth; + sal_Int32 mnTileHeight; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapPalette.hxx b/include/vcl/BitmapPalette.hxx new file mode 100644 index 000000000..d470dfbb5 --- /dev/null +++ b/include/vcl/BitmapPalette.hxx @@ -0,0 +1,78 @@ +/* -*- 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 . + */ + +#pragma once + +#include <vcl/dllapi.h> +#include <vcl/BitmapColor.hxx> +#include <vcl/checksum.hxx> +#include <o3tl/cow_wrapper.hxx> + +class ImplBitmapPalette; + +class VCL_DLLPUBLIC BitmapPalette +{ + friend class SalBitmap; + friend class BitmapAccess; + +public: + + SAL_DLLPRIVATE const BitmapColor* ImplGetColorBuffer() const; + + SAL_DLLPRIVATE BitmapColor* ImplGetColorBuffer(); + + BitmapChecksum GetChecksum() const; + + BitmapPalette(); + BitmapPalette( const BitmapPalette& ); + BitmapPalette( BitmapPalette&& ) noexcept; + BitmapPalette(std::initializer_list<BitmapColor> aBitmapColor); + explicit BitmapPalette(sal_uInt16 nCount); + ~BitmapPalette(); + + BitmapPalette& operator=( const BitmapPalette& ); + BitmapPalette& operator=( BitmapPalette&& ) noexcept; + + bool operator==( const BitmapPalette& rBitmapPalette ) const; + bool operator!=(const BitmapPalette& rBitmapPalette) const + { + return !( *this == rBitmapPalette ); + } + bool operator!() const; + + sal_uInt16 GetEntryCount() const; + void SetEntryCount(sal_uInt16 nCount); + + const BitmapColor& operator[](sal_uInt16 nIndex) const; + BitmapColor& operator[](sal_uInt16 nIndex); + + sal_uInt16 GetBestIndex(const BitmapColor& rCol) const; + + /// Returns true if the palette is 8-bit grey palette. + bool IsGreyPalette8Bit() const; + /// Returns true if the palette is a grey palette (may not be 8-bit). + bool IsGreyPaletteAny() const; + + typedef o3tl::cow_wrapper< ImplBitmapPalette > ImplType; + +private: + ImplType mpImpl; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapPopArtFilter.hxx b/include/vcl/BitmapPopArtFilter.hxx new file mode 100644 index 000000000..e5733f733 --- /dev/null +++ b/include/vcl/BitmapPopArtFilter.hxx @@ -0,0 +1,33 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_BITMAPPOPARTILTER_HXX +#define INCLUDED_VCL_BITMAPPOPARTILTER_HXX + +#include <vcl/BitmapFilter.hxx> + +class VCL_DLLPUBLIC BitmapPopArtFilter final : public BitmapFilter +{ +public: + BitmapPopArtFilter() {} + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; + +private: + struct PopArtEntry + { + sal_uInt32 mnIndex; + sal_uInt32 mnCount; + }; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapReadAccess.hxx b/include/vcl/BitmapReadAccess.hxx new file mode 100644 index 000000000..76d1cddbe --- /dev/null +++ b/include/vcl/BitmapReadAccess.hxx @@ -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 . + */ + +#ifndef INCLUDED_VCL_BITMAPREADACCESS_HXX +#define INCLUDED_VCL_BITMAPREADACCESS_HXX + +#include <vcl/dllapi.h> +#include <vcl/bitmap.hxx> +#include <vcl/Scanline.hxx> +#include <vcl/BitmapBuffer.hxx> +#include <vcl/BitmapColor.hxx> +#include <vcl/BitmapAccessMode.hxx> +#include <vcl/BitmapInfoAccess.hxx> + +class SAL_DLLPUBLIC_RTTI BitmapReadAccess : public BitmapInfoAccess +{ + friend class BitmapWriteAccess; + +public: + VCL_DLLPUBLIC BitmapReadAccess(Bitmap& rBitmap, + BitmapAccessMode nMode = BitmapAccessMode::Read); + VCL_DLLPUBLIC virtual ~BitmapReadAccess() override; + + Scanline GetBuffer() const + { + assert(mpBuffer && "Access is not valid!"); + + return mpBuffer ? mpBuffer->mpBits : nullptr; + } + + Scanline GetScanline(tools::Long nY) const + { + assert(mpBuffer && "Access is not valid!"); + assert(nY < mpBuffer->mnHeight && "y-coordinate out of range!"); + + if (mpBuffer->mnFormat & ScanlineFormat::TopDown) + { + return mpBuffer->mpBits + (nY * mpBuffer->mnScanlineSize); + } + return mpBuffer->mpBits + ((mpBuffer->mnHeight - 1 - nY) * mpBuffer->mnScanlineSize); + } + + BitmapColor GetPixelFromData(const sal_uInt8* pData, tools::Long nX) const + { + assert(pData && "Access is not valid!"); + + return mFncGetPixel(pData, nX, maColorMask); + } + + sal_uInt8 GetIndexFromData(const sal_uInt8* pData, tools::Long nX) const + { + return GetPixelFromData(pData, nX).GetIndex(); + } + + void SetPixelOnData(sal_uInt8* pData, tools::Long nX, const BitmapColor& rBitmapColor) + { + assert(pData && "Access is not valid!"); + + mFncSetPixel(pData, nX, rBitmapColor, maColorMask); + } + + BitmapColor GetPixel(tools::Long nY, tools::Long nX) const + { + assert(mpBuffer && "Access is not valid!"); + assert(nX < mpBuffer->mnWidth && "x-coordinate out of range!"); + assert(nY < mpBuffer->mnHeight && "y-coordinate out of range!"); + + return mFncGetPixel(GetScanline(nY), nX, maColorMask); + } + + BitmapColor GetPixel(const Point& point) const { return GetPixel(point.Y(), point.X()); } + + BitmapColor GetColor(tools::Long nY, tools::Long nX) const + { + if (HasPalette()) + { + const BitmapBuffer* pBuffer = mpBuffer; + return pBuffer->maPalette[GetPixelIndex(nY, nX)]; + } + else + return GetPixel(nY, nX); + } + + BitmapColor GetColor(const Point& point) const { return GetColor(point.Y(), point.X()); } + + sal_uInt8 GetPixelIndex(tools::Long nY, tools::Long nX) const + { + return GetPixel(nY, nX).GetIndex(); + } + + sal_uInt8 GetPixelIndex(const Point& point) const + { + return GetPixelIndex(point.Y(), point.X()); + } + + /** Get the interpolated color at coordinates fY, fX; if outside, return rFallback */ + BitmapColor GetInterpolatedColorWithFallback(double fY, double fX, + const BitmapColor& rFallback) const; + + /** Get the color at coordinates fY, fX; if outside, return rFallback. Automatically does the correct + inside/outside checks, e.g. static_cast< sal_uInt32 >(-0.25) *is* 0, not -1 and has to be outside */ + BitmapColor GetColorWithFallback(double fY, double fX, const BitmapColor& rFallback) const; + +private: + BitmapReadAccess(const BitmapReadAccess&) = delete; + BitmapReadAccess& operator=(const BitmapReadAccess&) = delete; + +protected: + FncGetPixel mFncGetPixel; + FncSetPixel mFncSetPixel; + +public: + BitmapBuffer* ImplGetBitmapBuffer() const { return mpBuffer; } + + static BitmapColor GetPixelForN1BitMsbPal(ConstScanline pScanline, tools::Long nX, + const ColorMask& rMask); + static BitmapColor GetPixelForN1BitLsbPal(ConstScanline pScanline, tools::Long nX, + const ColorMask& rMask); + static BitmapColor GetPixelForN8BitPal(ConstScanline pScanline, tools::Long nX, + const ColorMask& rMask); + static BitmapColor GetPixelForN24BitTcBgr(ConstScanline pScanline, tools::Long nX, + const ColorMask& rMask); + static BitmapColor GetPixelForN24BitTcRgb(ConstScanline pScanline, tools::Long nX, + const ColorMask& rMask); + static BitmapColor GetPixelForN32BitTcAbgr(ConstScanline pScanline, tools::Long nX, + const ColorMask& rMask); + static BitmapColor GetPixelForN32BitTcXbgr(ConstScanline pScanline, tools::Long nX, + const ColorMask& rMask); + static BitmapColor GetPixelForN32BitTcArgb(ConstScanline pScanline, tools::Long nX, + const ColorMask& rMask); + static BitmapColor GetPixelForN32BitTcXrgb(ConstScanline pScanline, tools::Long nX, + const ColorMask& rMask); + static BitmapColor GetPixelForN32BitTcBgra(ConstScanline pScanline, tools::Long nX, + const ColorMask& rMask); + static BitmapColor GetPixelForN32BitTcBgrx(ConstScanline pScanline, tools::Long nX, + const ColorMask& rMask); + static BitmapColor GetPixelForN32BitTcRgba(ConstScanline pScanline, tools::Long nX, + const ColorMask& rMask); + static BitmapColor GetPixelForN32BitTcRgbx(ConstScanline pScanline, tools::Long nX, + const ColorMask& rMask); + static BitmapColor GetPixelForN32BitTcMask(ConstScanline pScanline, tools::Long nX, + const ColorMask& rMask); + + static void SetPixelForN1BitMsbPal(Scanline pScanline, tools::Long nX, + const BitmapColor& rBitmapColor, const ColorMask& rMask); + static void SetPixelForN1BitLsbPal(Scanline pScanline, tools::Long nX, + const BitmapColor& rBitmapColor, const ColorMask& rMask); + static void SetPixelForN8BitPal(Scanline pScanline, tools::Long nX, + const BitmapColor& rBitmapColor, const ColorMask& rMask); + static void SetPixelForN24BitTcBgr(Scanline pScanline, tools::Long nX, + const BitmapColor& rBitmapColor, const ColorMask& rMask); + static void SetPixelForN24BitTcRgb(Scanline pScanline, tools::Long nX, + const BitmapColor& rBitmapColor, const ColorMask& rMask); + static void SetPixelForN32BitTcAbgr(Scanline pScanline, tools::Long nX, + const BitmapColor& rBitmapColor, const ColorMask& rMask); + static void SetPixelForN32BitTcXbgr(Scanline pScanline, tools::Long nX, + const BitmapColor& rBitmapColor, const ColorMask& rMask); + static void SetPixelForN32BitTcArgb(Scanline pScanline, tools::Long nX, + const BitmapColor& rBitmapColor, const ColorMask& rMask); + static void SetPixelForN32BitTcXrgb(Scanline pScanline, tools::Long nX, + const BitmapColor& rBitmapColor, const ColorMask& rMask); + static void SetPixelForN32BitTcBgra(Scanline pScanline, tools::Long nX, + const BitmapColor& rBitmapColor, const ColorMask& rMask); + static void SetPixelForN32BitTcBgrx(Scanline pScanline, tools::Long nX, + const BitmapColor& rBitmapColor, const ColorMask& rMask); + static void SetPixelForN32BitTcRgba(Scanline pScanline, tools::Long nX, + const BitmapColor& rBitmapColor, const ColorMask& rMask); + static void SetPixelForN32BitTcRgbx(Scanline pScanline, tools::Long nX, + const BitmapColor& rBitmapColor, const ColorMask& rMask); + static void SetPixelForN32BitTcMask(Scanline pScanline, tools::Long nX, + const BitmapColor& rBitmapColor, const ColorMask& rMask); + + static FncGetPixel GetPixelFunction(ScanlineFormat nFormat); + static FncSetPixel SetPixelFunction(ScanlineFormat nFormat); +}; + +#endif // INCLUDED_VCL_BITMAPREADACCESS_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapSeparableUnsharpenFilter.hxx b/include/vcl/BitmapSeparableUnsharpenFilter.hxx new file mode 100644 index 000000000..69dcfe3bf --- /dev/null +++ b/include/vcl/BitmapSeparableUnsharpenFilter.hxx @@ -0,0 +1,37 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_BITMAPSEPARABLEUNSHARPENFILTER_HXX +#define INCLUDED_VCL_BITMAPSEPARABLEUNSHARPENFILTER_HXX + +#include <vcl/BitmapFilter.hxx> + +class BitmapEx; + +/** Separable Unsharpen Mask filter is actually a subtracted blurred + image from the original image. + */ +class BitmapSeparableUnsharpenFilter final : public BitmapFilter +{ +public: + BitmapSeparableUnsharpenFilter(double fRadius) + : mfRadius(fRadius) + { + } + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; + +private: + double mfRadius; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapSepiaFilter.hxx b/include/vcl/BitmapSepiaFilter.hxx new file mode 100644 index 000000000..3121987ed --- /dev/null +++ b/include/vcl/BitmapSepiaFilter.hxx @@ -0,0 +1,38 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_BITMAPSEPIAFILTER_HXX +#define INCLUDED_VCL_BITMAPSEPIAFILTER_HXX + +#include <vcl/BitmapFilter.hxx> + +class BitmapEx; + +class VCL_DLLPUBLIC BitmapSepiaFilter final : public BitmapFilter +{ +public: + BitmapSepiaFilter(double nSepiaPercent) + { + // clamp value to 100% + if (nSepiaPercent <= 100) + mnSepiaPercent = nSepiaPercent; + else + mnSepiaPercent = 100; + } + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; + +private: + sal_uInt16 mnSepiaPercent; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapShadowFilter.hxx b/include/vcl/BitmapShadowFilter.hxx new file mode 100644 index 000000000..d4a3207a1 --- /dev/null +++ b/include/vcl/BitmapShadowFilter.hxx @@ -0,0 +1,31 @@ +/* -*- 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/. + * + */ + +#pragma once + +#include <vcl/BitmapFilter.hxx> + +/** If the alpha is beyond a certain threshold, make it fully transparent + */ +class VCL_DLLPUBLIC BitmapShadowFilter final : public BitmapFilter +{ +public: + BitmapShadowFilter(Color aShadowColor) + : maShadowColor(aShadowColor) + { + } + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; + +private: + Color maShadowColor; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapSharpenFilter.hxx b/include/vcl/BitmapSharpenFilter.hxx new file mode 100644 index 000000000..079e1d418 --- /dev/null +++ b/include/vcl/BitmapSharpenFilter.hxx @@ -0,0 +1,24 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_BITMAPSHARPENFILTER_HXX +#define INCLUDED_VCL_BITMAPSHARPENFILTER_HXX + +#include <vcl/BitmapConvolutionMatrixFilter.hxx> + +class VCL_DLLPUBLIC BitmapSharpenFilter final : public BitmapConvolutionMatrixFilter +{ +public: + BitmapSharpenFilter(); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapSimpleColorQuantizationFilter.hxx b/include/vcl/BitmapSimpleColorQuantizationFilter.hxx new file mode 100644 index 000000000..7e306e051 --- /dev/null +++ b/include/vcl/BitmapSimpleColorQuantizationFilter.hxx @@ -0,0 +1,37 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_INCLUDE_VCL_BITMAPSIMPLECOLORQUANTIZATIONFILTER_HXX +#define INCLUDED_INCLUDE_VCL_BITMAPSIMPLECOLORQUANTIZATIONFILTER_HXX + +#include <vcl/BitmapFilter.hxx> + +class VCL_DLLPUBLIC BitmapSimpleColorQuantizationFilter final : public BitmapFilter +{ +public: + /** Reduce number of colors for the bitmap using the POPULAR algorithm + + @param nNewColorCount + Maximal number of bitmap colors after the reduce operation + */ + BitmapSimpleColorQuantizationFilter(sal_uInt16 nNewColorCount) + : mnNewColorCount(nNewColorCount) + { + } + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; + +private: + sal_uInt16 mnNewColorCount; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapSmoothenFilter.hxx b/include/vcl/BitmapSmoothenFilter.hxx new file mode 100644 index 000000000..1a002c960 --- /dev/null +++ b/include/vcl/BitmapSmoothenFilter.hxx @@ -0,0 +1,34 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_BITMAPSMOOTHENFILTER_HXX +#define INCLUDED_VCL_BITMAPSMOOTHENFILTER_HXX + +#include <vcl/BitmapFilter.hxx> + +class BitmapEx; + +class VCL_DLLPUBLIC BitmapSmoothenFilter final : public BitmapFilter +{ +public: + BitmapSmoothenFilter(double fRadius) + : mfRadius(fRadius) + { + } + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; + +private: + double mfRadius; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapSobelGreyFilter.hxx b/include/vcl/BitmapSobelGreyFilter.hxx new file mode 100644 index 000000000..31e56bf5a --- /dev/null +++ b/include/vcl/BitmapSobelGreyFilter.hxx @@ -0,0 +1,26 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_BITMAPSOBELGREYILTER_HXX +#define INCLUDED_VCL_BITMAPSOBELGREYILTER_HXX + +#include <vcl/BitmapFilter.hxx> + +class VCL_DLLPUBLIC BitmapSobelGreyFilter final : public BitmapFilter +{ +public: + BitmapSobelGreyFilter() {} + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapSolarizeFilter.hxx b/include/vcl/BitmapSolarizeFilter.hxx new file mode 100644 index 000000000..f3e36e10f --- /dev/null +++ b/include/vcl/BitmapSolarizeFilter.hxx @@ -0,0 +1,34 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_BITMAPSOLARIZEFILTER_HXX +#define INCLUDED_VCL_BITMAPSOLARIZEFILTER_HXX + +#include <vcl/BitmapFilter.hxx> + +class BitmapEx; + +class VCL_DLLPUBLIC BitmapSolarizeFilter final : public BitmapFilter +{ +public: + BitmapSolarizeFilter(double cSolarGreyThreshold) + : mcSolarGreyThreshold(cSolarGreyThreshold) + { + } + + virtual BitmapEx execute(BitmapEx const& rBitmapEx) const override; + +private: + sal_uInt8 mcSolarGreyThreshold; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/BitmapTools.hxx b/include/vcl/BitmapTools.hxx new file mode 100644 index 000000000..36ccd707a --- /dev/null +++ b/include/vcl/BitmapTools.hxx @@ -0,0 +1,104 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_BITMAP_TOOLS_HXX +#define INCLUDED_VCL_BITMAP_TOOLS_HXX + +#include <config_cairo_canvas.h> +#include <config_wasm_strip.h> + +#include <vcl/bitmapex.hxx> +#include <vcl/ImageTree.hxx> +#if ENABLE_CAIRO_CANVAS +#include <vcl/cairo.hxx> +#endif +#include <basegfx/range/b2drectangle.hxx> +#include <array> +#include <vcl/RawBitmap.hxx> + +class SvStream; +namespace basegfx { class B2DHomMatrix; } +namespace com::sun::star::geometry { struct IntegerRectangle2D; } + +namespace vcl::bitmap { + +#if !ENABLE_WASM_STRIP_PREMULTIPLY +typedef std::array<std::array<sal_uInt8, 256>, 256> lookup_table; + +VCL_DLLPUBLIC lookup_table const & get_premultiply_table(); +VCL_DLLPUBLIC lookup_table const & get_unpremultiply_table(); +#endif + +sal_uInt8 unpremultiply(sal_uInt8 c, sal_uInt8 a); +sal_uInt8 premultiply(sal_uInt8 c, sal_uInt8 a); + +BitmapEx VCL_DLLPUBLIC loadFromName(const OUString& rFileName, const ImageLoadFlags eFlags = ImageLoadFlags::NONE); + +void loadFromSvg(SvStream& rStream, const OUString& sPath, BitmapEx& rBitmapEx, double fScaleFactor); + +/** Copy block of image data into the bitmap. + Assumes that the Bitmap has been constructed with the desired size. + + @param pData + The block of data to copy + @param nStride + The number of bytes in a scanline, must be >= (width * bitcount / 8) +*/ +BitmapEx VCL_DLLPUBLIC CreateFromData(sal_uInt8 const *pData, + sal_Int32 nWidth, sal_Int32 nHeight, sal_Int32 nStride, + vcl::PixelFormat ePixelFormat, + bool bReversColors = false, bool bReverseAlpha = false); + +BitmapEx VCL_DLLPUBLIC CreateFromData( RawBitmap && data ); + +#if ENABLE_CAIRO_CANVAS +VCL_DLLPUBLIC BitmapEx* CreateFromCairoSurface(Size size, cairo_surface_t* pSurface); +#endif + +VCL_DLLPUBLIC BitmapEx CanvasTransformBitmap( const BitmapEx& rBitmap, + const ::basegfx::B2DHomMatrix& rTransform, + ::basegfx::B2DRectangle const & rDestRect, + ::basegfx::B2DHomMatrix const & rLocalTransform ); + +VCL_DLLPUBLIC void DrawAlphaBitmapAndAlphaGradient(BitmapEx & rBitmapEx, bool bFixedTransparence, float fTransparence, AlphaMask & rNewMask); + +VCL_DLLPUBLIC void DrawAndClipBitmap(const Point& rPos, const Size& rSize, const BitmapEx& rBitmap, BitmapEx & aBmpEx, basegfx::B2DPolyPolygon const & rClipPath); + +VCL_DLLPUBLIC css::uno::Sequence< sal_Int8 > GetMaskDIB(BitmapEx const & aBmpEx); + +/** + * @param data will be filled with alpha data, if xBitmap is alpha/transparent image + * @param bHasAlpha will be set to true if resulting surface has alpha + **/ +VCL_DLLPUBLIC void CanvasCairoExtractBitmapData( BitmapEx const & rBmpEx, Bitmap & rBitmap, unsigned char*& data, bool& bHasAlpha, tools::Long& rnWidth, tools::Long& rnHeight ); + +VCL_DLLPUBLIC css::uno::Sequence< sal_Int8 > CanvasExtractBitmapData(BitmapEx const & rBitmapEx, const css::geometry::IntegerRectangle2D& rect); + +// helper to construct historical 8x8 bitmaps with two colors + +BitmapEx VCL_DLLPUBLIC createHistorical8x8FromArray(std::array<sal_uInt8,64> const & pArray, Color aColorPix, Color aColorBack); +bool VCL_DLLPUBLIC isHistorical8x8(const BitmapEx& rBitmapEx, Color& o_rBack, Color& o_rFront); + +VCL_DLLPUBLIC bool convertBitmap32To24Plus8(BitmapEx const & rInput, BitmapEx & rResult); + +/** Retrieve downsampled and cropped bitmap + + Takes destination size in twips units. + + @attention This method ignores negative rDstSz values, thus + mirroring must happen outside this method (e.g. in DrawBitmap) + */ +VCL_DLLPUBLIC Bitmap GetDownsampledBitmap(Size const& rDstSizeTwip, Point const& rSrcPt, Size const& rSrcSz, + Bitmap const& rBmp, tools::Long nMaxBmpDPIX, tools::Long nMaxBmpDPIY); + +} // end vcl::bitmap + +#endif // INCLUDED_VCL_BITMAP_TOOLS_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/ColorMask.hxx b/include/vcl/ColorMask.hxx new file mode 100644 index 000000000..7610aa87e --- /dev/null +++ b/include/vcl/ColorMask.hxx @@ -0,0 +1,193 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_COLORMASK_HXX +#define INCLUDED_VCL_COLORMASK_HXX + +#include <vcl/dllapi.h> +#include <vcl/BitmapColor.hxx> + +#define MASK_TO_COLOR( d_nVal, d_RM, d_GM, d_BM, d_RS, d_GS, d_BS, d_Col ) \ +const sal_uInt8 _def_cR = static_cast<sal_uInt8>( d_RS < 0 ? ( (d_nVal) & d_RM ) << -d_RS : ( (d_nVal) & d_RM ) >> d_RS ); \ +const sal_uInt8 _def_cG = static_cast<sal_uInt8>( d_GS < 0 ? ( (d_nVal) & d_GM ) << -d_GS : ( (d_nVal) & d_GM ) >> d_GS ); \ +const sal_uInt8 _def_cB = static_cast<sal_uInt8>( d_BS < 0 ? ( (d_nVal) & d_BM ) << -d_BS : ( (d_nVal) & d_BM ) >> d_BS ); \ +d_Col = BitmapColor( static_cast<sal_uInt8>( _def_cR | ( ( _def_cR & maR.mnOr ) >> maR.mnOrShift ) ), \ + static_cast<sal_uInt8>( _def_cG | ( ( _def_cG & maG.mnOr ) >> maG.mnOrShift ) ), \ + static_cast<sal_uInt8>( _def_cB | ( ( _def_cB & maB.mnOr ) >> maB.mnOrShift ) ) ); + + +#define COLOR_TO_MASK( d_rCol, d_RM, d_GM, d_BM, d_RS, d_GS, d_BS, d_ALPHA ) \ +( ( ( ( d_RS < 0 ) ? ( static_cast<sal_uInt32>((d_rCol).GetRed()) >> -d_RS ) : \ + ( static_cast<sal_uInt32>((d_rCol).GetRed()) << d_RS ) ) & d_RM ) | \ + ( ( ( d_GS < 0 ) ? ( static_cast<sal_uInt32>((d_rCol).GetGreen()) >> -d_GS ) : \ + ( static_cast<sal_uInt32>((d_rCol).GetGreen()) << d_GS ) ) & d_GM ) | \ + ( ( ( d_BS < 0 ) ? ( static_cast<sal_uInt32>((d_rCol).GetBlue()) >> -d_BS ) : \ + ( static_cast<sal_uInt32>((d_rCol).GetBlue()) << d_BS ) ) & d_BM ) | \ + d_ALPHA ) + + +struct VCL_DLLPUBLIC ColorMaskElement +{ + sal_uInt32 mnMask; + int mnShift; + int mnOrShift; + sal_uInt8 mnOr; + explicit ColorMaskElement(sal_uInt32 nMask = 0) + : mnMask(nMask) + , mnShift(0) + , mnOrShift(0) + , mnOr(0) + { + } + bool CalcMaskShift() + { + if (mnMask == 0) + return true; + + // from which bit starts the mask? + int nShift = 31; + + while( nShift >= 0 && !( mnMask & ( 1 << nShift ) ) ) + --nShift; + + mnShift = nShift - 7; + int nLen = 0; + + // XXX determine number of bits set => walk right until null + while( nShift >= 0 && ( mnMask & ( 1 << nShift ) ) ) + { + nShift--; + nLen++; + } + + if (nLen > 8) // mask length must be 8 bits or less + return false; + + mnOrShift = 8 - nLen; + mnOr = static_cast<sal_uInt8>( ( 0xFF >> nLen ) << mnOrShift ); + + return true; + } +}; + +class VCL_DLLPUBLIC ColorMask +{ + ColorMaskElement maR; + ColorMaskElement maG; + ColorMaskElement maB; + +public: + + ColorMask(const ColorMaskElement& rRedMask = ColorMaskElement(), + const ColorMaskElement& rGreenMask = ColorMaskElement(), + const ColorMaskElement& rBlueMask = ColorMaskElement()) + : maR(rRedMask) + , maG(rGreenMask) + , maB(rBlueMask) + { + } + + inline sal_uInt32 GetRedMask() const; + inline sal_uInt32 GetGreenMask() const; + inline sal_uInt32 GetBlueMask() const; + + inline void GetColorFor16BitMSB( BitmapColor& rColor, const sal_uInt8* pPixel ) const; + inline void SetColorFor16BitMSB( const BitmapColor& rColor, sal_uInt8* pPixel ) const; + inline void GetColorFor16BitLSB( BitmapColor& rColor, const sal_uInt8* pPixel ) const; + inline void SetColorFor16BitLSB( const BitmapColor& rColor, sal_uInt8* pPixel ) const; + + inline void GetColorFor32Bit( BitmapColor& rColor, const sal_uInt8* pPixel ) const; + inline void GetColorAndAlphaFor32Bit( BitmapColor& rColor, sal_uInt8& rAlpha, const sal_uInt8* pPixel ) const; + inline void SetColorFor32Bit( const BitmapColor& rColor, sal_uInt8* pPixel ) const; +}; + +inline sal_uInt32 ColorMask::GetRedMask() const +{ + return maR.mnMask; +} + +inline sal_uInt32 ColorMask::GetGreenMask() const +{ + return maG.mnMask; +} + +inline sal_uInt32 ColorMask::GetBlueMask() const +{ + return maB.mnMask; +} + +inline void ColorMask::GetColorFor16BitMSB( BitmapColor& rColor, const sal_uInt8* pPixel ) const +{ + const sal_uInt32 nVal = pPixel[ 1 ] | ( static_cast<sal_uInt32>(pPixel[ 0 ]) << 8 ); + + MASK_TO_COLOR( nVal, maR.mnMask, maG.mnMask, maB.mnMask, maR.mnShift, maG.mnShift, maB.mnShift, rColor ); +} + +inline void ColorMask::SetColorFor16BitMSB( const BitmapColor& rColor, sal_uInt8* pPixel ) const +{ + const sal_uInt16 nVal = static_cast<sal_uInt16>(COLOR_TO_MASK( rColor, maR.mnMask, maG.mnMask, maB.mnMask, maR.mnShift, maG.mnShift, maB.mnShift, 0/*nAlphaChannel*/ )); + + pPixel[ 0 ] = static_cast<sal_uInt8>(nVal >> 8); + pPixel[ 1 ] = static_cast<sal_uInt8>(nVal); +} + +inline void ColorMask::GetColorFor16BitLSB( BitmapColor& rColor, const sal_uInt8* pPixel ) const +{ + const sal_uInt32 nVal = pPixel[ 0 ] | ( static_cast<sal_uInt32>(pPixel[ 1 ]) << 8 ); + + MASK_TO_COLOR( nVal, maR.mnMask, maG.mnMask, maB.mnMask, maR.mnShift, maG.mnShift, maB.mnShift, rColor ); +} + +inline void ColorMask::SetColorFor16BitLSB( const BitmapColor& rColor, sal_uInt8* pPixel ) const +{ + const sal_uInt16 nVal = static_cast<sal_uInt16>(COLOR_TO_MASK( rColor, maR.mnMask, maG.mnMask, maB.mnMask, maR.mnShift, maG.mnShift, maB.mnShift, 0/*nAlphaChannel*/ )); + + pPixel[ 0 ] = static_cast<sal_uInt8>(nVal); + pPixel[ 1 ] = static_cast<sal_uInt8>(nVal >> 8); +} + +inline void ColorMask::GetColorFor32Bit( BitmapColor& rColor, const sal_uInt8* pPixel ) const +{ + const sal_uInt32 nVal = static_cast<sal_uInt32>(pPixel[ 0 ]) | ( static_cast<sal_uInt32>(pPixel[ 1 ]) << 8 ) | + ( static_cast<sal_uInt32>(pPixel[ 2 ]) << 16 ) | ( static_cast<sal_uInt32>(pPixel[ 3 ]) << 24 ); + + MASK_TO_COLOR( nVal, maR.mnMask, maG.mnMask, maB.mnMask, maR.mnShift, maG.mnShift, maB.mnShift, rColor ); +} + +inline void ColorMask::GetColorAndAlphaFor32Bit( BitmapColor& rColor, sal_uInt8& rAlpha, const sal_uInt8* pPixel ) const +{ + const sal_uInt32 nVal = static_cast<sal_uInt32>(pPixel[ 0 ]) | ( static_cast<sal_uInt32>(pPixel[ 1 ]) << 8 ) | + ( static_cast<sal_uInt32>(pPixel[ 2 ]) << 16 ) | ( static_cast<sal_uInt32>(pPixel[ 3 ]) << 24 ); + rAlpha = static_cast<sal_uInt8>(nVal >> 24); + + MASK_TO_COLOR( nVal, maR.mnMask, maG.mnMask, maB.mnMask, maR.mnShift, maG.mnShift, maB.mnShift, rColor ); +} + +inline void ColorMask::SetColorFor32Bit( const BitmapColor& rColor, sal_uInt8* pPixel ) const +{ + const sal_uInt32 nVal = COLOR_TO_MASK( rColor, maR.mnMask, maG.mnMask, maB.mnMask, maR.mnShift, maG.mnShift, maB.mnShift, 0/*nAlphaChannel*/ ); + pPixel[ 0 ] = static_cast<sal_uInt8>(nVal); + pPixel[ 1 ] = static_cast<sal_uInt8>( nVal >> 8 ); + pPixel[ 2 ] = static_cast<sal_uInt8>( nVal >> 16 ); + pPixel[ 3 ] = static_cast<sal_uInt8>( nVal >> 24 ); +} + +#endif // INCLUDED_VCL_COLORMASK_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/EnumContext.hxx b/include/vcl/EnumContext.hxx new file mode 100644 index 000000000..9d82e72ad --- /dev/null +++ b/include/vcl/EnumContext.hxx @@ -0,0 +1,167 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_VCL_ENUMCONTEXT_HXX +#define INCLUDED_VCL_ENUMCONTEXT_HXX + +#include <vcl/dllapi.h> + +#include <rtl/ustring.hxx> + + +namespace vcl { + +class VCL_DLLPUBLIC EnumContext +{ +public: + enum class Application + { + Writer, + WriterGlobal, + WriterWeb, + WriterXML, + WriterForm, + WriterReport, + Calc, + Chart, + Draw, + Impress, + Formula, + Base, + + // For your convenience to avoid duplicate code in the common + // case that Draw and Impress use identical context configurations. + DrawImpress, + + // Also for your convenience for the different variants of Writer documents. + WriterVariants, + + // Used only by deck or panel descriptors. Matches any + // application. + Any, + + // Use this only in special circumstances. One might be the + // wish to disable a deck or panel during debugging. + NONE, + + LAST = Application::NONE + }; + enum class Context + { + ThreeDObject, + Annotation, + Auditing, + Axis, + Cell, + Chart, + ChartElements, + Draw, + DrawFontwork, + DrawLine, + DrawPage, + DrawText, + EditCell, + ErrorBar, + Form, + Frame, + Graphic, + Grid, + HandoutPage, + MasterPage, + Math, + Media, + MultiObject, + NotesPage, + OLE, + OutlineText, + Pivot, + Printpreview, + Series, + SlidesorterPage, + Table, + Text, + TextObject, + Trendline, + Sparkline, + + // Default context of an application. Do we need this? + Default, + + // Used only by deck or panel descriptors. Matches any context. + Any, + + // Special context name that is only used when a deck would + // otherwise be empty. + Empty, + + Unknown, + + LAST = Unknown + }; + + EnumContext(); + EnumContext ( + const Application eApplication, + const Context eContext); + + /** This variant of the GetCombinedContext() method treats some + application names as identical to each other. Replacements + made are: + Draw or Impress -> DrawImpress + Writer or WriterWeb -> WriterAndWeb + Use the Application::DrawImpress or Application::WriterAndWeb values in the CombinedEnumContext macro. + */ + sal_Int32 GetCombinedContext_DI() const; + + Application GetApplication_DI() const; + + bool operator == (const EnumContext& rOther) const; + bool operator != (const EnumContext& rOther) const; + + /** When two contexts are matched against each other, then + application or context name may have the wildcard value 'any'. + In order to prefer matches without wildcards over matches with + wildcards we introduce an integer evaluation for matches. + */ + const static sal_Int32 NoMatch; + + static Application GetApplicationEnum (const OUString& rsApplicationName); + static const OUString& GetApplicationName (const Application eApplication); + + static Context GetContextEnum (const OUString& rsContextName); + static const OUString& GetContextName (const Context eContext); + +private: + Application meApplication; + Context meContext; + + static void ProvideApplicationContainers(); + static void ProvideContextContainers(); + static void AddEntry (const OUString& rsName, const Application eApplication); + static void AddEntry (const OUString& rsName, const Context eContext); +}; + + +#define CombinedEnumContext(a,e) ((static_cast<sal_uInt16>(::vcl::EnumContext::a)<<16)\ + | static_cast<sal_uInt16>(::vcl::EnumContext::e)) + +} // end of namespace vcl + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/FilterConfigItem.hxx b/include/vcl/FilterConfigItem.hxx new file mode 100644 index 000000000..45692fedb --- /dev/null +++ b/include/vcl/FilterConfigItem.hxx @@ -0,0 +1,94 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + + +#ifndef INCLUDED_VCL_FILTERCONFIGITEM_HXX +#define INCLUDED_VCL_FILTERCONFIGITEM_HXX + +#include <sal/config.h> + +#include <string_view> + +#include <vcl/dllapi.h> + +#include <rtl/ustring.hxx> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/uno/Reference.h> +#include <com/sun/star/uno/Sequence.hxx> + +namespace com::sun::star::beans { class XPropertySet; } +namespace com::sun::star::task { class XStatusIndicator; } +namespace com::sun::star::uno { class Any; } +namespace com::sun::star::uno { class XInterface; } + +class VCL_DLLPUBLIC FilterConfigItem +{ + css::uno::Reference< css::uno::XInterface > xUpdatableView; + css::uno::Reference< css::beans::XPropertySet > xPropSet; + css::uno::Sequence< css::beans::PropertyValue > aFilterData; + + bool bModified; + + static bool ImplGetPropertyValue( css::uno::Any& rAny, + const css::uno::Reference< css::beans::XPropertySet >& rXPropSet, + const OUString& rPropName ); + + void ImpInitTree( std::u16string_view rTree ); + + + static const css::beans::PropertyValue* GetPropertyValue( + const css::uno::Sequence< css::beans::PropertyValue >& rPropSeq, + const OUString& rName ); + static bool WritePropertyValue( + css::uno::Sequence< css::beans::PropertyValue >& rPropSeq, + const css::beans::PropertyValue& rPropValue ); + +public: + + FilterConfigItem( std::u16string_view rSubTree ); + FilterConfigItem( css::uno::Sequence< css::beans::PropertyValue > const * pFilterData ); + FilterConfigItem( std::u16string_view rSubTree, css::uno::Sequence< css::beans::PropertyValue > const * pFilterData ); + /// Writes config in destructor + ~FilterConfigItem(); + /// Writes config and sets unmodified state again. + void WriteModifiedConfig(); + + // all read methods are trying to return values in following order: + // 1. FilterData PropertySequence + // 2. configuration + // 3. given default + bool ReadBool( const OUString& rKey, bool bDefault ); + sal_Int32 ReadInt32( const OUString& rKey, sal_Int32 nDefault ); + OUString + ReadString( const OUString& rKey, const OUString& rDefault ); + + // try to store to configuration + // and always stores into the FilterData sequence + void WriteBool( const OUString& rKey, bool bValue ); + void WriteInt32( const OUString& rKey, sal_Int32 nValue ); + + const css::uno::Sequence< css::beans::PropertyValue >& GetFilterData() const { return aFilterData;} + + // GetStatusIndicator is returning the "StatusIndicator" property of the FilterData sequence + css::uno::Reference< css::task::XStatusIndicator > GetStatusIndicator() const; +}; + +#endif // INCLUDED_VCL_FILTERCONFIGITEM_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/GestureEvent.hxx b/include/vcl/GestureEvent.hxx new file mode 100644 index 000000000..7b6f25719 --- /dev/null +++ b/include/vcl/GestureEvent.hxx @@ -0,0 +1,61 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_GESTUREEVENT_HXX +#define INCLUDED_VCL_GESTUREEVENT_HXX + +#include <vcl/dllapi.h> + +enum class GestureEventType +{ + PanningBegin, + PanningUpdate, + PanningEnd +}; + +enum class PanningOrientation +{ + Horizontal, + Vertical +}; + +class VCL_DLLPUBLIC GestureEvent +{ +public: + sal_Int32 mnX; + sal_Int32 mnY; + GestureEventType meEventType; + + sal_Int32 mnOffset; + PanningOrientation meOrientation; + + GestureEvent() + : mnX(0) + , mnY(0) + , meEventType(GestureEventType::PanningBegin) + , mnOffset(0) + , meOrientation(PanningOrientation::Horizontal) + { + } + + GestureEvent(sal_Int32 nX, sal_Int32 nY, GestureEventType eEventType, sal_Int32 nOffset, + PanningOrientation eOrientation) + : mnX(nX) + , mnY(nY) + , meEventType(eEventType) + , mnOffset(nOffset) + , meOrientation(eOrientation) + { + } +}; + +#endif // INCLUDED_VCL_GESTUREEVENT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/GraphicAttributes.hxx b/include/vcl/GraphicAttributes.hxx new file mode 100644 index 000000000..442158cda --- /dev/null +++ b/include/vcl/GraphicAttributes.hxx @@ -0,0 +1,148 @@ +/* -*- 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 . + */ + +#pragma once + +#include <tools/degree.hxx> +#include <vcl/dllapi.h> +#include <vcl/bitmap.hxx> + +enum class GraphicDrawMode +{ + Standard = 0, + Greys = 1, + Mono = 2, + Watermark = 3 +}; + +class VCL_DLLPUBLIC GraphicAttr +{ +private: + double mfGamma; + tools::Long mnLeftCrop; + tools::Long mnTopCrop; + tools::Long mnRightCrop; + tools::Long mnBottomCrop; + BmpMirrorFlags mnMirrFlags; + GraphicDrawMode meDrawMode; + Degree10 mnRotate10; + short mnContPercent; + short mnLumPercent; + short mnRPercent; + short mnGPercent; + short mnBPercent; + sal_uInt8 mcAlpha; + bool mbInvert; + +public: + GraphicAttr() + : mfGamma(1.0) + , mnLeftCrop(0) + , mnTopCrop(0) + , mnRightCrop(0) + , mnBottomCrop(0) + , mnMirrFlags(BmpMirrorFlags::NONE) + , meDrawMode(GraphicDrawMode::Standard) + , mnRotate10(0) + , mnContPercent(0) + , mnLumPercent(0) + , mnRPercent(0) + , mnGPercent(0) + , mnBPercent(0) + , mcAlpha(255) + , mbInvert(false) + { + } + + bool operator==(const GraphicAttr& rAttr) const + { + return mfGamma == rAttr.mfGamma && mnMirrFlags == rAttr.mnMirrFlags + && mnLeftCrop == rAttr.mnLeftCrop && mnTopCrop == rAttr.mnTopCrop + && mnRightCrop == rAttr.mnRightCrop && mnBottomCrop == rAttr.mnBottomCrop + && mnRotate10 == rAttr.mnRotate10 && mnContPercent == rAttr.mnContPercent + && mnLumPercent == rAttr.mnLumPercent && mnRPercent == rAttr.mnRPercent + && mnGPercent == rAttr.mnGPercent && mnBPercent == rAttr.mnBPercent + && mbInvert == rAttr.mbInvert && mcAlpha == rAttr.mcAlpha + && meDrawMode == rAttr.meDrawMode; + } + + bool operator!=(const GraphicAttr& rAttr) const { return !(*this == rAttr); } + + void SetDrawMode(GraphicDrawMode eDrawMode) { meDrawMode = eDrawMode; } + GraphicDrawMode GetDrawMode() const { return meDrawMode; } + + void SetMirrorFlags(BmpMirrorFlags nMirrFlags) { mnMirrFlags = nMirrFlags; } + BmpMirrorFlags GetMirrorFlags() const { return mnMirrFlags; } + + void SetCrop(tools::Long nLeft_100TH_MM, tools::Long nTop_100TH_MM, tools::Long nRight_100TH_MM, + tools::Long nBottom_100TH_MM) + { + mnLeftCrop = nLeft_100TH_MM; + mnTopCrop = nTop_100TH_MM; + mnRightCrop = nRight_100TH_MM; + mnBottomCrop = nBottom_100TH_MM; + } + tools::Long GetLeftCrop() const { return mnLeftCrop; } + tools::Long GetTopCrop() const { return mnTopCrop; } + tools::Long GetRightCrop() const { return mnRightCrop; } + tools::Long GetBottomCrop() const { return mnBottomCrop; } + + void SetRotation(Degree10 nRotate10) { mnRotate10 = nRotate10; } + Degree10 GetRotation() const { return mnRotate10; } + + void SetLuminance(short nLuminancePercent) { mnLumPercent = nLuminancePercent; } + short GetLuminance() const { return mnLumPercent; } + + void SetContrast(short nContrastPercent) { mnContPercent = nContrastPercent; } + short GetContrast() const { return mnContPercent; } + + void SetChannelR(short nChannelRPercent) { mnRPercent = nChannelRPercent; } + short GetChannelR() const { return mnRPercent; } + + void SetChannelG(short nChannelGPercent) { mnGPercent = nChannelGPercent; } + short GetChannelG() const { return mnGPercent; } + + void SetChannelB(short nChannelBPercent) { mnBPercent = nChannelBPercent; } + short GetChannelB() const { return mnBPercent; } + + void SetGamma(double fGamma) { mfGamma = fGamma; } + double GetGamma() const { return mfGamma; } + + void SetInvert(bool bInvert) { mbInvert = bInvert; } + bool IsInvert() const { return mbInvert; } + + void SetAlpha(sal_uInt8 cAlpha) { mcAlpha = cAlpha; } + sal_uInt8 GetAlpha() const { return mcAlpha; } + + bool IsSpecialDrawMode() const { return (meDrawMode != GraphicDrawMode::Standard); } + bool IsMirrored() const { return mnMirrFlags != BmpMirrorFlags::NONE; } + bool IsCropped() const + { + return (mnLeftCrop != 0 || mnTopCrop != 0 || mnRightCrop != 0 || mnBottomCrop != 0); + } + bool IsRotated() const { return ((mnRotate10 % 3600_deg10) != 0_deg10); } + bool IsTransparent() const { return (mcAlpha < 255); } + bool IsAdjusted() const + { + return (mnLumPercent != 0 || mnContPercent != 0 || mnRPercent != 0 || mnGPercent != 0 + || mnBPercent != 0 || mfGamma != 1.0 || mbInvert); + } +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/GraphicExternalLink.hxx b/include/vcl/GraphicExternalLink.hxx new file mode 100644 index 000000000..ab9f2a69f --- /dev/null +++ b/include/vcl/GraphicExternalLink.hxx @@ -0,0 +1,31 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_GRAPHIC_EXTERNAL_LINK_HXX +#define INCLUDED_VCL_GRAPHIC_EXTERNAL_LINK_HXX + +#include <vcl/dllapi.h> +#include <rtl/ustring.hxx> + +class VCL_DLLPUBLIC GraphicExternalLink +{ +public: + OUString msURL; + + GraphicExternalLink() {} + + GraphicExternalLink(OUString const& rURL) + : msURL(rURL) + { + } +}; + +#endif // INCLUDED_VCL_GRAPHIC_EXTERNAL_LINK_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/GraphicLoader.hxx b/include/vcl/GraphicLoader.hxx new file mode 100644 index 000000000..d99c54731 --- /dev/null +++ b/include/vcl/GraphicLoader.hxx @@ -0,0 +1,27 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_GRAPHIC_LOADER_HXX +#define INCLUDED_VCL_GRAPHIC_LOADER_HXX + +#include <vcl/graph.hxx> + +namespace weld +{ +class Window; +} + +namespace vcl::graphic +{ +Graphic VCL_DLLPUBLIC loadFromURL(OUString const& rURL, weld::Window* pParentWin = nullptr); +} // end vcl::graphic + +#endif // INCLUDED_VCL_GRAPHIC_TOOLS_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/GraphicNativeMetadata.hxx b/include/vcl/GraphicNativeMetadata.hxx new file mode 100644 index 000000000..7ef2adee8 --- /dev/null +++ b/include/vcl/GraphicNativeMetadata.hxx @@ -0,0 +1,40 @@ +/* -*- 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 . + */ + +#pragma once + +#include <vcl/graph.hxx> +#include <tools/stream.hxx> +#include <tools/degree.hxx> + +class VCL_DLLPUBLIC GraphicNativeMetadata final +{ + Degree10 mRotation; + +public: + GraphicNativeMetadata(); + + bool read(Graphic const& rGraphic); + bool read(SvStream& rStream); + + // counter-clock-wise rotation 10ths of a degree + Degree10 getRotation() const { return mRotation; } +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/GraphicNativeTransform.hxx b/include/vcl/GraphicNativeTransform.hxx new file mode 100644 index 000000000..2f82aa158 --- /dev/null +++ b/include/vcl/GraphicNativeTransform.hxx @@ -0,0 +1,43 @@ +/* -*- 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 . + */ + +#pragma once + +#include <tools/degree.hxx> +#include <vcl/dllapi.h> + +#include <string_view> + +class Graphic; + +class VCL_DLLPUBLIC GraphicNativeTransform final +{ + Graphic& mrGraphic; + + bool rotateBitmapOnly(Degree10 aRotation); + void rotateJPEG(Degree10 aRotation); + bool rotateGeneric(Degree10 aRotation, std::u16string_view aType); + +public: + GraphicNativeTransform(Graphic& rGraphic); + + void rotate(Degree10 aRotation); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/GraphicObject.hxx b/include/vcl/GraphicObject.hxx new file mode 100644 index 000000000..7ebaa274e --- /dev/null +++ b/include/vcl/GraphicObject.hxx @@ -0,0 +1,302 @@ +/* -*- 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 . + */ + +#pragma once + +#include <memory> +#include <string_view> +#include <vcl/graph.hxx> +#include <vcl/dllapi.h> +#include <o3tl/typed_flags_set.hxx> + +#include <vcl/GraphicAttributes.hxx> + +namespace com::sun::star::graphic { class XGraphic; } + +// Adjustment defines +enum class GraphicAdjustmentFlags +{ + NONE = 0x00, + DRAWMODE = 0x01, + COLORS = 0x02, + MIRROR = 0x04, + ROTATE = 0x08, + TRANSPARENCY = 0x10, + ALL = 0x1f, +}; +namespace o3tl +{ + template<> struct typed_flags<GraphicAdjustmentFlags> : is_typed_flags<GraphicAdjustmentFlags, 0x1f> {}; +} + +class VirtualDevice; +struct GrfSimpleCacheObj; +struct ImplTileInfo; + +class VCL_DLLPUBLIC GraphicObject +{ + friend class SdrGrafObj; + +private: + Graphic maGraphic; + GraphicAttr maAttr; + OUString maUserData; + std::unique_ptr<GrfSimpleCacheObj> mxSimpleCache; + + bool VCL_DLLPRIVATE ImplGetCropParams( + const OutputDevice& rOut, + Point& rPt, + Size& rSz, + const GraphicAttr* pAttr, + tools::PolyPolygon& rClipPolyPoly, + bool& bRectClipRegion + ) const; + + /** Render a given number of tiles in an optimized way + + This method recursively subdivides the tile rendering problem + in smaller parts, i.e. rendering output size x with few tiles + of size y, which in turn are generated from the original + bitmap in a recursive fashion. The subdivision size can be + controlled by the exponent argument, which specifies the + minimal number of smaller tiles used in one recursion + step. The resulting tile size is given as the integer number + of repetitions of the original bitmap along x and y. As the + exponent need not necessarily divide these numbers without + remainder, the repetition counts are effectively converted to + base-exponent numbers, where each place denotes the number of + times the corresponding tile size is rendered. + + @param rVDev + Virtual device to render everything into + + @param nNumTilesX + Number of original tiles to generate in x direction + + @param nNumTilesY + Number of original tiles to generate in y direction + + @param rTileSizePixel + Size in pixel of the original tile bitmap to render it in + + @param pAttr + Graphic attributes to be used for rendering + + @param nFlags + Graphic flags to be used for rendering + + @param rCurrPos + Current output point for this recursion level (should start with (0,0)) + + @return true, if everything was successfully rendered. + */ + bool VCL_DLLPRIVATE ImplRenderTempTile( + VirtualDevice& rVDev, + int nNumTilesX, + int nNumTilesY, + const Size& rTileSizePixel, + const GraphicAttr* pAttr + ); + + /// internally called by ImplRenderTempTile() + bool VCL_DLLPRIVATE ImplRenderTileRecursive( + VirtualDevice& rVDev, + int nExponent, + int nMSBFactor, + int nNumOrigTilesX, + int nNumOrigTilesY, + int nRemainderTilesX, + int nRemainderTilesY, + const Size& rTileSizePixel, + const GraphicAttr* pAttr, + ImplTileInfo& rTileInfo + ); + + bool VCL_DLLPRIVATE ImplDrawTiled( + OutputDevice& rOut, + const tools::Rectangle& rArea, + const Size& rSizePixel, + const Size& rOffset, + const GraphicAttr* pAttr, + int nTileCacheSize1D + ); + + bool VCL_DLLPRIVATE ImplDrawTiled( + OutputDevice& rOut, + const Point& rPos, + int nNumTilesX, + int nNumTilesY, + const Size& rTileSize, + const GraphicAttr* pAttr + ) const; + + void VCL_DLLPRIVATE ImplTransformBitmap( + BitmapEx& rBmpEx, + const GraphicAttr& rAttr, + const Size& rCropLeftTop, + const Size& rCropRightBottom, + const tools::Rectangle& rCropRect, + const Size& rDstSize, + bool bEnlarge + ) const; + +public: + GraphicObject(); + GraphicObject( const Graphic& rGraphic ); + GraphicObject( const GraphicObject& rCacheObj ); + ~GraphicObject(); + + GraphicObject& operator=( const GraphicObject& rCacheObj ); + bool operator==( const GraphicObject& rCacheObj ) const; + bool operator!=( const GraphicObject& rCacheObj ) const { return !( *this == rCacheObj ); } + + const Graphic& GetGraphic() const; + void SetGraphic( const Graphic& rGraphic); + + /** Get graphic transformed according to given attributes + + This method returns a Graphic transformed, cropped and scaled + to the given parameters, ready to be rendered to printer or + display. The returned graphic has the same visual appearance + as if it had been drawn via GraphicObject::Draw() to a + specific output device. + + @param rDestSize + Desired output size in logical coordinates. The mapmode to + interpret these logical coordinates in is given by the second + parameter, rDestMap. + + @param rDestMap + Mapmode the output should be interpreted in. This is used to + interpret rDestSize, to set the appropriate PrefMapMode on the + returned Graphic, and to deal correctly with metafile graphics. + + @param rAttr + Graphic attributes used to transform the graphic. This + includes cropping, rotation, mirroring, and various color + adjustment parameters. + + @return the readily transformed Graphic + */ + Graphic GetTransformedGraphic( + const Size& rDestSize, + const MapMode& rDestMap, + const GraphicAttr& rAttr + ) const; + Graphic GetTransformedGraphic( const GraphicAttr* pAttr ) const; // TODO: Change to Impl + + void SetAttr( const GraphicAttr& rAttr ); + const GraphicAttr& GetAttr() const { return maAttr; } + + bool HasUserData() const { return !maUserData.isEmpty(); } + void SetUserData(); + void SetUserData( const OUString& rUserData ); + const OUString& GetUserData() const { return maUserData; } + + OString GetUniqueID() const; + + GraphicType GetType() const; + Size GetPrefSize() const; + MapMode GetPrefMapMode() const; + bool IsTransparent() const; + bool IsAnimated() const; + bool IsEPS() const; + + bool Draw(OutputDevice& rOut, + const Point& rPt, + const Size& rSz, + const GraphicAttr* pAttr = nullptr) const; + + /** Draw the graphic repeatedly into the given output rectangle + + @param pOut + OutputDevice where the rendering should take place + + @param rArea + The output area that is filled with tiled instances of this graphic + + @param rSize + The actual size of a single tile + + @param rOffset + Offset from the left, top position of rArea, where to start + the tiling. The upper left corner of the graphic tilings will + virtually start at this position. Concretely, only that many + tiles are drawn to completely fill the given output area. + + @param nFlags + Optional rendering flags + + @param nTileCacheSize1D + Optional dimension of the generated cache tiles. The pOut sees + a number of tile draws, which have approximately + nTileCacheSize1D times nTileCacheSize1D bitmap sizes if the + tile bitmap is smaller. Otherwise, the tile is drawn as + is. This is useful if e.g. you want only a few, very large + bitmap drawings appear on the outdev. + */ + void DrawTiled( + OutputDevice& rOut, + const tools::Rectangle& rArea, + const Size& rSize, + const Size& rOffset, + int nTileCacheSize1D=128 + ); + + bool StartAnimation( + OutputDevice& rOut, + const Point& rPt, + const Size& rSz, + tools::Long nExtraData = 0, + OutputDevice* pFirstFrameOutDev = nullptr + ); + + void StopAnimation( const OutputDevice* pOut = nullptr, tools::Long nExtraData = 0 ); + + static bool isGraphicObjectUniqueIdURL(std::u16string_view rURL); + + // create CropScaling information + // fWidth, fHeight: object size + // f*Crop: crop values relative to original bitmap size + basegfx::B2DVector calculateCropScaling( + double fWidth, + double fHeight, + double fLeftCrop, + double fTopCrop, + double fRightCrop, + double fBottomCrop) const; +}; + +namespace vcl::graphic +{ + +// Will search an object ( e.g. a control ) for any 'ImageURL' or 'Graphic' +// properties and return graphics from the properties in a vector. ImageURL +// will be loaded from the URL. +// +// Note: this implementation will cater for XNameContainer objects and deep inspect any containers +// if they exist + +VCL_DLLPUBLIC void SearchForGraphics(css::uno::Reference<css::uno::XInterface> const & rxInterface, + std::vector<css::uno::Reference<css::graphic::XGraphic>> & raGraphicList); + + +} // end namespace vcl::graphic + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/IContext.hxx b/include/vcl/IContext.hxx new file mode 100644 index 000000000..d595d8771 --- /dev/null +++ b/include/vcl/IContext.hxx @@ -0,0 +1,44 @@ +/* -*- 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/. + */ + +#pragma once + +#include <vcl/EnumContext.hxx> +#include <vector> + +#include <algorithm> + +namespace vcl +{ +class VCL_DLLPUBLIC IContext +{ +protected: + IContext() { maContext.push_back(vcl::EnumContext::Context::Any); } + +public: + void SetContext(std::vector<vcl::EnumContext::Context>&& aContext) + { + maContext = std::move(aContext); + } + + bool HasContext(const vcl::EnumContext::Context eContext) const + { + auto aFind = std::find(maContext.begin(), maContext.end(), eContext); + if (aFind == maContext.end()) + return false; + return true; + } + +private: + std::vector<vcl::EnumContext::Context> maContext; +}; + +} // namespace vcl + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/IDialogRenderable.hxx b/include/vcl/IDialogRenderable.hxx new file mode 100644 index 000000000..68a573574 --- /dev/null +++ b/include/vcl/IDialogRenderable.hxx @@ -0,0 +1,47 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_IDIALOGRENDERABLE_HXX +#define INCLUDED_VCL_IDIALOGRENDERABLE_HXX + +#include <config_options.h> +#include <vcl/dllapi.h> + +#include <rtl/ustring.hxx> + +#include <vector> + +class SfxItemSet; + +namespace vcl +{ + +typedef std::pair<const OString, const OString> LOKPayloadItem; + +typedef sal_uInt32 LOKWindowId; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) ILibreOfficeKitNotifier +{ +public: + virtual ~ILibreOfficeKitNotifier(); + + /// Callbacks + virtual void notifyWindow(vcl::LOKWindowId nLOKWindowId, + const OUString& rAction, + const std::vector<LOKPayloadItem>& rPayload = std::vector<LOKPayloadItem>()) const = 0; + + virtual void libreOfficeKitViewCallback(int nType, const char* pPayload) const = 0; +}; + +} // namespace vcl + +#endif // INCLUDED_VCL_IDIALOGRENDERABLE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/ITiledRenderable.hxx b/include/vcl/ITiledRenderable.hxx new file mode 100644 index 000000000..1bddde538 --- /dev/null +++ b/include/vcl/ITiledRenderable.hxx @@ -0,0 +1,348 @@ +/* -*- 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/. + * + */ + +#pragma once + +#include <tools/gen.hxx> +#include <rtl/ustring.hxx> +#include <vcl/dllapi.h> +#include <vcl/ptrstyle.hxx> +#include <vcl/vclptr.hxx> +#include <map> +#include <com/sun/star/datatransfer/XTransferable.hpp> +#include <basegfx/range/b2drange.hxx> + +namespace com::sun::star::beans { struct PropertyValue; } +namespace com::sun::star::datatransfer::clipboard { class XClipboard; } +namespace com::sun::star::uno { template <class interface_type> class Reference; } +namespace com::sun::star::uno { template <typename > class Sequence; } +namespace vcl { class Window; } +namespace tools { class JsonWriter; } + +class VirtualDevice; + +namespace vcl +{ + /* + * Map directly to css cursor styles to avoid further mapping in the client. + * Gtk (via gdk_cursor_new_from_name) also supports the same css cursor styles. + * + * This was created partially with help of the mappings in gtkdata.cxx. + * The list is incomplete as some cursor style simply aren't supported + * by css, it might turn out to be worth mapping some of these missing cursors + * to available cursors? + */ + extern const std::map <PointerStyle, OString> gaLOKPointerMap; + + +class VCL_DLLPUBLIC ITiledRenderable +{ +public: + + typedef std::map<OUString, OUString> StringMap; + + virtual ~ITiledRenderable(); + + /** + * Paint a tile to a given VirtualDevice. + * + * Output parameters are measured in pixels, tile parameters are in + * twips. + */ + virtual void paintTile( VirtualDevice &rDevice, + int nOutputWidth, + int nOutputHeight, + int nTilePosX, + int nTilePosY, + tools::Long nTileWidth, + tools::Long nTileHeight ) = 0; + + /** + * Get the document size in twips. + */ + virtual Size getDocumentSize() = 0; + + /** + * Set the document "part", i.e. slide for a slideshow, and + * tab for a spreadsheet. + * bool bAllowChangeFocus - used to not disturb other users while editing when + * setPart is used for tile rendering only + */ + virtual void setPart( int /*nPart*/, bool /*bAllowChangeFocus*/ = true ) {} + + /** + * Get the number of parts -- see setPart for further details. + */ + virtual int getParts() + { + return 1; + } + + /** + * Get the currently displayed/selected part -- see setPart for further + * details. + */ + virtual int getPart() + { + return 0; + } + + /** + * Get the name of the currently displayed part, i.e. sheet in a spreadsheet + * or slide in a presentation. + */ + virtual OUString getPartName(int) + { + return OUString(); + } + + /** + * Get the vcl::Window for the document being edited + */ + virtual VclPtr<vcl::Window> getDocWindow() = 0; + + /** + * Get the hash of the currently displayed part, i.e. sheet in a spreadsheet + * or slide in a presentation. + */ + virtual OUString getPartHash(int nPart) = 0; + + /// @see lok::Document::setPartMode(). + virtual void setPartMode(int) {} + + /** + * Setup various document properties that are needed for the document to + * be renderable via tiled rendering. + */ + virtual void initializeForTiledRendering(const css::uno::Sequence<css::beans::PropertyValue>& rArguments) = 0; + + /** + * Posts a keyboard event on the document. + * + * @see lok::Document::postKeyEvent(). + */ + virtual void postKeyEvent(int nType, int nCharCode, int nKeyCode) = 0; + + /** + * Posts a mouse event on the document. + * + * @see lok::Document::postMouseEvent(). + */ + virtual void postMouseEvent(int nType, int nX, int nY, int nCount, int nButtons, int nModifier) = 0; + + /** + * Sets the start or end of a text selection. + * + * @see lok::Document::setTextSelection(). + */ + virtual void setTextSelection(int nType, int nX, int nY) = 0; + + /** + * Gets the selection as a transferable for later processing + */ + virtual css::uno::Reference<css::datatransfer::XTransferable> getSelection() = 0; + + /** + * Adjusts the graphic selection. + * + * @see lok::Document::setGraphicSelection(). + */ + virtual void setGraphicSelection(int nType, int nX, int nY) = 0; + + /** + * @see lok::Document::resetSelection(). + */ + virtual void resetSelection() = 0; + + /** + * @see lok::Document::getPartPageRectangles(). + */ + virtual OUString getPartPageRectangles() + { + return OUString(); + } + + /** + * Get position and content of row/column headers of Calc documents. + * + * @param rRectangle - if not empty, then limit the output only to the area of this rectangle + * @return a JSON describing position/content of rows/columns + */ + virtual void getRowColumnHeaders(const tools::Rectangle& /*rRectangle*/, tools::JsonWriter& /*rJsonWriter*/) + { + } + + /** + * Generates a serialization of the active (Calc document) sheet's geometry data. + * + * @param bColumns - if true, the column widths/hidden/filtered/groups data + * are included depending on the settings of the flags bSizes, bHidden, + * bFiltered and bGroups. + * @param bRows - if true, the row heights/hidden/filtered/groups data + * are included depending on the settings of the flags bSizes, bHidden, + * bFiltered and bGroups. + * @bSizes - if true, the column-widths and/or row-heights data (represented as a list of spans) + * are included depending on the settings of the flags bColumns and bRows. + * @bHidden - if true, the hidden columns and/or rows data (represented as a list of spans) + * are included depending on the settings of the flags bColumns and bRows. + * @bFiltered - if true, the filtered columns and/or rows data (represented as a list of spans) + * are included depending on the settings of the flags bColumns and bRows. + * @bGroups - if true, the column grouping and/or row grouping data + * are included depending on the settings of the flags bColumns and bRows. + * @return serialization of the active sheet's geometry data as OString. + */ + virtual OString getSheetGeometryData(bool /*bColumns*/, bool /*bRows*/, bool /*bSizes*/, + bool /*bHidden*/, bool /*bFiltered*/, bool /*bGroups*/) + { + return ""; + } + + /** + * Get position and size of cell cursor in Calc - as JSON in the + * current' views' co-ordinate system. + * (This could maybe also be used for tables in Writer/Impress in future?) + */ + virtual void getCellCursor(tools::JsonWriter& /*rJsonWriter*/) + { + } + + virtual PointerStyle getPointer() = 0; + + /// Sets the clipboard of the component. + virtual void setClipboard(const css::uno::Reference<css::datatransfer::clipboard::XClipboard>& xClipboard) = 0; + + /// If the current contents of the clipboard is something we can paste. + virtual bool isMimeTypeSupported() = 0; + + /** + * Save the client's view so that we can compute the right zoom level + * for the mouse events. + * @param nTilePixelWidth - tile width in pixels + * @param nTilePixelHeight - tile height in pixels + * @param nTileTwipWidth - tile width in twips + * @param nTileTwipHeight - tile height in twips + */ + virtual void setClientZoom(int /*nTilePixelWidth*/, + int /*nTilePixelHeight*/, + int /*nTileTwipWidth*/, + int /*nTileTwipHeight*/) + {} + + /// @see lok::Document::setClientVisibleArea(). + virtual void setClientVisibleArea(const tools::Rectangle& /*rRectangle*/) + { + } + + /** + * Show/Hide a single row/column header outline for Calc documents. + * + * @param bColumn - if we are dealing with a column or row group + * @param nLevel - the level to which the group belongs + * @param nIndex - the group entry index + * @param bHidden - the new group state (collapsed/expanded) + */ + virtual void setOutlineState(bool /*bColumn*/, int /*nLevel*/, int /*nIndex*/, bool /*bHidden*/) + { + return; + } + + /// Implementation for + /// lok::Document::getCommandValues(".uno:AcceptTrackedChanges") when there + /// is no matching UNO API. + virtual void getTrackedChanges(tools::JsonWriter&) + { + } + + /// Implementation for + /// lok::Document::getCommandValues(".uno:TrackedChangeAuthors"). + virtual void getTrackedChangeAuthors(tools::JsonWriter& /*rJsonWriter*/) + { + } + + /// Implementation for + /// lok::Document::getCommandValues(".uno:ViewAnnotations"); + virtual void getPostIts(tools::JsonWriter& /*rJsonWriter*/) + { + } + + /// Implementation for + /// lok::Document::getCommandValues(".uno:ViewAnnotationsPosition"); + virtual void getPostItsPos(tools::JsonWriter& /*rJsonWriter*/) + { + } + + /// Implementation for + /// lok::Document::getCommandValues(".uno:RulerState"); + virtual void getRulerState(tools::JsonWriter& /*rJsonWriter*/) + { + } + + /* + * Used for sheets in spreadsheet documents, + * and slides in presentation documents. + */ + virtual OUString getPartInfo(int /*nPart*/) + { + return OUString(); + } + + /** + * Select/Unselect a document "part", i.e. slide for a slideshow, and + * tab for a spreadsheet(?). + * nSelect: 0 to deselect, 1 to select, and 2 to toggle. + */ + virtual void selectPart(int /*nPart*/, int /*nSelect*/) {} + + /** + * Move selected pages/slides to a new position. + * nPosition: the new position to move to. + * bDuplicate: to copy (true), or to move (false). + */ + virtual void moveSelectedParts(int /*nPosition*/, bool /*bDuplicate*/) {} + + /// @see lok::Document::completeFunction(). + virtual void completeFunction(const OUString& /*rFunctionName*/) + { + } + + /** + * It can happen that the underlying implementation is being disposed, but + * somebody is trying to access the data... + */ + virtual bool isDisposed() const + { + return false; + } + + /** + * Execute a form field event in the document. + * E.g. select an item from a drop down field's list. + */ + virtual void executeFromFieldEvent(const StringMap&) + { + } + + /** + * Returns the rectangles of the input search result JSON + */ + virtual std::vector<basegfx::B2DRange> getSearchResultRectangles(const char* /*pPayload*/) + { + return std::vector<basegfx::B2DRange>(); + } + + /** + * Execute a content control event in the document. + * E.g. select a list item from a drop down content control. + */ + virtual void executeContentControlEvent(const StringMap&) {} +}; +} // namespace vcl + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/IconThemeInfo.hxx b/include/vcl/IconThemeInfo.hxx new file mode 100644 index 000000000..0ac2b7dc2 --- /dev/null +++ b/include/vcl/IconThemeInfo.hxx @@ -0,0 +1,98 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_ICONTHEMEINFO_HXX +#define INCLUDED_VCL_ICONTHEMEINFO_HXX + +#include <vcl/dllapi.h> +#include <tools/gen.hxx> +#include <rtl/ustring.hxx> + +#include <vector> + +// forward declaration of unit test classes. Required for friend relationship. +class IconThemeInfoTest; +class IconThemeSelectorTest; +class IconThemeScannerTest; + +namespace vcl +{ +/** This class provides information about an icon theme. + */ +class VCL_DLLPUBLIC IconThemeInfo +{ +public: + /** The name of the icon theme to use for high contrast mode */ + static constexpr OUStringLiteral HIGH_CONTRAST_ID_BRIGHT = u"sifr"; + static constexpr OUStringLiteral HIGH_CONTRAST_ID_DARK = u"sifr_dark"; + + /** Construct an IconThemeInfo from the URL to a file. + * This method will throw a std::runtime_error if the URL cannot be properly parsed. + * Check the URL with UrlCanBeParsed() first. + */ + IconThemeInfo(const OUString& urlToFile); + + const OUString& GetDisplayName() const { return mDisplayName; } + + const OUString& GetThemeId() const { return mThemeId; } + + const OUString& GetUrlToFile() const { return mUrlToFile; } + + /** Obtain the icon size by theme name. + * @internal + * It is not clear where this information belongs to. The sizes were hard-coded before they moved here. + * Maybe there is a way to determine the sizes from the icon theme packages. + */ + static Size SizeByThemeName(std::u16string_view); + + /** Check whether an IconThemeInfo can be constructed from a URL */ + static bool UrlCanBeParsed(std::u16string_view url); + + /** Find an icon theme by its id in a vector. + * Throws a runtime_error if the theme is not contained in the vector + */ + static const vcl::IconThemeInfo& + FindIconThemeById(const std::vector<vcl::IconThemeInfo>& themes, const OUString& themeId); + + /** Check whether a theme with a specified id is in a vector of IconThemeInfo */ + static bool IconThemeIsInVector(const std::vector<vcl::IconThemeInfo>& themes, + const OUString& themeId); + +private: + /** private constructor for testing purposes only */ + IconThemeInfo(); + + /** Determine the icon theme name from the filename + * If the name has an underscore, the name is taken from the first underscore to the last dot, + * e.g., images_oxygen.zip becomes oxygen + * If the name does not have an underscore in it, the whole name until the last dot is returned, + * e.g. default.zip becomes default + */ + static OUString FileNameToThemeId(std::u16string_view); + + /** Creates the display name for the given id of a file. + * Currently, we only uppercase the id. + */ + static OUString ThemeIdToDisplayName(const OUString&); + + /** The name which is presented to the user */ + OUString mDisplayName; + /** The theme id. This id is used in ... to determine the file name */ + OUString mThemeId; + /** The url to the icon theme package */ + OUString mUrlToFile; + + friend class ::IconThemeInfoTest; + friend class ::IconThemeScannerTest; + friend class ::IconThemeSelectorTest; +}; + +} // namespace vcl + +#endif // INCLUDED_VCL_ICONTHEMEINFO_HXX diff --git a/include/vcl/ImageTree.hxx b/include/vcl/ImageTree.hxx new file mode 100644 index 000000000..4de20d74e --- /dev/null +++ b/include/vcl/ImageTree.hxx @@ -0,0 +1,95 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_INCLUDE_VCL_IMAGETREE_HXX +#define INCLUDED_INCLUDE_VCL_IMAGETREE_HXX + +#include <memory> +#include <sal/config.h> +#include <vcl/dllapi.h> +#include <rtl/ustring.hxx> +#include <o3tl/typed_flags_set.hxx> + +namespace com::sun::star::uno { template <class interface_type> class Reference; } + +enum class ImageLoadFlags : sal_uInt16 +{ + NONE = 0, + IgnoreScalingFactor = 1, + IgnoreDarkTheme = 2, +}; + +namespace o3tl { +template<> struct typed_flags<ImageLoadFlags>: is_typed_flags<ImageLoadFlags, 0x3> {}; +} + +namespace com::sun::star::container { + class XNameAccess; +} + +namespace com::sun::star::io { + class XInputStream; +} + +class ImplImageTree; +class BitmapEx; +class SvMemoryStream; + +class ImageTree +{ +private: + std::unique_ptr<ImplImageTree> mpImplImageTree; + +public: + ImageTree(); + + VCL_DLLPUBLIC static ImageTree & get(); + + VCL_DLLPUBLIC OUString getImageUrl( + OUString const & name, OUString const & style, OUString const & lang); + + VCL_DLLPUBLIC std::shared_ptr<SvMemoryStream> getImageStream( + OUString const & rName, OUString const & rStyle, OUString const & rLang); + + VCL_DLLPUBLIC css::uno::Reference<css::io::XInputStream> getImageXInputStream(OUString const & rName, + OUString const & rStyle, OUString const & rLang); + + VCL_DLLPUBLIC bool loadImage( + OUString const & name, OUString const & style, + BitmapEx & bitmap, bool localized, + const ImageLoadFlags eFlags = ImageLoadFlags::NONE); + + VCL_DLLPUBLIC bool loadImage( + OUString const & name, OUString const & style, + BitmapEx & bitmap, bool localized, + sal_Int32 nScalePercentage, + const ImageLoadFlags eFlags = ImageLoadFlags::NONE); + + VCL_DLLPUBLIC css::uno::Reference<css::container::XNameAccess> const & getNameAccess(); + + + /** a crude form of life cycle control (called from DeInitVCL; otherwise, + * if the ImplImageTree singleton were destroyed during exit that would + * be too late for the destructors of the bitmaps in maIconCache)*/ + VCL_DLLPUBLIC void shutdown(); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/InterimItemWindow.hxx b/include/vcl/InterimItemWindow.hxx new file mode 100644 index 000000000..4cf4dd4eb --- /dev/null +++ b/include/vcl/InterimItemWindow.hxx @@ -0,0 +1,76 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#pragma once + +#include <vcl/dllapi.h> +#include <vcl/ctrl.hxx> +#include <vcl/idle.hxx> +#include <vcl/weld.hxx> + +class VCL_DLLPUBLIC InterimItemWindow : public Control +{ +public: + virtual ~InterimItemWindow() override; + virtual void dispose() override; + + virtual void Resize() override; + virtual Size GetOptimalSize() const override; + // throw away cached size request of child so GetOptimalSize will + // fetch it anew + void InvalidateChildSizeCache(); + virtual void StateChanged(StateChangedType nStateChange) override; + virtual void queue_resize(StateChangedType eReason = StateChangedType::Layout) override; + virtual void GetFocus() override; + + bool ControlHasFocus() const; + + virtual void Draw(OutputDevice* pDevice, const Point& rPos, + SystemTextColorFlags nFlags) override; + +protected: + // bAllowCycleFocusOut of true allows focus to be moved out of the Control + // via tab key into a parent window or sibling window, false means focus + // remains inside the InterimItemWindow and cycles back to the first child + // of this control on reaching pass the last child. This is suitable when + // the Control is the toplevel control and has no siblings or parent + InterimItemWindow(vcl::Window* pParent, const OUString& rUIXMLDescription, const OString& rID, + bool bAllowCycleFocusOut = true, sal_uInt64 nLOKWindowId = 0); + + void InitControlBase(weld::Widget* pWidget); + + // pass keystrokes from our child window through this to handle focus changes correctly + // returns true if keystroke is consumed + bool ChildKeyInput(const KeyEvent& rKEvt); + + virtual void Layout(); + + // unclip a "SysObj" which is a native window element hosted in a vcl::Window + // if the SysObj is logically "visible" in the vcl::Window::IsVisible sense but + // is partially or wholly clipped out due to being overlapped or scrolled out + // of view. The clip state is flagged as dirty after this and vcl will restore + // the clip state the next time it evaluates the clip status + void UnclipVisibleSysObj(); + + std::unique_ptr<weld::Builder> m_xBuilder; + VclPtr<vcl::Window> m_xVclContentArea; + std::unique_ptr<weld::Container> m_xContainer; + weld::Widget* m_pWidget; + +private: + Idle m_aLayoutIdle; + + void StartIdleLayout(); + + DECL_DLLPRIVATE_LINK(DoLayout, Timer*, void); + + virtual void ImplPaintToDevice(::OutputDevice* pTargetOutDev, const Point& rPos) override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/NotebookbarContextControl.hxx b/include/vcl/NotebookbarContextControl.hxx new file mode 100644 index 000000000..adb6178e5 --- /dev/null +++ b/include/vcl/NotebookbarContextControl.hxx @@ -0,0 +1,24 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_NOTEBOOKBARCONTEXTCONTROL_HXX +#define INCLUDED_VCL_NOTEBOOKBARCONTEXTCONTROL_HXX + +#include <vcl/EnumContext.hxx> + +class NotebookbarContextControl +{ +public: + virtual ~NotebookbarContextControl() {} + virtual void SetContext(vcl::EnumContext::Context eContext) = 0; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/PrinterSupport.hxx b/include/vcl/PrinterSupport.hxx new file mode 100644 index 000000000..bde01fa19 --- /dev/null +++ b/include/vcl/PrinterSupport.hxx @@ -0,0 +1,34 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_PRINTERSUPPORT_HXX +#define INCLUDED_VCL_PRINTERSUPPORT_HXX + +enum class PrinterSupport +{ + SetOrientation, + SetPaperSize, + SetPaper, + CollateCopy, + SetupDialog +}; + +#endif // INCLUDED_VCL_PRINTERSUPPORT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/QueueInfo.hxx b/include/vcl/QueueInfo.hxx new file mode 100644 index 000000000..a011e125e --- /dev/null +++ b/include/vcl/QueueInfo.hxx @@ -0,0 +1,55 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_QUEUEINFO_HXX +#define INCLUDED_VCL_QUEUEINFO_HXX + +#include <rtl/ustring.hxx> + +#include <vcl/dllapi.h> +#include <vcl/prntypes.hxx> + +class Printer; + +class VCL_DLLPUBLIC QueueInfo +{ + friend class Printer; + +private: + OUString maPrinterName; + OUString maDriver; + OUString maLocation; + OUString maComment; + PrintQueueFlags mnStatus; + sal_uInt32 mnJobs; + +public: + QueueInfo(); + + const OUString& GetPrinterName() const; + const OUString& GetDriver() const; + const OUString& GetLocation() const; + const OUString& GetComment() const; + PrintQueueFlags GetStatus() const; + sal_uInt32 GetJobs() const; +}; + +#endif // INCLUDED_VCL_QUEUEINFO_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/RawBitmap.hxx b/include/vcl/RawBitmap.hxx new file mode 100644 index 000000000..12c924dbb --- /dev/null +++ b/include/vcl/RawBitmap.hxx @@ -0,0 +1,79 @@ +/* -*- 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/. + */ + +#pragma once + +#include <o3tl/safeint.hxx> +#include <vcl/BitmapColor.hxx> +#include <vcl/bitmapex.hxx> + +namespace vcl::bitmap +{ +/** + * Intended to be used to feed into CreateFromData to create a BitmapEx. RGB data format. + */ +class VCL_DLLPUBLIC RawBitmap +{ + friend BitmapEx VCL_DLLPUBLIC CreateFromData(RawBitmap&& rawBitmap); + std::unique_ptr<sal_uInt8[]> mpData; + Size maSize; + sal_uInt8 mnBitCount; + +public: + RawBitmap(Size const& rSize, sal_uInt8 nBitCount) + : maSize(rSize) + , mnBitCount(nBitCount) + { + assert(nBitCount == 24 || nBitCount == 32); + if (rSize.getWidth() > std::numeric_limits<sal_Int32>::max() || rSize.getWidth() < 0) + throw std::bad_alloc(); + if (rSize.getHeight() > std::numeric_limits<sal_Int32>::max() || rSize.getHeight() < 0) + throw std::bad_alloc(); + sal_Int32 nRowSize, nDataSize; + if (o3tl::checked_multiply<sal_Int32>(rSize.getWidth(), nBitCount / 8, nRowSize) + || o3tl::checked_multiply<sal_Int32>(nRowSize, rSize.getHeight(), nDataSize) + || nDataSize < 0) + { + throw std::bad_alloc(); + } + mpData.reset(new sal_uInt8[nDataSize]); + } + void SetPixel(tools::Long nY, tools::Long nX, Color nColor) + { + tools::Long p = (nY * maSize.getWidth() + nX) * (mnBitCount / 8); + mpData[p++] = nColor.GetRed(); + mpData[p++] = nColor.GetGreen(); + mpData[p++] = nColor.GetBlue(); + if (mnBitCount == 32) + mpData[p] = nColor.GetAlpha(); + } + void SetAlpha(tools::Long nY, tools::Long nX, sal_uInt8 nAlpha) + { + assert(mnBitCount == 32); + tools::Long p = (nY * maSize.getWidth() + nX) * (mnBitCount / 8) + 3; + mpData[p] = nAlpha; + } + Color GetPixel(tools::Long nY, tools::Long nX) const + { + tools::Long p = (nY * maSize.getWidth() + nX) * mnBitCount / 8; + if (mnBitCount == 24) + return Color(mpData[p], mpData[p + 1], mpData[p + 2]); + else + return Color(ColorAlpha, mpData[p + 3], mpData[p], mpData[p + 1], mpData[p + 2]); + } + // so we don't accidentally leave any code in that uses palette color indexes + void SetPixel(tools::Long nY, tools::Long nX, BitmapColor nColor) = delete; + tools::Long Height() const { return maSize.Height(); } + tools::Long Width() const { return maSize.Width(); } + sal_uInt8 GetBitCount() const { return mnBitCount; } +}; + +} // end vcl::bitmap + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/Scanline.hxx b/include/vcl/Scanline.hxx new file mode 100644 index 000000000..be33bc232 --- /dev/null +++ b/include/vcl/Scanline.hxx @@ -0,0 +1,61 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_SCANLINE_HXX +#define INCLUDED_VCL_SCANLINE_HXX + +#include <o3tl/typed_flags_set.hxx> +#include <sal/types.h> + +typedef sal_uInt8* Scanline; +typedef const sal_uInt8* ConstScanline; + +enum class ScanlineFormat { + NONE = 0x00000000, + + N1BitMsbPal = 0x00000001, + N1BitLsbPal = 0x00000002, + + N8BitPal = 0x00000010, + + N24BitTcBgr = 0x00000100, + N24BitTcRgb = 0x00000200, + + N32BitTcAbgr = 0x00000800, + N32BitTcArgb = 0x00001000, + N32BitTcBgra = 0x00002000, + N32BitTcRgba = 0x00004000, + N32BitTcMask = 0x00008000, + + TopDown = 0x00010000 // scanline adjustment +}; + +namespace o3tl +{ + template<> struct typed_flags<ScanlineFormat> : is_typed_flags<ScanlineFormat, 0x0001fb13> {}; +} + +inline ScanlineFormat RemoveScanline(ScanlineFormat nFormat) +{ + return nFormat & ~ScanlineFormat::TopDown; +} + +#endif // INCLUDED_VCL_SCANLINE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/TaskStopwatch.hxx b/include/vcl/TaskStopwatch.hxx new file mode 100644 index 000000000..b27b3a316 --- /dev/null +++ b/include/vcl/TaskStopwatch.hxx @@ -0,0 +1,117 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_TASK_STOPWATCH_HXX +#define INCLUDED_VCL_TASK_STOPWATCH_HXX + +#include <tools/time.hxx> +#include <vcl/dllapi.h> +#include <vcl/inputtypes.hxx> +#include <vcl/svapp.hxx> + +/** + * Helper class primary used to track time of long running iterating tasks. + * + * Normally it should be sufficient to instantiate the watch object before + * starting the iteration and query continueIter() at the end of each. + * + * Called Stopwatch, because there is already a Timer class in the Scheduler. + * + * TODO: merge into the general Scheduler, so this can also be used to track + * Task runtimes in a more general way. + * TODO: handle fast iterations, where continueIter is called multiple times + * per tick, by counting the iterations per tick and use that for approximation. + **/ +class VCL_DLLPUBLIC TaskStopwatch +{ + static constexpr VclInputFlags eDefaultInputStop = VCL_INPUT_ANY & ~VclInputFlags::TIMER; + static constexpr unsigned int nDefaultTimeSlice = 50; + static unsigned int m_nTimeSlice; + + sal_uInt64 m_nStartTicks; + sal_uInt64 m_nIterStartTicks; + bool m_bConsiderLastIterTime; + VclInputFlags m_eInputStop; + + bool nextIter() + { + sal_uInt64 nCurTicks = tools::Time::GetSystemTicks(); + // handle system ticks wrap as exceeded time slice + if (nCurTicks < m_nStartTicks) + return false; + + if (m_bConsiderLastIterTime) + { + // based on the last iter runtime, we don't expect to finish in time + // m_nTimeSlice < (nCurTicks - m_nStartTicks) + (nCurTicks - m_nIterStartTicks) + if (m_nTimeSlice < 2 * nCurTicks - m_nIterStartTicks - m_nStartTicks) + return false; + } + // time slice exceeded + else if (m_nTimeSlice < nCurTicks - m_nStartTicks) + return false; + + m_nIterStartTicks = nCurTicks; + + return !Application::AnyInput(m_eInputStop); + } + +public: + /** + * Per default the watch considers the last iter time when asking for an + * other iteration, so considers Scheduler::acceptableTaskTime as a + * maximum value. + * + * If you already know your iter time vary in a large range, consider + * setting bConciderLastIterTime to false, so Scheduler::acceptableTaskTime + * will be used as a minimum time slot. + **/ + TaskStopwatch(bool bConciderLastIterTime = true) + : m_nStartTicks(tools::Time::GetSystemTicks()) + , m_nIterStartTicks(m_nStartTicks) + , m_bConsiderLastIterTime(bConciderLastIterTime) + , m_eInputStop(eDefaultInputStop) + { + } + + /** + * Returns true, if another iteration will probably pass in the time slot + **/ + bool continueIter() { return nextIter(); } + + /** + * Reset the stopwatch + **/ + void reset() + { + m_nStartTicks = tools::Time::GetSystemTicks(); + m_nIterStartTicks = m_nStartTicks; + } + + /** + * Sets the input events, which should also "exceed" the stopwatch. + * + * Per default this ignores the VclInputFlags::TIMER. + */ + void setInputStop(VclInputFlags eInputStop = eDefaultInputStop) { m_eInputStop = eInputStop; } + VclInputFlags inputStop() const { return m_eInputStop; } + + /** + * Sets the time considered the acceptable maximum for a task to run + * + * This is an orientation for long time background jobs to yield to + * the scheduler, so Idle task don't starve each other too much. + **/ + static unsigned int timeSlice() { return m_nTimeSlice; } + static void setTimeSlice(unsigned int nTimeSlice) { m_nTimeSlice = nTimeSlice; } +}; + +#endif // INCLUDED_VCL_TASK_STOPWATCH_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/TypeSerializer.hxx b/include/vcl/TypeSerializer.hxx new file mode 100644 index 000000000..e85b25b1c --- /dev/null +++ b/include/vcl/TypeSerializer.hxx @@ -0,0 +1,60 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_INC_TYPESERIALIZER_HXX +#define INCLUDED_VCL_INC_TYPESERIALIZER_HXX + +#include <vcl/dllapi.h> +#include <tools/GenericTypeSerializer.hxx> +#include <vcl/gradient.hxx> +#include <vcl/gfxlink.hxx> +#include <vcl/graph.hxx> + +constexpr sal_uInt32 createMagic(char char1, char char2, char char3, char char4) +{ + return (static_cast<sal_uInt32>(char1) << 24) | (static_cast<sal_uInt32>(char2) << 16) + | (static_cast<sal_uInt32>(char3) << 8) | (static_cast<sal_uInt32>(char4) << 0); +} + +constexpr sal_uInt32 constSvgMagic = createMagic('s', 'v', 'g', '0'); +constexpr sal_uInt32 constWmfMagic = createMagic('w', 'm', 'f', '0'); +constexpr sal_uInt32 constEmfMagic = createMagic('e', 'm', 'f', '0'); +constexpr sal_uInt32 constPdfMagic = createMagic('p', 'd', 'f', '0'); + +class VCL_DLLPUBLIC TypeSerializer : public tools::GenericTypeSerializer +{ +public: + TypeSerializer(SvStream& rStream); + + void readGradient(Gradient& rGradient); + void writeGradient(const Gradient& rGradient); + + void readGfxLink(GfxLink& rGfxLink); + void writeGfxLink(const GfxLink& rGfxLink); + + void readGraphic(Graphic& rGraphic); + void writeGraphic(const Graphic& rGraphic); + + void readMapMode(MapMode& rMapMode); + void writeMapMode(MapMode const& rMapMode); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/VectorGraphicSearch.hxx b/include/vcl/VectorGraphicSearch.hxx new file mode 100644 index 000000000..4601a1f5a --- /dev/null +++ b/include/vcl/VectorGraphicSearch.hxx @@ -0,0 +1,71 @@ +/* -*- 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/. + * + */ + +#pragma once + +#include <vcl/graph.hxx> +#include <vcl/vectorgraphicdata.hxx> +#include <vcl/dllapi.h> + +#include <basegfx/range/b2drectangle.hxx> +#include <basegfx/vector/b2dsize.hxx> + +#include <memory> + +enum class SearchStartPosition +{ + Begin, + End +}; + +struct VCL_DLLPUBLIC VectorGraphicSearchOptions final +{ + SearchStartPosition meStartPosition; + bool mbMatchCase; + bool mbMatchWholeWord; + + VectorGraphicSearchOptions() + : meStartPosition(SearchStartPosition::Begin) + , mbMatchCase(false) + , mbMatchWholeWord(false) + { + } + + VectorGraphicSearchOptions(SearchStartPosition eStartPosition, bool bMatchCase, + bool bMatchWholeWord) + : meStartPosition(eStartPosition) + , mbMatchCase(bMatchCase) + , mbMatchWholeWord(bMatchWholeWord) + { + } +}; + +class VCL_DLLPUBLIC VectorGraphicSearch final +{ +private: + class Implementation; + std::unique_ptr<Implementation> mpImplementation; + Graphic maGraphic; + + bool searchPDF(std::shared_ptr<VectorGraphicData> const& rData); + +public: + VectorGraphicSearch(Graphic const& rGraphic); + ~VectorGraphicSearch(); + bool search(OUString const& rSearchString, + VectorGraphicSearchOptions const& rOptions = VectorGraphicSearchOptions()); + basegfx::B2DSize pageSize(); + bool next(); + bool previous(); + int index(); + std::vector<basegfx::B2DRectangle> getTextRectangles(); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/WeldedTabbedNotebookbar.hxx b/include/vcl/WeldedTabbedNotebookbar.hxx new file mode 100644 index 000000000..073902f2d --- /dev/null +++ b/include/vcl/WeldedTabbedNotebookbar.hxx @@ -0,0 +1,36 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_SFX2_NOTEBOOKBAR_WRITERTABBEDNOTEBOOKBAR_HXX +#define INCLUDED_SFX2_NOTEBOOKBAR_WRITERTABBEDNOTEBOOKBAR_HXX + +#include <vcl/dllapi.h> +#include <rtl/ustring.hxx> +#include <vcl/weld.hxx> +#include <com/sun/star/frame/XFrame.hpp> + +/** + * Welded wrapper for NotebookBar used for online +*/ +class VCL_DLLPUBLIC WeldedTabbedNotebookbar +{ + std::unique_ptr<weld::Builder> m_xBuilder; + + std::unique_ptr<weld::Container> m_xContainer; + +public: + WeldedTabbedNotebookbar(const VclPtr<vcl::Window>& pContainerWindow, + const OUString& rUIFilePath, + const css::uno::Reference<css::frame::XFrame>& rFrame, + sal_uInt64 nWindowId); +}; + +#endif // INCLUDED_SFX2_NOTEBOOKBAR_SFXNOTEBOOKBAR_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/abstdlg.hxx b/include/vcl/abstdlg.hxx new file mode 100644 index 000000000..79b2b32a9 --- /dev/null +++ b/include/vcl/abstdlg.hxx @@ -0,0 +1,193 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_VCL_ABSTDLG_HXX +#define INCLUDED_VCL_ABSTDLG_HXX + +#include <sal/types.h> +#include <rtl/ustring.hxx> +#include <vcl/dllapi.h> +#include <vcl/vclptr.hxx> +#include <vcl/vclreferencebase.hxx> +#include <vector> +#include <functional> +#include <memory> + +namespace com::sun::star::uno { template <class interface_type> class Reference; } + +namespace com::sun::star::frame { class XModel; } + +class Dialog; +class BitmapEx; +class SdrObjGroup; +namespace weld +{ + class Dialog; + class DialogController; + class Window; +} + +/** +* Some things multiple-inherit from VclAbstractDialog and OutputDevice, +* so we need to use virtual inheritance to keep the referencing counting +* OK. +*/ +class VCL_DLLPUBLIC VclAbstractDialog : public virtual VclReferenceBase +{ +protected: + virtual ~VclAbstractDialog() override; +public: + virtual short Execute() = 0; + + struct AsyncContext { + // for the case where the owner is the dialog itself, and the dialog is an unwelded VclPtr based dialog + VclPtr<VclReferenceBase> mxOwner; + // for the case where the dialog is welded, and owned by a DialogController + std::shared_ptr<weld::DialogController> mxOwnerDialogController; + // for the case where the dialog is welded, and is running async without a DialogController + std::shared_ptr<weld::Dialog> mxOwnerSelf; + std::function<void(sal_Int32)> maEndDialogFn; + bool isSet() const { return !!maEndDialogFn; } + }; + + bool StartExecuteAsync(const std::function<void(sal_Int32)> &rEndDialogFn) + { + AsyncContext aCtx; + aCtx.mxOwner = this; + aCtx.maEndDialogFn = rEndDialogFn; + return StartExecuteAsync(aCtx); + } + + /// Commence execution of a modal dialog. + virtual bool StartExecuteAsync(AsyncContext &); + + // Screenshot interface + virtual std::vector<OString> getAllPageUIXMLDescriptions() const; + virtual bool selectPageByUIXMLDescription(const OString& rUIXMLDescription); + virtual BitmapEx createScreenshot() const; + virtual OString GetScreenshotId() const { return OString(); }; +}; + +class VCL_DLLPUBLIC VclAbstractTerminatedDialog : public VclAbstractDialog +{ +protected: + virtual ~VclAbstractTerminatedDialog() override = default; +public: + virtual void EndDialog(sal_Int32 nResult) = 0; +}; + +class VCL_DLLPUBLIC AbstractPasswordToOpenModifyDialog : public VclAbstractDialog +{ +protected: + virtual ~AbstractPasswordToOpenModifyDialog() override = default; +public: + virtual OUString GetPasswordToOpen() const = 0; + virtual OUString GetPasswordToModify() const = 0; + virtual bool IsRecommendToOpenReadonly() const = 0; +}; + +class VCL_DLLPUBLIC AbstractScreenshotAnnotationDlg : public VclAbstractDialog +{ +protected: + virtual ~AbstractScreenshotAnnotationDlg() override = default; +}; + +class VCL_DLLPUBLIC AbstractSignatureLineDialog : public VclAbstractDialog +{ +protected: + virtual ~AbstractSignatureLineDialog() override = default; +}; + +class VCL_DLLPUBLIC AbstractSignSignatureLineDialog : public VclAbstractDialog +{ +protected: + virtual ~AbstractSignSignatureLineDialog() override = default; +}; + +class VCL_DLLPUBLIC AbstractQrCodeGenDialog : public VclAbstractDialog +{ +protected: + virtual ~AbstractQrCodeGenDialog() override = default; +}; + +class VCL_DLLPUBLIC AbstractAdditionsDialog : public VclAbstractDialog +{ +protected: + virtual ~AbstractAdditionsDialog() override = default; +}; + +/** Edit Diagram dialog */ +class VCL_DLLPUBLIC AbstractDiagramDialog : public VclAbstractDialog +{ +protected: + virtual ~AbstractDiagramDialog() override = default; +}; + +class VCL_DLLPUBLIC VclAbstractDialogFactory +{ +public: + virtual ~VclAbstractDialogFactory(); // needed for export of vtable + static VclAbstractDialogFactory* Create(); + // The Id is an implementation detail of the factory + virtual VclPtr<VclAbstractDialog> CreateVclDialog(weld::Window* pParent, sal_uInt32 nId) = 0; + + // creates instance of PasswordToOpenModifyDialog from cui + virtual VclPtr<AbstractPasswordToOpenModifyDialog> CreatePasswordToOpenModifyDialog(weld::Window * pParent, sal_uInt16 nMaxPasswdLen, bool bIsPasswordToModify) = 0; + + // creates instance of SignatureDialog from cui + virtual VclPtr<AbstractSignatureLineDialog> + CreateSignatureLineDialog(weld::Window* pParent, + const css::uno::Reference<css::frame::XModel> xModel, + bool bEditExisting) + = 0; + + // creates instance of SignSignatureDialog from cui + virtual VclPtr<AbstractSignSignatureLineDialog> + CreateSignSignatureLineDialog(weld::Window* pParent, + const css::uno::Reference<css::frame::XModel> xModel) + = 0; + + // creates instance of QrCodeDialog from cui + virtual VclPtr<AbstractQrCodeGenDialog> + CreateQrCodeGenDialog(weld::Window* pParent, + const css::uno::Reference<css::frame::XModel> xModel, + bool bEditExisting) + = 0; + + // creates instance of ScreenshotAnnotationDlg from cui + virtual VclPtr<AbstractScreenshotAnnotationDlg> CreateScreenshotAnnotationDlg( + weld::Dialog& rParentDialog) = 0; + + // create additions dialog + virtual VclPtr<AbstractAdditionsDialog> + CreateAdditionsDialog(weld::Window* pParent, const OUString& sAdditionsTag) = 0; + + virtual VclPtr<AbstractDiagramDialog> CreateDiagramDialog( + weld::Window* pParent, + SdrObjGroup& rDiagram) = 0; + +#ifdef _WIN32 + virtual VclPtr<VclAbstractDialog> + CreateFileExtCheckDialog(weld::Window* _pParent, const OUString& sTitle, const OUString& sMsg) + = 0; +#endif +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/accessiblefactory.hxx b/include/vcl/accessiblefactory.hxx new file mode 100644 index 000000000..a13e4dabc --- /dev/null +++ b/include/vcl/accessiblefactory.hxx @@ -0,0 +1,173 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_ACCESSIBLEFACTORY_HXX +#define INCLUDED_VCL_ACCESSIBLEFACTORY_HXX + +#include <vcl/AccessibleBrowseBoxObjType.hxx> + +#include <com/sun/star/uno/Reference.hxx> + +#include <salhelper/simplereferenceobject.hxx> +#include <tools/gen.hxx> + +namespace com::sun::star { + namespace accessibility { + class XAccessible; + class XAccessibleContext; + } + namespace awt { + class XWindow; + } +} + +namespace vcl { class IAccessibleBrowseBox; } +namespace vcl { class IAccessibleTabListBox; } +namespace vcl { class IAccessibleTableProvider; } + +class SvHeaderTabListBox; +class SvtIconChoiceCtrl; +class TabBar; +class SvTreeListBox; +class VCLXWindow; +class TextEngine; +class TextView; + +namespace vcl +{ + namespace table + { + class IAccessibleTable; + class IAccessibleTableControl; + } + + /** a function which is able to create a factory for the standard Accessible/Context + components needed for standard toolkit controls + + The returned pointer denotes an instance of the IAccessibleFactory, which has been acquired + <em>once</em>. The caller is responsible for holding this reference as long as it needs the + factory, and release it afterwards. + */ + typedef void* (* GetSvtAccessibilityComponentFactory)( ); + + + //= IAccessibleFactory + + class IAccessibleFactory : public virtual ::salhelper::SimpleReferenceObject + { + public: + virtual vcl::IAccessibleTabListBox* + createAccessibleTabListBox( + const css::uno::Reference< css::accessibility::XAccessible >& rxParent, + SvHeaderTabListBox& rBox + ) const = 0; + virtual css::uno::Reference< css::accessibility::XAccessible > + createAccessibleTreeListBox( + SvTreeListBox& _rListBox, + const css::uno::Reference< css::accessibility::XAccessible >& _xParent + ) const = 0; + virtual css::uno::Reference< css::accessibility::XAccessible > + createAccessibleIconView( + SvTreeListBox& _rListBox, + const css::uno::Reference< css::accessibility::XAccessible >& _xParent + ) const = 0; + virtual vcl::IAccessibleBrowseBox* + createAccessibleBrowseBox( + const css::uno::Reference< css::accessibility::XAccessible >& _rxParent, + vcl::IAccessibleTableProvider& _rBrowseBox + ) const = 0; + virtual table::IAccessibleTableControl* + createAccessibleTableControl( + const css::uno::Reference< css::accessibility::XAccessible >& _rxParent, + table::IAccessibleTable& _rTable + ) const = 0; + + virtual css::uno::Reference< css::accessibility::XAccessible > + createAccessibleIconChoiceCtrl( + SvtIconChoiceCtrl& _rIconCtrl, + const css::uno::Reference< css::accessibility::XAccessible >& _xParent + ) const = 0; + + virtual css::uno::Reference< css::accessibility::XAccessible > + createAccessibleTabBar( + TabBar& _rTabBar + ) const = 0; + + virtual css::uno::Reference< css::accessibility::XAccessibleContext > + createAccessibleTextWindowContext( + VCLXWindow* pVclXWindow, TextEngine& rEngine, TextView& rView + ) const = 0; + + virtual css::uno::Reference< css::accessibility::XAccessible > + createAccessibleBrowseBoxHeaderBar( + const css::uno::Reference< css::accessibility::XAccessible >& rxParent, + vcl::IAccessibleTableProvider& _rOwningTable, + AccessibleBrowseBoxObjType _eObjType + ) const = 0; + + virtual css::uno::Reference< css::accessibility::XAccessible > + createAccessibleBrowseBoxTableCell( + const css::uno::Reference< css::accessibility::XAccessible >& _rxParent, + vcl::IAccessibleTableProvider& _rBrowseBox, + const css::uno::Reference< css::awt::XWindow >& _xFocusWindow, + sal_Int32 _nRowId, + sal_uInt16 _nColId, + sal_Int32 _nOffset + ) const = 0; + + virtual css::uno::Reference< css::accessibility::XAccessible > + createAccessibleBrowseBoxHeaderCell( + sal_Int32 _nColumnRowId, + const css::uno::Reference< css::accessibility::XAccessible >& rxParent, + vcl::IAccessibleTableProvider& _rBrowseBox, + const css::uno::Reference< css::awt::XWindow >& _xFocusWindow, + AccessibleBrowseBoxObjType _eObjType + ) const = 0; + + virtual css::uno::Reference< css::accessibility::XAccessible > + createAccessibleCheckBoxCell( + const css::uno::Reference< css::accessibility::XAccessible >& _rxParent, + vcl::IAccessibleTableProvider& _rBrowseBox, + const css::uno::Reference< css::awt::XWindow >& _xFocusWindow, + sal_Int32 _nRowPos, + sal_uInt16 _nColPos, + const TriState& _eState, + bool _bIsTriState + ) const = 0; + + virtual css::uno::Reference< css::accessibility::XAccessible > + createEditBrowseBoxTableCellAccess( + const css::uno::Reference< css::accessibility::XAccessible >& _rxParent, + const css::uno::Reference< css::accessibility::XAccessible >& _rxControlAccessible, + const css::uno::Reference< css::awt::XWindow >& _rxFocusWindow, + vcl::IAccessibleTableProvider& _rBrowseBox, + sal_Int32 _nRowPos, + sal_uInt16 _nColPos + ) const = 0; + + protected: + virtual ~IAccessibleFactory() override {} + }; + +} // namespace vcl + + +#endif // INCLUDED_VCL_ACCESSIBLEFACTORY_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/accessibletable.hxx b/include/vcl/accessibletable.hxx new file mode 100644 index 000000000..3e3cd2fcb --- /dev/null +++ b/include/vcl/accessibletable.hxx @@ -0,0 +1,174 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_ACCESSIBLETABLE_HXX +#define INCLUDED_VCL_ACCESSIBLETABLE_HXX + +#include <tools/gen.hxx> + +#include <com/sun/star/uno/Reference.hxx> + +namespace com::sun::star::accessibility { class XAccessible; } +namespace utl { class AccessibleStateSetHelper; } +namespace vcl { class Window; } + +namespace vcl::table +{ + +typedef sal_Int32 RowPos; + +enum AccessibleTableControlObjType +{ + TCTYPE_GRIDCONTROL, /// The GridControl itself. + TCTYPE_TABLE, /// The data table. + TCTYPE_ROWHEADERBAR, /// The row header bar. + TCTYPE_COLUMNHEADERBAR, /// The horizontal column header bar. + TCTYPE_TABLECELL, /// A cell of the data table. + TCTYPE_ROWHEADERCELL, /// A cell of the row header bar. + TCTYPE_COLUMNHEADERCELL, /// A cell of the column header bar. +}; + + +/** This abstract class provides methods to implement an accessible table object. +*/ +class IAccessibleTable +{ +public: + /** @return The position of the current row. */ + virtual sal_Int32 GetCurrentRow() const = 0; + /** @return The position of the current column. */ + virtual sal_Int32 GetCurrentColumn() const = 0; + virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessibleControl( sal_Int32 _nIndex )= 0; + virtual OUString GetAccessibleObjectName(AccessibleTableControlObjType eObjType, sal_Int32 _nRow, sal_Int32 _nCol) const= 0; + virtual void GoToCell( sal_Int32 _nColumnPos, sal_Int32 _nRow )= 0; + virtual bool HasColHeader() = 0; + virtual bool HasRowHeader() = 0; + + /** return the description of the specified object. + @param eObjType + The type to ask for + @return + The description of the specified object. + */ + virtual OUString GetAccessibleObjectDescription(AccessibleTableControlObjType eObjType) const= 0; + + /** Fills the StateSet with all states (except DEFUNC and SHOWING, done by + the accessible object), depending on the specified object type. */ + virtual void FillAccessibleStateSet( ::utl::AccessibleStateSetHelper& rStateSet, + AccessibleTableControlObjType eObjType ) const= 0; + + // Window + virtual tools::Rectangle GetWindowExtentsRelative(const vcl::Window *pRelativeWindow) const = 0; + virtual void GrabFocus()= 0; + virtual css::uno::Reference< css::accessibility::XAccessible > GetAccessible()= 0; + virtual vcl::Window* GetAccessibleParentWindow() const= 0; + virtual vcl::Window* GetWindowInstance()= 0; + virtual sal_Int32 GetAccessibleControlCount() const = 0; + virtual bool ConvertPointToControlIndex( sal_Int32& _rnIndex, const Point& _rPoint )= 0; + virtual sal_Int32 GetRowCount() const= 0; + virtual sal_Int32 GetColumnCount() const= 0; + virtual bool ConvertPointToCellAddress( sal_Int32& _rnRow, sal_Int32& _rnColPos, const Point& _rPoint )= 0; + virtual tools::Rectangle calcHeaderRect( bool _bIsColumnBar ) = 0; + virtual tools::Rectangle calcHeaderCellRect( bool _bColHeader, sal_Int32 _nPos ) = 0; + virtual tools::Rectangle calcTableRect() = 0; + virtual tools::Rectangle calcCellRect( sal_Int32 _nRowPos, sal_Int32 _nColPos ) = 0; + virtual tools::Rectangle GetFieldCharacterBounds(sal_Int32 _nRow,sal_Int32 _nColumnPos,sal_Int32 nIndex)= 0; + virtual sal_Int32 GetFieldIndexAtPoint(sal_Int32 _nRow,sal_Int32 _nColumnPos,const Point& _rPoint)= 0; + virtual void FillAccessibleStateSetForCell( ::utl::AccessibleStateSetHelper& _rStateSet, sal_Int32 _nRow, sal_uInt16 _nColumnPos ) const= 0; + virtual OUString GetRowName(sal_Int32 _nIndex) const = 0; + virtual OUString GetColumnName( sal_Int32 _nIndex ) const = 0; + virtual OUString GetAccessibleCellText(sal_Int32 _nRowPos, sal_Int32 _nColPos) const = 0; + + virtual sal_Int32 GetSelectedRowCount() const = 0; + virtual sal_Int32 GetSelectedRowIndex( sal_Int32 const i_selectionIndex ) const = 0; + virtual bool IsRowSelected( sal_Int32 const i_rowIndex ) const = 0; + virtual void SelectRow( sal_Int32 const i_rowIndex, bool const i_select ) = 0; + virtual void SelectAllRows( bool const i_select ) = 0; + +protected: + ~IAccessibleTable() {} +}; + + +/** interface for an implementation of a table control's Accessible component +*/ +class IAccessibleTableControl +{ +public: + /** returns the XAccessible object itself + + The reference returned here can be used to control the life time of the + IAccessibleTableImplementation object. + + The returned reference is guaranteed to not be <NULL/>. + */ + virtual css::uno::Reference< css::accessibility::XAccessible > + getMyself() = 0; + + /** disposes the accessible implementation, so that it becomes defunc + */ + virtual void DisposeAccessImpl() = 0; + + /** checks whether the accessible implementation, and its context, are still alive + @return <TRUE/>, if the object is not disposed or disposing. + */ + virtual bool isAlive() const = 0; + + /** commits the event at all listeners of the cell + @param nEventId + the event id + @param rNewValue + the new value + @param rOldValue + the old value + */ + virtual void commitCellEvent( + sal_Int16 nEventId, + const css::uno::Any& rNewValue, + const css::uno::Any& rOldValue + ) = 0; + /** commits the event at all listeners of the table + @param nEventId + the event id + @param rNewValue + the new value + @param rOldValue + the old value + */ + virtual void commitTableEvent( + sal_Int16 nEventId, + const css::uno::Any& rNewValue, + const css::uno::Any& rOldValue + ) = 0; + + ///** Commits an event to all listeners. */ + virtual void commitEvent( + sal_Int16 nEventId, + const css::uno::Any& rNewValue + ) = 0; + +protected: + ~IAccessibleTableControl() {} +}; + +} // namespace vcl::table + +#endif // INCLUDED_VCL_ACCESSIBLETABLE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/accessibletableprovider.hxx b/include/vcl/accessibletableprovider.hxx new file mode 100644 index 000000000..cf7a0d097 --- /dev/null +++ b/include/vcl/accessibletableprovider.hxx @@ -0,0 +1,233 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_ACCESSIBLETABLEPROVIDER_HXX +#define INCLUDED_VCL_ACCESSIBLETABLEPROVIDER_HXX + +#include <vcl/AccessibleBrowseBoxObjType.hxx> +#include <vcl/window.hxx> + +namespace com::sun::star::accessibility { class XAccessible; } +namespace utl { class AccessibleStateSetHelper; } + +namespace vcl +{ + +#define OFFSET_DEFAULT (sal_Int32(-1)) +#define OFFSET_NONE (sal_Int32(0)) + +enum AccessibleTableChildIndex +{ + /** Child index of the column header bar (first row). Exists always. */ + BBINDEX_COLUMNHEADERBAR = 0, + /** Child index of the row header bar ("handle column"). Exists always. */ + BBINDEX_ROWHEADERBAR = 1, + /** Child index of the data table. */ + BBINDEX_TABLE = 2, + /** Child index of the first additional control. */ + BBINDEX_FIRSTCONTROL = 3 +}; + + +/** This abstract class provides methods to implement an accessible table object. +*/ +class IAccessibleTableProvider +{ +public: + /** @return The count of the rows. */ + virtual sal_Int32 GetRowCount() const = 0; + /** @return The count of the columns. */ + virtual sal_uInt16 GetColumnCount() const = 0; + + /** @return The position of the current row. */ + virtual sal_Int32 GetCurrRow() const = 0; + /** @return The position of the current column. */ + virtual sal_uInt16 GetCurrColumn() const = 0; + + /** @return The description of a row. + @param _nRow The row which description is in demand. */ + virtual OUString GetRowDescription( sal_Int32 _nRow ) const = 0; + /** @return The description of a column. + @param _nColumn The column which description is in demand. */ + virtual OUString GetColumnDescription( sal_uInt16 _nColumnPos ) const = 0; + + /** @return <TRUE/>, if the object has a row header. */ + virtual bool HasRowHeader() const = 0; //GetColumnId + virtual bool GoToCell( sal_Int32 _nRow, sal_uInt16 _nColumnPos ) = 0; + + virtual void SetNoSelection() = 0; + virtual void SelectAll() = 0; + virtual void SelectRow( sal_Int32 _nRow, bool _bSelect = true, bool bExpand = true ) = 0; + virtual void SelectColumn( sal_uInt16 _nColumnPos, bool _bSelect = true ) = 0; + virtual sal_Int32 GetSelectedRowCount() const = 0; + virtual sal_Int32 GetSelectedColumnCount() const = 0; + /** @return <TRUE/>, if the row is selected. */ + virtual bool IsRowSelected( sal_Int32 _nRow ) const = 0; + virtual bool IsColumnSelected( sal_Int32 _nColumnPos ) const = 0; + virtual void GetAllSelectedRows( css::uno::Sequence< sal_Int32 >& _rRows ) const = 0; + virtual void GetAllSelectedColumns( css::uno::Sequence< sal_Int32 >& _rColumns ) const = 0; + + /** @return <TRUE/>, if the cell is visible. */ + virtual bool IsCellVisible( sal_Int32 _nRow, sal_uInt16 _nColumnPos ) const = 0; + virtual OUString GetAccessibleCellText( sal_Int32 _nRow, sal_uInt16 _nColumnPos ) const = 0; + + virtual tools::Rectangle calcHeaderRect( bool _bIsColumnBar, bool _bOnScreen = true ) = 0; + virtual tools::Rectangle calcTableRect( bool _bOnScreen = true ) = 0; + virtual tools::Rectangle GetFieldRectPixelAbs( sal_Int32 _nRow, sal_uInt16 _nColumnPos, bool _bIsHeader, bool _bOnScreen = true ) = 0; + + virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessibleCell( sal_Int32 _nRow, sal_uInt16 _nColumnPos ) = 0; + virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessibleRowHeader( sal_Int32 _nRow ) = 0; + virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessibleColumnHeader( sal_uInt16 _nColumnPos ) = 0; + + virtual sal_Int32 GetAccessibleControlCount() const = 0; + virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessibleControl( sal_Int32 _nIndex ) = 0; + virtual bool ConvertPointToControlIndex( sal_Int32& _rnIndex, const Point& _rPoint ) = 0; + + virtual bool ConvertPointToCellAddress( sal_Int32& _rnRow, sal_uInt16& _rnColPos, const Point& _rPoint ) = 0; + virtual bool ConvertPointToRowHeader( sal_Int32& _rnRow, const Point& _rPoint ) = 0; + virtual bool ConvertPointToColumnHeader( sal_uInt16& _rnColPos, const Point& _rPoint ) = 0; + + virtual OUString GetAccessibleObjectName( AccessibleBrowseBoxObjType _eType, sal_Int32 _nPos = -1 ) const = 0; + virtual OUString GetAccessibleObjectDescription( AccessibleBrowseBoxObjType _eType, sal_Int32 _nPos = -1 ) const = 0; + + virtual void FillAccessibleStateSet( ::utl::AccessibleStateSetHelper& _rStateSet, AccessibleBrowseBoxObjType _eType ) const = 0; + virtual void FillAccessibleStateSetForCell( ::utl::AccessibleStateSetHelper& _rStateSet, sal_Int32 _nRow, sal_uInt16 _nColumnPos ) const = 0; + virtual void GrabTableFocus() = 0; + + // OutputDevice + virtual bool GetGlyphBoundRects( const Point& rOrigin, const OUString& rStr, int nIndex, int nLen, std::vector< tools::Rectangle >& rVector ) = 0; + + // Window + virtual tools::Rectangle GetWindowExtentsRelative(const vcl::Window *pRelativeWindow) const = 0; + virtual void GrabFocus() = 0; + virtual css::uno::Reference< css::accessibility::XAccessible > GetAccessible() = 0; + virtual vcl::Window* GetAccessibleParentWindow() const = 0; + virtual vcl::Window* GetWindowInstance() = 0; + + virtual tools::Rectangle GetFieldCharacterBounds(sal_Int32 _nRow,sal_Int32 _nColumnPos,sal_Int32 nIndex) = 0; + virtual sal_Int32 GetFieldIndexAtPoint(sal_Int32 _nRow,sal_Int32 _nColumnPos,const Point& _rPoint) = 0; + +protected: + ~IAccessibleTableProvider() {} +}; + + +/** interface for an implementation of a table control's Accessible component +*/ +class IAccessibleTabListBox +{ +public: + /** returns the XAccessible object itself + + The reference returned here can be used to control the life time of the + IAccessibleTableImplementation object. + + The returned reference is guaranteed to not be <NULL/>. + */ + virtual css::uno::Reference< css::accessibility::XAccessible > + getMyself() = 0; + + /** returns the accessible object for the column header bar + */ + virtual css::uno::Reference< css::accessibility::XAccessible > + getHeaderBar() = 0; + +protected: + ~IAccessibleTabListBox() {} +}; + +/** interface for an implementation of a browse box's Accessible component +*/ +class IAccessibleBrowseBox +{ +public: + /** returns the XAccessible object itself + + The reference returned here can be used to control the life time of the + IAccessibleTableImplementation object. + + The returned reference is guaranteed to not be <NULL/>. + */ + virtual css::uno::Reference< css::accessibility::XAccessible > + getMyself() = 0; + + /** disposes the accessible implementation, so that it becomes defunc + */ + virtual void dispose() = 0; + + /** checks whether the accessible implementation, and its context, are still alive + @return <TRUE/>, if the object is not disposed or disposing. + */ + virtual bool isAlive() const = 0; + + /** returns the accessible object for the row or the column header bar + */ + virtual css::uno::Reference< css::accessibility::XAccessible > + getHeaderBar( AccessibleBrowseBoxObjType _eObjType ) = 0; + + /** returns the accessible object for the table representation + */ + virtual css::uno::Reference< css::accessibility::XAccessible > + getTable() = 0; + + /** commits the event at all listeners of the column/row header bar + @param nEventId + the event id + @param rNewValue + the new value + @param rOldValue + the old value + */ + virtual void commitHeaderBarEvent( + sal_Int16 nEventId, + const css::uno::Any& rNewValue, + const css::uno::Any& rOldValue, + bool _bColumnHeaderBar + ) = 0; + + /** commits the event at all listeners of the table + @param nEventId + the event id + @param rNewValue + the new value + @param rOldValue + the old value + */ + virtual void commitTableEvent( + sal_Int16 nEventId, + const css::uno::Any& rNewValue, + const css::uno::Any& rOldValue + ) = 0; + + /** Commits an event to all listeners. */ + virtual void commitEvent( + sal_Int16 nEventId, + const css::uno::Any& rNewValue, + const css::uno::Any& rOldValue + ) = 0; + +protected: + ~IAccessibleBrowseBox() {} +}; + +} // namespace vcl + +#endif // INCLUDED_VCL_ACCESSIBLETABLEPROVIDER_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/alpha.hxx b/include/vcl/alpha.hxx new file mode 100644 index 000000000..1078ce06f --- /dev/null +++ b/include/vcl/alpha.hxx @@ -0,0 +1,75 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_ALPHA_HXX +#define INCLUDED_VCL_ALPHA_HXX + +#include <sal/config.h> + +#include <utility> + +#include <vcl/dllapi.h> +#include <vcl/bitmap.hxx> + +class BitmapEx; + +class VCL_DLLPUBLIC AlphaMask final : public Bitmap +{ +public: + + AlphaMask(); + explicit AlphaMask( const Bitmap& rBitmap ); + AlphaMask( const AlphaMask& rAlphaMask ); + AlphaMask( AlphaMask&& rAlphaMask ); + explicit AlphaMask( const Size& rSizePixel, const sal_uInt8* pEraseTransparency = nullptr ); + virtual ~AlphaMask() override; + + AlphaMask& operator=( const Bitmap& rBitmap ); + AlphaMask& operator=( const AlphaMask& rAlphaMask ) { return static_cast<AlphaMask&>( Bitmap::operator=( rAlphaMask ) ); } + AlphaMask& operator=( AlphaMask&& rAlphaMask ) noexcept { return static_cast<AlphaMask&>( Bitmap::operator=( std::move(rAlphaMask) ) ); } + bool operator==( const AlphaMask& rAlphaMask ) const { return Bitmap::operator==(rAlphaMask); } + bool operator!=( const AlphaMask& rAlphaMask ) const { return Bitmap::operator!=(rAlphaMask); } + + Bitmap const & GetBitmap() const; + + void Erase( sal_uInt8 cTransparency ); + void BlendWith(const Bitmap& rOther); + + BitmapReadAccess* AcquireAlphaReadAccess() { return Bitmap::AcquireReadAccess(); } + BitmapWriteAccess* AcquireAlphaWriteAccess() { return Bitmap::AcquireWriteAccess(); } + + void ReleaseAccess( BitmapReadAccess* pAccess ); + + typedef vcl::ScopedBitmapAccess<BitmapReadAccess, AlphaMask, &AlphaMask::AcquireAlphaReadAccess> ScopedReadAccess; + + using Bitmap::IsEmpty; + +private: + friend class BitmapEx; + friend class ::OutputDevice; + friend bool VCL_DLLPUBLIC ReadDIBBitmapEx(BitmapEx& rTarget, SvStream& rIStm, bool bFileHeader, bool bMSOFormat); + + SAL_DLLPRIVATE const Bitmap& ImplGetBitmap() const; + SAL_DLLPRIVATE void ImplSetBitmap( const Bitmap& rBitmap ); + +}; + +#endif // INCLUDED_VCL_ALPHA_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/animate/Animation.hxx b/include/vcl/animate/Animation.hxx new file mode 100644 index 000000000..94cefee2e --- /dev/null +++ b/include/vcl/animate/Animation.hxx @@ -0,0 +1,118 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_ANIMATE_ANIMATION_HXX +#define INCLUDED_VCL_ANIMATE_ANIMATION_HXX + +#include <tools/solar.h> +#include <vcl/dllapi.h> +#include <vcl/timer.hxx> +#include <vcl/animate/AnimationBitmap.hxx> + +#define ANIMATION_TIMEOUT_ON_CLICK 2147483647L + +class ImplAnimView; + +class VCL_DLLPUBLIC Animation +{ +public: + Animation(); + Animation(const Animation& rAnimation); + ~Animation(); + + Animation& operator=(const Animation& rAnimation); + bool operator==(const Animation& rAnimation) const; + bool operator!=(const Animation& rAnimation) const { return !(*this == rAnimation); } + + void Clear(); + + bool Start(OutputDevice& rOutDev, const Point& rDestPt, const Size& rDestSz, + tools::Long nExtraData, OutputDevice* pFirstFrameOutDev); + + void Stop(const OutputDevice* pOutDev = nullptr, tools::Long nExtraData = 0); + + void Draw(OutputDevice& rOutDev, const Point& rDestPt) const; + void Draw(OutputDevice& rOutDev, const Point& rDestPt, const Size& rDestSz) const; + + bool IsInAnimation() const { return mbIsInAnimation; } + bool IsTransparent() const; + + const Size& GetDisplaySizePixel() const { return maGlobalSize; } + void SetDisplaySizePixel(const Size& rSize) { maGlobalSize = rSize; } + + const BitmapEx& GetBitmapEx() const { return maBitmapEx; } + void SetBitmapEx(const BitmapEx& rBmpEx) { maBitmapEx = rBmpEx; } + + sal_uInt32 GetLoopCount() const { return mnLoopCount; } + void SetLoopCount(const sal_uInt32 nLoopCount); + void ResetLoopCount(); + + void SetNotifyHdl(const Link<Animation*, void>& rLink) { maNotifyLink = rLink; } + const Link<Animation*, void>& GetNotifyHdl() const { return maNotifyLink; } + + std::vector<std::unique_ptr<AnimationBitmap>>& GetAnimationFrames() { return maList; } + size_t Count() const { return maList.size(); } + bool Insert(const AnimationBitmap& rAnimationBitmap); + const AnimationBitmap& Get(sal_uInt16 nAnimation) const; + void Replace(const AnimationBitmap& rNewAnimationBmp, sal_uInt16 nAnimation); + + sal_uLong GetSizeBytes() const; + BitmapChecksum GetChecksum() const; + +public: + void Convert(BmpConversion eConversion); + bool ReduceColors(sal_uInt16 nNewColorCount); + + bool Invert(); + void Mirror(BmpMirrorFlags nMirrorFlags); + void Adjust(short nLuminancePercent, short nContrastPercent, short nChannelRPercent, + short nChannelGPercent, short nChannelBPercent, double fGamma = 1.0, + bool bInvert = false); + + friend SvStream& ReadAnimation(SvStream& rIStream, Animation& rAnimation); + friend SvStream& WriteAnimation(SvStream& rOStream, const Animation& rAnimation); + +public: + SAL_DLLPRIVATE static void ImplIncAnimCount() { mnAnimCount++; } + SAL_DLLPRIVATE static void ImplDecAnimCount() { mnAnimCount--; } + SAL_DLLPRIVATE sal_uLong ImplGetCurPos() const { return mnPos; } + +private: + SAL_DLLPRIVATE static sal_uLong mnAnimCount; + + std::vector<std::unique_ptr<AnimationBitmap>> maList; + std::vector<std::unique_ptr<ImplAnimView>> maViewList; + + Link<Animation*, void> maNotifyLink; + BitmapEx maBitmapEx; + Timer maTimer; + Size maGlobalSize; + sal_uInt32 mnLoopCount; + sal_uInt32 mnLoops; + size_t mnPos; + bool mbIsInAnimation; + bool mbLoopTerminated; + + SAL_DLLPRIVATE void ImplRestartTimer(sal_uLong nTimeout); + DECL_DLLPRIVATE_LINK(ImplTimeoutHdl, Timer*, void); +}; + +#endif // INCLUDED_VCL_ANIMATE_ANIMATION_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/animate/AnimationBitmap.hxx b/include/vcl/animate/AnimationBitmap.hxx new file mode 100644 index 000000000..d06f820f8 --- /dev/null +++ b/include/vcl/animate/AnimationBitmap.hxx @@ -0,0 +1,78 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_ANIMATE_ANIMATIONBITMAP_HXX +#define INCLUDED_VCL_ANIMATE_ANIMATIONBITMAP_HXX + +#include <vcl/bitmapex.hxx> + +enum class Disposal +{ + Not, + Back, + Previous +}; + +struct AnimationBitmap +{ + BitmapEx maBitmapEx; + Point maPositionPixel; + Size maSizePixel; + tools::Long mnWait; + Disposal meDisposal; + bool mbUserInput; + + AnimationBitmap() + : mnWait(0) + , meDisposal(Disposal::Not) + , mbUserInput(false) + { + } + + AnimationBitmap(const BitmapEx& rBitmapEx, const Point& rPositionPixel, const Size& rSizePixel, + tools::Long nWait = 0, Disposal eDisposal = Disposal::Not) + : maBitmapEx(rBitmapEx) + , maPositionPixel(rPositionPixel) + , maSizePixel(rSizePixel) + , mnWait(nWait) + , meDisposal(eDisposal) + , mbUserInput(false) + { + } + + bool operator==(const AnimationBitmap& rAnimationBitmap) const + { + return (rAnimationBitmap.maBitmapEx == maBitmapEx + && rAnimationBitmap.maPositionPixel == maPositionPixel + && rAnimationBitmap.maSizePixel == maSizePixel && rAnimationBitmap.mnWait == mnWait + && rAnimationBitmap.meDisposal == meDisposal + && rAnimationBitmap.mbUserInput == mbUserInput); + } + + bool operator!=(const AnimationBitmap& rAnimationBitmap) const + { + return !(*this == rAnimationBitmap); + } + + BitmapChecksum GetChecksum() const; +}; + +#endif // INCLUDED_VCL_ANIMATE_ANIMATIONBITMAP_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/bitmap.hxx b/include/vcl/bitmap.hxx new file mode 100644 index 000000000..d27ffdaa8 --- /dev/null +++ b/include/vcl/bitmap.hxx @@ -0,0 +1,570 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_BITMAP_HXX +#define INCLUDED_VCL_BITMAP_HXX + +#include <tools/degree.hxx> +#include <vcl/checksum.hxx> +#include <vcl/dllapi.h> +#include <vcl/mapmod.hxx> +#include <vcl/region.hxx> +#include <vcl/scopedbitmapaccess.hxx> +#include <vcl/bitmap/BitmapTypes.hxx> + +#include <o3tl/typed_flags_set.hxx> + +#include <memory> + +#define GAMMA( _def_cVal, _def_InvGamma ) (static_cast<sal_uInt8>(MinMax(FRound(pow( _def_cVal/255.0,_def_InvGamma)*255.0),0,255))) + +class Color; + +template <typename Arg, typename Ret> class Link; + +enum class BmpMirrorFlags +{ + NONE = 0x00, + Horizontal = 0x01, + Vertical = 0x02, +}; + +namespace o3tl +{ + template<> struct typed_flags<BmpMirrorFlags> : is_typed_flags<BmpMirrorFlags, 0x03> {}; +} + +enum class BmpScaleFlag +{ +// Try to preferably use these. + Default, + Fast, + BestQuality, +// Specific algorithms, use only if you really need to (mainly used for tests) + NearestNeighbor, + Interpolate, // fast, integer bilinear + Lanczos, + BiCubic, + BiLinear +}; + +#define BMP_COL_TRANS Color( 252, 3, 251 ) + +enum class BmpConversion +{ + NNONE, + N1BitThreshold, + N8BitGreys, + N8BitColors, + N24Bit, + N32Bit, + N8BitTrans, + N8BitNoConversion // make 8bit without color conversion (e.g. take the red channel) +}; + +class BitmapInfoAccess; +class BitmapReadAccess; +class BitmapWriteAccess; +class BitmapPalette; +class GDIMetaFile; +class AlphaMask; +class OutputDevice; +class SalBitmap; + +struct BitmapSystemData +{ + #if defined(_WIN32) + void* pDIB; // device independent byte buffer + #elif defined( MACOSX ) || defined( IOS ) + // Nothing needed, apparently + #else + void* aPixmap; + #endif + int mnWidth; + int mnHeight; +}; + +class SAL_WARN_UNUSED VCL_DLLPUBLIC Bitmap +{ +public: + + Bitmap(); + Bitmap( const Bitmap& rBitmap ); + Bitmap( const Size& rSizePixel, vcl::PixelFormat ePixelFormat, const BitmapPalette* pPal = nullptr ); + explicit Bitmap( std::shared_ptr<SalBitmap> const & xSalBitmap ); + virtual ~Bitmap(); + + Bitmap& operator=( const Bitmap& rBitmap ); + Bitmap& operator=( Bitmap&& rBitmap ) noexcept; + bool operator==( const Bitmap& rBitmap ) const; + bool operator!=( const Bitmap& rBitmap ) const { return !operator==(rBitmap); } + + inline bool IsEmpty() const; + void SetEmpty(); + + inline const MapMode& GetPrefMapMode() const; + inline void SetPrefMapMode( const MapMode& rMapMode ); + + inline const Size& GetPrefSize() const; + inline void SetPrefSize( const Size& rSize ); + + Size GetSizePixel() const; + + vcl::PixelFormat getPixelFormat() const; + inline sal_Int64 GetSizeBytes() const; + bool HasGreyPalette8Bit() const; + bool HasGreyPaletteAny() const; + /** get system dependent bitmap data + + @param rData + The system dependent BitmapSystemData structure to be filled + + @return true if the bitmap has a valid system object (e.g. not empty) + */ + bool GetSystemData( BitmapSystemData& rData ) const; + + BitmapChecksum GetChecksum() const; + + Bitmap CreateDisplayBitmap( OutputDevice* pDisplay ) const; + + static const BitmapPalette& + GetGreyPalette( int nEntries ); + +public: + + /** Convert bitmap format + + @param eConversion + The format this bitmap should be converted to. + + @return true the conversion was completed successfully. + */ + bool Convert( BmpConversion eConversion ); + + /** Apply a Floyd dither algorithm to the bitmap + + This method dithers the bitmap inplace, i.e. a true color + bitmap is converted to a paletted bitmap, reducing the color + deviation by error diffusion. + + */ + bool Dither(); + + /** Crop the bitmap + + @param rRectPixel + A rectangle specifying the crop amounts on all four sides of + the bitmap. If the upper left corner of the bitmap is assigned + (0,0), then this method cuts out the given rectangle from the + bitmap. Note that the rectangle is clipped to the bitmap's + dimension, i.e. negative left,top rectangle coordinates or + exceeding width or height is ignored. + + @return true cropping was performed successfully. If + nothing had to be cropped, because e.g. the crop rectangle + included the bitmap, false is returned, too! + */ + bool Crop( const tools::Rectangle& rRectPixel ); + + /** Expand the bitmap by pixel padding + + @param nDX + Number of pixel to pad at the right border of the bitmap + + @param nDY + Number of scanlines to pad at the bottom border of the bitmap + + @param pInitColor + Color to use for padded pixel + + @return true, if padding was performed successfully. false is + not only returned when the operation failed, but also if + nothing had to be done, e.g. because nDX and nDY were zero. + */ + bool Expand( + sal_Int32 nDX, sal_Int32 nDY, + const Color* pInitColor = nullptr ); + + /** Copy a rectangular area from another bitmap + + @param rRectDst + Destination rectangle in this bitmap. This is clipped to the + bitmap dimensions. + + @param rRectSrc + Source rectangle in pBmpSrc. This is clipped to the source + bitmap dimensions. Note further that no scaling takes place + during this copy operation, i.e. only the minimum of source + and destination rectangle's width and height are used. + + @param pBmpSrc + The source bitmap to copy from. If this argument is NULL, or + equal to the object this method is called on, copying takes + place within the same bitmap. + + @return true, if the operation completed successfully. false + is not only returned when the operation failed, but also if + nothing had to be done, e.g. because one of the rectangles are + empty. + */ + bool CopyPixel( + const tools::Rectangle& rRectDst, + const tools::Rectangle& rRectSrc, + const Bitmap* pBmpSrc = nullptr ); + + bool CopyPixel_AlphaOptimized( + const tools::Rectangle& rRectDst, + const tools::Rectangle& rRectSrc, + const Bitmap* pBmpSrc ); + + /** Perform boolean OR operation with another bitmap + + @param rMask + The mask bitmap in the selected combine operation + + @return true, if the operation was completed successfully. + */ + bool CombineOr( const Bitmap& rMask ); + + /** Alpha-blend the given bitmap against a specified uniform + background color. + + @attention This method might convert paletted bitmaps to + truecolor, to be able to represent every necessary color. Note + that during alpha blending, lots of colors not originally + included in the bitmap can be generated. + + @param rAlpha + Alpha mask to blend with + + @param rBackgroundColor + Background color to use for every pixel during alpha blending + + @return true, if blending was successful, false otherwise + */ + bool Blend( + const AlphaMask& rAlpha, + const Color& rBackgroundColor ); + + /** Fill the entire bitmap with the given color + + @param rFillColor + Color value to use for filling + + @return true, if the operation was completed successfully. + */ + bool Erase( const Color& rFillColor ); + + /** Perform the Invert operation on every pixel + + @return true, if the operation was completed successfully. + */ + bool Invert(); + + /** Mirror the bitmap + + @param nMirrorFlags + About which axis (horizontal, vertical, or both) to mirror + + @return true, if the operation was completed successfully. + */ + bool Mirror( BmpMirrorFlags nMirrorFlags ); + + /** Scale the bitmap + + @param rNewSize + The resulting size of the scaled bitmap + + @param nScaleFlag + The algorithm to be used for scaling + + @return true, if the operation was completed successfully. + */ + bool Scale( const Size& rNewSize, BmpScaleFlag nScaleFlag = BmpScaleFlag::Default ); + + /** Scale the bitmap + + @param rScaleX + The scale factor in x direction. + + @param rScaleY + The scale factor in y direction. + + @param nScaleFlag + Method of scaling - it is recommended that either BmpScaleFlag::Default or BmpScaleFlag::BestQuality be used. + + @return true, if the operation was completed successfully. + */ + bool Scale( const double& rScaleX, const double& rScaleY, BmpScaleFlag nScaleFlag = BmpScaleFlag::Default ); + + /** + Returns true if bitmap scaling is considered to be fast. + + Currently this returns true if OpenGL is used for scaling, otherwise false (CPU scaling is slower). + + @since 4.5 + */ + static bool HasFastScale(); + + // Adapt the BitCount of rNew to BitCount of total, including grey or color palette + // Can be used to create alpha/mask bitmaps after their processing in 24bit + void AdaptBitCount(Bitmap& rNew) const; + + /** Rotate bitmap by the specified angle + + @param nAngle10 + The rotation angle in tenth of a degree. The bitmap is always rotated around its center. + + @param rFillColor + The color to use for filling blank areas. During rotation, the + bitmap is enlarged such that the whole rotation result fits + in. The empty spaces around that rotated original bitmap are + then filled with this color. + + @return true, if the operation was completed successfully. + */ + bool Rotate( Degree10 nAngle10, const Color& rFillColor ); + + /** Create on-off mask from bitmap + + This method creates a bitmask from the bitmap, where every + pixel that equals rTransColor is set transparent, the rest + opaque. + + @param rTransColor + Color value where the bitmask should be transparent + + @param nTol + Tolerance value. Specifies the maximal difference between + rTransColor and the individual pixel values, such that the + corresponding pixel is still regarded as transparent. + + @return the resulting bitmask. + */ + Bitmap CreateMask( const Color& rTransColor, sal_uInt8 nTol = 0 ) const; + + /** Create region of similar colors in a given rectangle + + @param rColor + All pixel which have this color are included in the calculated region + + @param rRect + The rectangle within which matching pixel are looked for. This + rectangle is always clipped to the bitmap dimensions. + + @return the generated region. + */ + vcl::Region CreateRegion( const Color& rColor, const tools::Rectangle& rRect ) const; + + /** Replace all pixel where the given mask is on with the specified color + + @param rMask + Mask specifying which pixel should be replaced + + @param rReplaceColor + Color to be placed in all changed pixel + + @return true, if the operation was completed successfully. + */ + bool Replace( const Bitmap& rMask, const Color& rReplaceColor ); + + /** Merge bitmap with given background color according to specified alpha mask + + @param rAlpha + Alpha mask specifying the amount of background color to merge in + + @param rMergeColor + Background color to be used for merging + + @return true, if the operation was completed successfully. + */ + bool Replace( const AlphaMask& rAlpha, const Color& rMergeColor ); + + /** Replace all pixel having the search color with the specified color + + @param rSearchColor + Color specifying which pixel should be replaced + + @param rReplaceColor + Color to be placed in all changed pixel + + @param nTol + Tolerance value. Specifies the maximal difference between + rSearchColor and the individual pixel values, such that the + corresponding pixel is still regarded a match. + + @return true, if the operation was completed successfully. + */ + bool Replace( const Color& rSearchColor, const Color& rReplaceColor, sal_uInt8 nTol = 0 ); + + /** Replace all pixel having one the search colors with the corresponding replace color + + @param pSearchColors + Array of colors specifying which pixel should be replaced + + @param rReplaceColors + Array of colors to be placed in all changed pixel + + @param nColorCount + Size of the aforementioned color arrays + + @param pTols + Tolerance value. Specifies the maximal difference between + pSearchColor colors and the individual pixel values, such that + the corresponding pixel is still regarded a match. + + @return true, if the operation was completed successfully. + */ + bool Replace( + const Color* pSearchColors, + const Color* rReplaceColors, + size_t nColorCount, + sal_uInt8 const * pTols ); + + /** Convert the bitmap to a meta file + + This works by putting continuous areas of the same color into + polygons painted in this color, by tracing the area's bounding + line. + + @param rMtf + The resulting meta file + + @param cReduce + If non-null, minimal size of bound rects for individual polygons. Smaller ones are ignored. + + @param pProgress + A callback for showing the progress of the vectorization + */ + void Vectorize( + GDIMetaFile& rMtf, + sal_uInt8 cReduce, + const Link<tools::Long,void>* pProgress ); + + /** Change various global color characteristics + + @param nLuminancePercent + Percent of luminance change, valid range [-100,100]. Values outside this range are clipped to the valid range. + + @param nContrastPercent + Percent of contrast change, valid range [-100,100]. Values outside this range are clipped to the valid range. + + @param nChannelRPercent + Percent of red channel change, valid range [-100,100]. Values outside this range are clipped to the valid range. + + @param nChannelGPercent + Percent of green channel change, valid range [-100,100]. Values outside this range are clipped to the valid range. + + @param nChannelBPercent + Percent of blue channel change, valid range [-100,100]. Values outside this range are clipped to the valid range. + + @param fGamma + Exponent of the gamma function applied to the bitmap. The + value 1.0 results in no change, the valid range is + (0.0,10.0]. Values outside this range are regarded as 1.0. + + @param bInvert + If true, invert the channel values with the logical 'not' operator + + @param msoBrightness + Use the same formula for brightness as used by MSOffice. + + @return true, if the operation was completed successfully. + */ + bool Adjust( + short nLuminancePercent, + short nContrastPercent = 0, + short nChannelRPercent = 0, + short nChannelGPercent = 0, + short nChannelBPercent = 0, + double fGamma = 1.0, + bool bInvert = false, + bool msoBrightness = false ); + +public: + /** ReassignWithSize and recalculate bitmap. + + ReassignWithSizes the bitmap, and recalculates the bitmap size based on the new bitmap. + + @param rBitmap Bitmap to reassign and use for size calculation + */ + SAL_DLLPRIVATE void ReassignWithSize(const Bitmap& rBitmap); + + SAL_DLLPRIVATE void ImplMakeUnique(); + const std::shared_ptr<SalBitmap>& ImplGetSalBitmap() const { return mxSalBmp; } + SAL_DLLPRIVATE void ImplSetSalBitmap( const std::shared_ptr<SalBitmap>& xImpBmp ); + + SAL_DLLPRIVATE bool ImplMakeGreyscales(); + +public: + + BitmapInfoAccess* AcquireInfoAccess(); + BitmapReadAccess* AcquireReadAccess(); + BitmapWriteAccess* AcquireWriteAccess(); + static void ReleaseAccess( BitmapInfoAccess* pAccess ); + + typedef vcl::ScopedBitmapAccess<BitmapReadAccess, Bitmap, &Bitmap::AcquireReadAccess> ScopedReadAccess; + typedef vcl::ScopedBitmapAccess<BitmapInfoAccess, Bitmap, &Bitmap::AcquireInfoAccess> ScopedInfoAccess; + +private: + SAL_DLLPRIVATE bool ImplConvertUp(vcl::PixelFormat ePixelFormat, Color const* pExtColor = nullptr); + SAL_DLLPRIVATE bool ImplConvertDown8BPP(Color const* pExtColor = nullptr); + +private: + std::shared_ptr<SalBitmap> mxSalBmp; + MapMode maPrefMapMode; + Size maPrefSize; +}; + +inline bool Bitmap::IsEmpty() const +{ + return( mxSalBmp == nullptr ); +} + +inline const MapMode& Bitmap::GetPrefMapMode() const +{ + return maPrefMapMode; +} + +inline void Bitmap::SetPrefMapMode( const MapMode& rMapMode ) +{ + maPrefMapMode = rMapMode; +} + +inline const Size& Bitmap::GetPrefSize() const +{ + return maPrefSize; +} + +inline void Bitmap::SetPrefSize( const Size& rSize ) +{ + maPrefSize = rSize; +} + +inline sal_Int64 Bitmap::GetSizeBytes() const +{ + const auto aSizePixel = GetSizePixel(); + const sal_Int64 aBitCount = vcl::pixelFormatBitCount(getPixelFormat()); + sal_Int64 aSizeInBytes = (aSizePixel.Width() * aSizePixel.Height() * aBitCount) / 8; + return aSizeInBytes; +} + +#endif // INCLUDED_VCL_BITMAP_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/bitmap/BitmapTypes.hxx b/include/vcl/bitmap/BitmapTypes.hxx new file mode 100644 index 000000000..10d0f5332 --- /dev/null +++ b/include/vcl/bitmap/BitmapTypes.hxx @@ -0,0 +1,68 @@ +/* -*- 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/. + * + */ + +#pragma once + +#include <sal/types.h> +#include <cassert> + +namespace vcl +{ +/** Pixel format of the bitmap in bits per pixel */ +enum class PixelFormat +{ + INVALID = 0, + N1_BPP = 1, + N8_BPP = 8, + N24_BPP = 24, + N32_BPP = 32 +}; + +/** Is it a pixel format that forces creation of a palette */ +constexpr bool isPalettePixelFormat(PixelFormat ePixelFormat) +{ + assert(ePixelFormat != PixelFormat::INVALID); + return sal_uInt16(ePixelFormat) <= 8; +} + +constexpr sal_uInt16 pixelFormatBitCount(PixelFormat ePixelFormat) +{ + return sal_uInt16(ePixelFormat); +} + +constexpr sal_Int64 numberOfColors(PixelFormat ePixelFormat) +{ + return sal_Int64(1) << sal_Int64(ePixelFormat); +} + +constexpr PixelFormat bitDepthToPixelFormat(sal_uInt16 nBitDepth) +{ + switch (nBitDepth) + { + case 1: + return PixelFormat::N1_BPP; + case 4: + assert(false); + break; + case 8: + return PixelFormat::N8_BPP; + case 24: + return PixelFormat::N24_BPP; + case 32: + return PixelFormat::N32_BPP; + default: + break; + } + return PixelFormat::INVALID; +} + +} // end namespace vcl + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/bitmapex.hxx b/include/vcl/bitmapex.hxx new file mode 100644 index 000000000..f847c9f6d --- /dev/null +++ b/include/vcl/bitmapex.hxx @@ -0,0 +1,512 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_BITMAPEX_HXX +#define INCLUDED_VCL_BITMAPEX_HXX + +#include <vcl/dllapi.h> +#include <vcl/alpha.hxx> +#include <vcl/Scanline.hxx> +#include <tools/color.hxx> +#include <tools/degree.hxx> + +#include <sal/types.h> + +namespace com::sun::star::rendering { + class XBitmapCanvas; +} +namespace com::sun::star::uno { template <class interface_type> class Reference; } +namespace basegfx { class BColorModifierStack; } + +class SAL_WARN_UNUSED VCL_DLLPUBLIC BitmapEx +{ +public: + + BitmapEx(); + explicit BitmapEx( const OUString& rIconName ); + BitmapEx( const BitmapEx& rBitmapEx ); + BitmapEx( const BitmapEx& rBitmapEx, Point aSrc, Size aSize ); + BitmapEx(Size aSize, vcl::PixelFormat ePixelFormat); + explicit BitmapEx( const Bitmap& rBmp ); + BitmapEx( const Bitmap& rBmp, const Bitmap& rMask ); + BitmapEx( const Bitmap& rBmp, const AlphaMask& rAlphaMask ); + BitmapEx( const Bitmap& rBmp, const Color& rTransparentColor ); + + BitmapEx& operator=( const BitmapEx& rBitmapEx ); + BitmapEx& operator=( const Bitmap& rBitmap ) { return operator=(BitmapEx(rBitmap)); } + bool operator==( const BitmapEx& rBitmapEx ) const; + bool operator!=( const BitmapEx& rBitmapEx ) const { return !(*this==rBitmapEx); } + + bool IsEmpty() const; + void SetEmpty(); + void Clear(); + + void Draw( OutputDevice* pOutDev, + const Point& rDestPt ) const; + void Draw( OutputDevice* pOutDev, + const Point& rDestPt, const Size& rDestSize ) const; + + Bitmap GetBitmap( Color aTransparentReplaceColor ) const; + /// Gives direct access to the contained bitmap. + const Bitmap& GetBitmap() const; + + bool IsAlpha() const; + AlphaMask GetAlpha() const; + + const Size& GetSizePixel() const { return maBitmapSize; } + void SetSizePixel(const Size& rNewSize); + + const Size& GetPrefSize() const { return maBitmap.GetPrefSize(); } + void SetPrefSize( const Size& rPrefSize ) { maBitmap.SetPrefSize( rPrefSize ); } + + const MapMode& GetPrefMapMode() const { return maBitmap.GetPrefMapMode(); } + void SetPrefMapMode( const MapMode& rPrefMapMode ) { maBitmap.SetPrefMapMode( rPrefMapMode ); } + + vcl::PixelFormat getPixelFormat() const + { + return maBitmap.getPixelFormat(); + } + + sal_Int64 GetSizeBytes() const; + BitmapChecksum GetChecksum() const; + + /** Convert bitmap format + + @param eConversion + The format this bitmap should be converted to. + + @return true, if the conversion was completed successfully. + */ + bool Convert( BmpConversion eConversion ); + + /** Crop the bitmap + + @param rRectPixel + A rectangle specifying the crop amounts on all four sides of + the bitmap. If the upper left corner of the bitmap is assigned + (0,0), then this method cuts out the given rectangle from the + bitmap. Note that the rectangle is clipped to the bitmap's + dimension, i.e. negative left,top rectangle coordinates or + exceeding width or height is ignored. + + @return true, if cropping was performed successfully. If + nothing had to be cropped, because e.g. the crop rectangle + included the bitmap, false is returned, too! + */ + bool Crop( const tools::Rectangle& rRectPixel ); + + /** Expand the bitmap by pixel padding + + @param nDX + Number of pixel to pad at the right border of the bitmap + + @param nDY + Number of scanlines to pad at the bottom border of the bitmap + + @param bExpandTransparent + Whether to expand the transparency color or not. + */ + void Expand( + sal_Int32 nDX, sal_Int32 nDY, + bool bExpandTransparent = false ); + + /** Copy a rectangular area from another bitmap + + @param rRectDst + Destination rectangle in this bitmap. This is clipped to the + bitmap dimensions. + + @param rRectSrc + Source rectangle in pBmpSrc. This is clipped to the source + bitmap dimensions. Note further that no scaling takes place + during this copy operation, i.e. only the minimum of source + and destination rectangle's width and height are used. + + @param pBmpExSrc + The source bitmap to copy from. If this argument is NULL, or + equal to the object this method is called on, copying takes + place within the same bitmap. + + @return true, if the operation completed successfully. false + is not only returned when the operation failed, but also if + nothing had to be done, e.g. because one of the rectangles are + empty. + */ + bool CopyPixel( + const tools::Rectangle& rRectDst, + const tools::Rectangle& rRectSrc, + const BitmapEx* pBmpExSrc ); + + /** Fill the entire bitmap with the given color + + @param rFillColor + Color value to use for filling. Set the transparency part of + the color to fill the mask. + + @return true, if the operation was completed successfully. + */ + bool Erase( const Color& rFillColor ); + + /** Perform the Invert operation on every pixel + + @return true, if the operation was completed successfully. + */ + bool Invert(); + + /** Mirror the bitmap + + @param nMirrorFlags + About which axis (horizontal, vertical, or both) to mirror + + @return true, if the operation was completed successfully. + */ + bool Mirror( BmpMirrorFlags nMirrorFlags ); + + /** Scale the bitmap + + @param rNewSize + The resulting size of the scaled bitmap + + @param nScaleFlag + The algorithm to be used for scaling + + @return true, if the operation was completed successfully. + */ + bool Scale( + const Size& rNewSize, + BmpScaleFlag nScaleFlag = BmpScaleFlag::Default ); + + /** Scale the bitmap + + @param rScaleX + The scale factor in x direction. + + @param rScaleY + The scale factor in y direction. + + @param nScaleFlag + The algorithm to be used for scaling + + @return true, if the operation was completed successfully. + */ + bool Scale( + const double& rScaleX, + const double& rScaleY, + BmpScaleFlag nScaleFlag = BmpScaleFlag::Default ); + + /** Rotate bitmap by the specified angle + + @param nAngle10 + The rotation angle in tenth of a degree. The bitmap is always rotated around its center. + + @param rFillColor + The color to use for filling blank areas. During rotation, the + bitmap is enlarged such that the whole rotation result fits + in. The empty spaces around that rotated original bitmap are + then filled with this color. + + @return true, if the operation was completed successfully. + */ + bool Rotate( + Degree10 nAngle10, + const Color& rFillColor ); + + /** Replace all pixel having the search color with the specified color + + @param rSearchColor + Color specifying which pixel should be replaced + + @param rReplaceColor + Color to be placed in all changed pixel + */ + void Replace( + const Color& rSearchColor, + const Color& rReplaceColor ); + + /** Replace all pixel having the search color with the specified color + + @param rSearchColor + Color specifying which pixel should be replaced + + @param rReplaceColor + Color to be placed in all changed pixel + + @param nTolerance + Tolerance value. Specifies the maximal difference between + rSearchColor and the individual pixel values, such that the + corresponding pixel is still regarded a match. + */ + void Replace( + const Color& rSearchColor, + const Color& rReplaceColor, + sal_uInt8 nTolerance ); + + /** Replace all pixel having one the search colors with the corresponding replace color + + @param pSearchColors + Array of colors specifying which pixel should be replaced + + @param pReplaceColors + Array of colors to be placed in all changed pixel + + @param nColorCount + Size of the aforementioned color arrays + + @param pTols + Tolerance value. Specifies the maximal difference between + pSearchColor colors and the individual pixel values, such that + the corresponding pixel is still regarded a match. + */ + void Replace( + const Color* pSearchColors, + const Color* pReplaceColors, + size_t nColorCount ); + + /** Replace all pixel having one the search colors with the corresponding replace color + + @param pSearchColors + Array of colors specifying which pixel should be replaced + + @param rReplaceColors + Array of colors to be placed in all changed pixel + + @param nColorCount + Size of the aforementioned color arrays + + @param pTols + Tolerance value. Specifies the maximal difference between + pSearchColor colors and the individual pixel values, such that + the corresponding pixel is still regarded a match. + + @return true, if the operation was completed successfully. + */ + void Replace( + const Color* pSearchColors, + const Color* pReplaceColors, + size_t nColorCount, + sal_uInt8 const * pTols ); + + /** Replace transparency with given color. + */ + void ReplaceTransparency( const Color& rColor ); + + /** Get contours in image */ + tools::Polygon GetContour( bool bContourEdgeDetect, const tools::Rectangle* pWorkRect ); + + /** Change various global color characteristics + + @param nLuminancePercent + Percent of luminance change, valid range [-100,100]. Values outside this range are clipped to the valid range. + + @param nContrastPercent + Percent of contrast change, valid range [-100,100]. Values outside this range are clipped to the valid range. + + @param nChannelRPercent + Percent of red channel change, valid range [-100,100]. Values outside this range are clipped to the valid range. + + @param nChannelGPercent + Percent of green channel change, valid range [-100,100]. Values outside this range are clipped to the valid range. + + @param nChannelBPercent + Percent of blue channel change, valid range [-100,100]. Values outside this range are clipped to the valid range. + + @param fGamma + Exponent of the gamma function applied to the bitmap. The + value 1.0 results in no change, the valid range is + (0.0,10.0]. Values outside this range are regarded as 1.0. + + @param bInvert + If true, invert the channel values with the logical 'not' operator + + @param msoBrightness + Use the same formula for brightness as used by MSOffice. + + @return true, if the operation was completed successfully. + */ + bool Adjust( + short nLuminancePercent, + short nContrastPercent, + short nChannelRPercent, + short nChannelGPercent, + short nChannelBPercent, + double fGamma = 1.0, + bool bInvert = false, + bool msoBrightness = false ); + + /** Get alpha at given position + + @param nX + integer X-Position in Bitmap + + @param nY + integer Y-Position in Bitmap + + @return alpha value in the range of [0 .. 255] where + 0 is fully transparent, 255 is not transparent + */ + sal_uInt8 GetAlpha( + sal_Int32 nX, + sal_Int32 nY) const; + + /** Get pixel color (including alpha) at given position + + @param nX + integer X-Position in Bitmap + + @param nY + integer Y-Position in Bitmap + */ + ::Color GetPixelColor( + sal_Int32 nX, + sal_Int32 nY) const; + + /** Create transformed Bitmap + + @param fWidth + The target width in pixels + + @param fHeight + The target height in pixels + + @param rTransformation + The back transformation for each pixel in (0 .. fWidth),(0 .. fHeight) to + local pixel coordinates + */ + [[nodiscard]] + BitmapEx TransformBitmapEx( + double fWidth, + double fHeight, + const basegfx::B2DHomMatrix& rTransformation) const; + + /** Create transformed Bitmap + + @param rTransformation + The transformation from unit coordinates to the unit range + + @param rVisibleRange + The relative visible range in unit coordinates, relative to (0,0,1,1) which + defines the whole target area + + @param fMaximumArea + A limitation for the maximum size of pixels to use for the result + + The target size of the result bitmap is defined by transforming the given + rTargetRange with the given rTransformation; the area of the result is + linearly scaled to not exceed the given fMaximumArea + + @return The transformed bitmap + */ + [[nodiscard]] + BitmapEx getTransformed( + const basegfx::B2DHomMatrix& rTransformation, + const basegfx::B2DRange& rVisibleRange, + double fMaximumArea) const; + + /** Create ColorStack-modified version of this BitmapEx + + @param rBColorModifierStack + A ColrModifierStack which defines how each pixel has to be modified + */ + [[nodiscard]] + BitmapEx ModifyBitmapEx( const basegfx::BColorModifierStack& rBColorModifierStack) const; + + [[nodiscard]] + static BitmapEx AutoScaleBitmap( BitmapEx const & aBitmap, const tools::Long aStandardSize ); + + /// populate from a canvas implementation + bool Create( + const css::uno::Reference< css::rendering::XBitmapCanvas > &xBitmapCanvas, + const Size &rSize ); + + void setAlphaFrom( sal_uInt8 cIndexFrom, sal_Int8 nAlphaTo ); + + void AdjustTransparency( sal_uInt8 cTrans ); + + void CombineMaskOr(Color maskColor, sal_uInt8 nTol); + + /** + * Retrieves the color model data we need for the XImageConsumer stuff. + */ + void GetColorModel(css::uno::Sequence< sal_Int32 >& rRGBPalette, + sal_uInt32& rnRedMask, sal_uInt32& rnGreenMask, sal_uInt32& rnBlueMask, sal_uInt32& rnAlphaMask, sal_uInt32& rnTransparencyIndex, + sal_uInt32& rnWidth, sal_uInt32& rnHeight, sal_uInt8& rnBitCount); + + SAL_DLLPRIVATE std::shared_ptr<SalBitmap> const & ImplGetBitmapSalBitmap() const { return maBitmap.ImplGetSalBitmap(); } + + +private: + friend class ImpGraphic; + friend class OutputDevice; + friend bool VCL_DLLPUBLIC WriteDIBBitmapEx(const BitmapEx& rSource, SvStream& rOStm); + friend bool VCL_DLLPUBLIC ReadRawDIB(BitmapEx& rTarget, const unsigned char* pBuf, + const ScanlineFormat nFormat, + const int nHeight, + const int nStride); + + void loadFromIconTheme( const OUString& rIconName ); + + Bitmap maBitmap; + Bitmap maAlphaMask; + Size maBitmapSize; +}; + + +/** Create a blend frame as BitmapEx + + @param nAlpha + The blend value defines how strong the frame will be blended with the + existing content, 255 == full coverage, 0 == no frame will be drawn + + @param aColorTopLeft, aColorBottomRight + The colors defining the frame. These colors are linearly interpolated from + aColorTopLeft and aColorBottomRight using the width and height of the area + + @param rSize + The size of the frame in pixels + */ +BitmapEx VCL_DLLPUBLIC createBlendFrame( + const Size& rSize, + sal_uInt8 nAlpha, + Color aColorTopLeft, + Color aColorBottomRight); + + +/** Create a blend frame as BitmapEx + + @param nAlpha + The blend value defines how strong the frame will be blended with the + existing content, 255 == full coverage, 0 == no frame will be drawn + + @param aColorTopLeft, aColorBottomRight, aColorTopRight, aColorBottomLeft + The colors defining the frame. + + @param rSize + The size of the frame in pixels + */ +BitmapEx createBlendFrame( + const Size& rSize, + sal_uInt8 nAlpha, + Color aColorTopLeft, + Color aColorTopRight, + Color aColorBottomRight, + Color aColorBottomLeft); + +#endif // INCLUDED_VCL_BITMAPEX_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/builder.hxx b/include/vcl/builder.hxx new file mode 100644 index 000000000..ddae54a1d --- /dev/null +++ b/include/vcl/builder.hxx @@ -0,0 +1,450 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_BUILDER_HXX +#define INCLUDED_VCL_BUILDER_HXX + +#include <typeinfo> +#include <sal/log.hxx> +#include <unotools/resmgr.hxx> +#include <tools/fldunit.hxx> +#include <vcl/dllapi.h> +#include <vcl/window.hxx> +#include <vcl/vclptr.hxx> +#include <vcl/toolboxid.hxx> +#include <tools/wintypes.hxx> +#include <vcl/EnumContext.hxx> + +#include <memory> +#include <map> +#include <string_view> +#include <vector> +#ifdef check +# //some problem with MacOSX and a check define +# undef check +#endif + +class Button; +class ComboBox; +class FormattedField; +class ListBox; +class Menu; +class MessageDialog; +class NumericFormatter; +class PopupMenu; +class SalInstanceBuilder; +class ScreenshotTest; +class ScrollBar; +class SvTabListBox; +class Slider; +class DateField; +class TimeField; +class ToolBox; +class VclExpander; +class VclMultiLineEdit; +struct NotebookBarAddonsItem; +namespace xmlreader { class XmlReader; } +namespace com::sun::star::frame { class XFrame; } + +struct ComboBoxTextItem +{ + OUString m_sItem; + OString m_sId; + ComboBoxTextItem(const OUString& rItem, const OString& rId) + : m_sItem(rItem) + , m_sId(rId) + { + } +}; + +/// Creates a hierarchy of vcl::Windows (widgets) from a .ui file for dialogs, sidebar, etc. +class VCL_DLLPUBLIC VclBuilder +{ +public: + typedef std::map<OString, OUString> stringmap; + typedef std::map<OString, std::pair<OString, OString>> accelmap; + /// These functions create a new widget with parent pParent and return it in rRet + typedef void (*customMakeWidget)(VclPtr<vcl::Window> &rRet, const VclPtr<vcl::Window> &pParent, stringmap &rVec); + +public: + VclBuilder(vcl::Window* pParent, const OUString& sUIRootDir, const OUString& sUIFile, + const OString& sID = OString(), + const css::uno::Reference<css::frame::XFrame>& rFrame + = css::uno::Reference<css::frame::XFrame>(), + bool bLegacy = true, + const NotebookBarAddonsItem* pNotebookBarAddonsItem = nullptr); + ~VclBuilder(); + ///releases references and disposes all children. + void disposeBuilder(); + //sID must exist and be of type T + template <typename T> T* get(VclPtr<T>& ret, const OString& sID); + + //sID may not exist, but must be of type T if it does + template <typename T = vcl::Window> T* get(const OString& sID); + + vcl::Window* get_widget_root(); + + //sID may not exist + PopupMenu* get_menu(std::string_view sID); + + //release ownership of pWindow, i.e. don't delete it + void drop_ownership(const vcl::Window *pWindow); + + //see m_aDeferredProperties, you need this for toplevel dialogs + //which build themselves from their ctor. The properties on + //the top level are stored in m_aDeferredProperties and need + //to be applied post ctor + void setDeferredProperties(); + + /// return UI-File name (without '.ui') + const OString& getUIFile() const + { + return m_sHelpRoot; + } + + static SymbolType mapStockToSymbol(std::u16string_view icon_name); + +private: + VclBuilder(const VclBuilder&) = delete; + VclBuilder& operator=(const VclBuilder&) = delete; + + // owner for ListBox/ComboBox UserData + std::vector<std::unique_ptr<OUString>> m_aUserData; + + //If the toplevel window has any properties which need to be set on it, + //but the toplevel is the owner of the builder, then its ctor + //has not been completed during the building, so properties for it + //are collected here and need to be set afterwards, e.g. during + //Show or Execute + stringmap m_aDeferredProperties; + + std::unique_ptr<NotebookBarAddonsItem> m_pNotebookBarAddonsItem; + + struct PackingData + { + bool m_bVerticalOrient; + sal_Int32 m_nPosition; + PackingData(bool bVerticalOrient = false) + : m_bVerticalOrient(bVerticalOrient) + , m_nPosition(-1) + { + } + }; + + struct WinAndId + { + OString m_sID; + VclPtr<vcl::Window> m_pWindow; + PackingData m_aPackingData; + WinAndId(const OString &rId, vcl::Window *pWindow, bool bVertical) + : m_sID(rId) + , m_pWindow(pWindow) + , m_aPackingData(bVertical) + { + } + }; + std::vector<WinAndId> m_aChildren; + + struct MenuAndId + { + OString m_sID; + VclPtr<Menu> m_pMenu; + MenuAndId(const OString &rId, Menu *pMenu); + }; + std::vector<MenuAndId> m_aMenus; + + struct StringPair + { + OString m_sID; + OString m_sValue; + StringPair(const OString &rId, const OString &rValue) + : m_sID(rId) + , m_sValue(rValue) + { + } + }; + + struct UStringPair + { + OString m_sID; + OUString m_sValue; + UStringPair(const OString &rId, const OUString &rValue) + : m_sID(rId) + , m_sValue(rValue) + { + } + }; + + typedef StringPair RadioButtonGroupMap; + + struct ButtonImageWidgetMap + { + OString m_sID; + OUString m_sValue; + bool m_bRadio; + ButtonImageWidgetMap(const OString &rId, const OUString &rValue, bool bRadio) + : m_sID(rId) + , m_sValue(rValue) + , m_bRadio(bRadio) + { + } + }; + + typedef UStringPair TextBufferMap; + typedef UStringPair WidgetAdjustmentMap; + typedef UStringPair ButtonMenuMap; + typedef UStringPair MnemonicWidgetMap; + + struct ComboBoxModelMap + { + OString m_sID; + OUString m_sValue; + sal_Int32 m_nActiveId; + ComboBoxModelMap(const OString &rId, const OUString &rValue, sal_Int32 nActiveId) + : m_sID(rId) + , m_sValue(rValue) + , m_nActiveId(nActiveId) + { + } + }; + + struct ListStore + { + typedef std::vector<OUString> row; + std::vector<row> m_aEntries; + }; + + const ListStore* get_model_by_name(const OString& sID) const; + void mungeModel(ListBox &rTarget, const ListStore &rStore, sal_uInt16 nActiveId); + void mungeModel(ComboBox &rTarget, const ListStore &rStore, sal_uInt16 nActiveId); + void mungeModel(SvTabListBox &rTarget, const ListStore &rStore, sal_uInt16 nActiveId); + + typedef stringmap TextBuffer; + const TextBuffer* get_buffer_by_name(const OString& sID) const; + + static void mungeTextBuffer(VclMultiLineEdit &rTarget, const TextBuffer &rTextBuffer); + + typedef stringmap Adjustment; + const Adjustment* get_adjustment_by_name(const OString& sID) const; + + static void mungeAdjustment(NumericFormatter &rTarget, const Adjustment &rAdjustment); + static void mungeAdjustment(FormattedField &rTarget, const Adjustment &rAdjustment); + static void mungeAdjustment(ScrollBar &rTarget, const Adjustment &rAdjustment); + static void mungeAdjustment(Slider &rTarget, const Adjustment &rAdjustment); + + typedef std::map<OString, int> ImageSizeMap; + + struct SizeGroup + { + std::vector<OString> m_aWidgets; + stringmap m_aProperties; + SizeGroup() {} + }; + + + struct ParserState + { + std::locale m_aResLocale; + + std::vector<RadioButtonGroupMap> m_aGroupMaps; + + std::vector<ComboBoxModelMap> m_aModelMaps; + std::map<OString, ListStore> m_aModels; + + std::vector<TextBufferMap> m_aTextBufferMaps; + std::map<OString, TextBuffer> m_aTextBuffers; + + std::vector<WidgetAdjustmentMap> m_aNumericFormatterAdjustmentMaps; + std::vector<WidgetAdjustmentMap> m_aFormattedFormatterAdjustmentMaps; + std::vector<WidgetAdjustmentMap> m_aScrollAdjustmentMaps; + std::vector<WidgetAdjustmentMap> m_aSliderAdjustmentMaps; + + std::map<OString, Adjustment> m_aAdjustments; + + std::vector<ButtonImageWidgetMap> m_aButtonImageWidgetMaps; + ImageSizeMap m_aImageSizeMap; + + std::vector<ButtonMenuMap> m_aButtonMenuMaps; + + std::map<VclPtr<vcl::Window>, VclPtr<vcl::Window>> m_aRedundantParentWidgets; + + std::vector<SizeGroup> m_aSizeGroups; + + std::map<VclPtr<vcl::Window>, stringmap> m_aAtkInfo; + + std::vector<MnemonicWidgetMap> m_aMnemonicWidgetMaps; + + std::vector< VclPtr<VclExpander> > m_aExpanderWidgets; + + std::vector< VclPtr<MessageDialog> > m_aMessageDialogs; + + ToolBoxItemId m_nLastToolbarId; + + sal_uInt16 m_nLastMenuItemId; + + ParserState(); + }; + + OString m_sID; + OString m_sHelpRoot; + ResHookProc m_pStringReplace; + VclPtr<vcl::Window> m_pParent; + bool m_bToplevelHasDeferredInit; + bool m_bToplevelHasDeferredProperties; + bool m_bToplevelParentFound; + bool m_bLegacy; + std::unique_ptr<ParserState> m_pParserState; + + vcl::Window *get_by_name(std::string_view sID); + void delete_by_name(const OString& sID); + + class sortIntoBestTabTraversalOrder + { + public: + sortIntoBestTabTraversalOrder(VclBuilder *pBuilder) + : m_pBuilder(pBuilder) {} + + bool operator()(const vcl::Window *pA, const vcl::Window *pB) const; + + private: + VclBuilder *m_pBuilder; + }; + + /// XFrame to be able to extract labels and other properties of the UNO commands (like of .uno:Bold). + css::uno::Reference<css::frame::XFrame> m_xFrame; + +private: + VclPtr<vcl::Window> insertObject(vcl::Window *pParent, + const OString &rClass, const OString &rID, + stringmap &rProps, stringmap &rPangoAttributes, + stringmap &rAtkProps); + + VclPtr<vcl::Window> makeObject(vcl::Window *pParent, + const OString &rClass, const OString &rID, + stringmap &rVec); + + void connectNumericFormatterAdjustment(const OString &id, const OUString &rAdjustment); + void connectFormattedFormatterAdjustment(const OString &id, const OUString &rAdjustment); + + static int getImageSize(const stringmap &rMap); + + void extractGroup(const OString &id, stringmap &rVec); + void extractModel(const OString &id, stringmap &rVec); + void extractBuffer(const OString &id, stringmap &rVec); + static bool extractAdjustmentToMap(const OString &id, stringmap &rVec, std::vector<WidgetAdjustmentMap>& rAdjustmentMap); + void extractButtonImage(const OString &id, stringmap &rMap, bool bRadio); + void extractMnemonicWidget(const OString &id, stringmap &rMap); + + // either pParent or pAtkProps must be set, pParent for a child of a widget, pAtkProps for + // collecting the atk info for a GtkMenuItem + void handleChild(vcl::Window *pParent, stringmap *pAtkProps, xmlreader::XmlReader &reader); + VclPtr<vcl::Window> handleObject(vcl::Window *pParent, stringmap *pAtkProps, xmlreader::XmlReader &reader); + void handlePacking(vcl::Window *pCurrent, vcl::Window *pParent, xmlreader::XmlReader &reader); + static std::vector<vcl::EnumContext::Context> handleStyle(xmlreader::XmlReader &reader, int &nPriority); + static OString getStyleClass(xmlreader::XmlReader &reader); + void applyPackingProperty(vcl::Window *pCurrent, vcl::Window *pParent, xmlreader::XmlReader &reader); + void collectProperty(xmlreader::XmlReader &reader, stringmap &rVec) const; + static void collectPangoAttribute(xmlreader::XmlReader &reader, stringmap &rMap); + static void collectAtkRelationAttribute(xmlreader::XmlReader &reader, stringmap &rMap); + static void collectAtkRoleAttribute(xmlreader::XmlReader &reader, stringmap &rMap); + static void collectAccelerator(xmlreader::XmlReader &reader, accelmap &rMap); + + void insertMenuObject( + Menu *pParent, + PopupMenu *pSubMenu, + const OString &rClass, + const OString &rID, + stringmap &rProps, + stringmap &rAtkProps, + accelmap &rAccels); + + void handleMenuChild(Menu *pParent, xmlreader::XmlReader &reader); + void handleMenuObject(Menu *pParent, xmlreader::XmlReader &reader); + + void handleListStore(xmlreader::XmlReader &reader, const OString &rID, std::string_view rClass); + void handleRow(xmlreader::XmlReader &reader, const OString &rID); + void handleTabChild(vcl::Window *pParent, xmlreader::XmlReader &reader); + VclPtr<Menu> handleMenu(xmlreader::XmlReader &reader, const OString &rID, bool bMenuBar); + std::vector<ComboBoxTextItem> handleItems(xmlreader::XmlReader &reader) const; + + void handleSizeGroup(xmlreader::XmlReader &reader); + + stringmap handleAtkObject(xmlreader::XmlReader &reader) const; + + static void applyAtkProperties(vcl::Window *pWindow, const stringmap& rProperties); + + void handleActionWidget(xmlreader::XmlReader &reader); + + PackingData get_window_packing_data(const vcl::Window *pWindow) const; + void set_window_packing_position(const vcl::Window *pWindow, sal_Int32 nPosition); + + static vcl::Window* prepareWidgetOwnScrolling(vcl::Window *pParent, WinBits &rWinStyle); + void cleanupWidgetOwnScrolling(vcl::Window *pScrollParent, vcl::Window *pWindow, stringmap &rMap); + + void set_response(std::string_view sID, short nResponse); + + OString get_by_window(const vcl::Window *pWindow) const; + void delete_by_window(vcl::Window *pWindow); +}; + +namespace BuilderUtils +{ + //apply the properties of rProps to pWindow + VCL_DLLPUBLIC void set_properties(vcl::Window *pWindow, const VclBuilder::stringmap &rProps); + + //Convert _ gtk markup to ~ vcl markup + VCL_DLLPUBLIC OUString convertMnemonicMarkup(std::u16string_view rIn); + + VCL_DLLPUBLIC OUString extractCustomProperty(VclBuilder::stringmap &rMap); + + VCL_DLLPUBLIC bool extractDropdown(VclBuilder::stringmap &rMap); + + //add a default value of 25 width-chars to a map if width-chars not set + VCL_DLLPUBLIC void ensureDefaultWidthChars(VclBuilder::stringmap &rMap); + + //Helpers to retrofit all the existing code to the builder + VCL_DLLPUBLIC void reorderWithinParent(std::vector< vcl::Window*>& rChilds, bool bIsButtonBox); + VCL_DLLPUBLIC void reorderWithinParent(vcl::Window &rWindow, sal_uInt16 nNewPosition); + + //Convert an accessibility role name to accessibility role number + VCL_DLLPUBLIC sal_Int16 getRoleFromName(const OString& roleName); +} + +template <typename T> +inline T* VclBuilder::get(VclPtr<T>& ret, const OString& sID) +{ + vcl::Window *w = get_by_name(sID); + SAL_WARN_IF(!w, "vcl.layout", "widget \"" << sID << "\" not found in .ui"); + SAL_WARN_IF(!dynamic_cast<T*>(w), + "vcl.layout", ".ui widget \"" << sID << "\" needs to correspond to vcl type " << typeid(T).name()); + assert(w); + assert(dynamic_cast<T*>(w)); + ret = static_cast<T*>(w); + return ret.get(); +} + +//sID may not exist, but must be of type T if it does +template <typename T> +inline T* VclBuilder::get(const OString& sID) +{ + vcl::Window *w = get_by_name(sID); + SAL_WARN_IF(w && !dynamic_cast<T*>(w), + "vcl.layout", ".ui widget \"" << sID << "\" needs to correspond to vcl type " << typeid(T).name()); + assert(!w || dynamic_cast<T*>(w)); + return static_cast<T*>(w); +} + +/* + * @return true if rValue is "True", "true", "1", etc. + */ +VCL_DLLPUBLIC bool toBool(std::u16string_view rValue); + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/builderfactory.hxx b/include/vcl/builderfactory.hxx new file mode 100644 index 000000000..c6b1b0ccf --- /dev/null +++ b/include/vcl/builderfactory.hxx @@ -0,0 +1,51 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_BUILDER_FACTORY_HXX +#define INCLUDED_VCL_BUILDER_FACTORY_HXX + +#include <vcl/vclptr.hxx> +#include <vcl/builder.hxx> + +#define VCL_BUILDER_FACTORY(typeName) \ + extern "C" SAL_DLLPUBLIC_EXPORT void make##typeName(VclPtr<vcl::Window> & rRet, const VclPtr<vcl::Window> & pParent, VclBuilder::stringmap & rMap) \ + { \ + static_assert(std::is_same_v<std::remove_pointer_t<VclBuilder::customMakeWidget>, \ + decltype(make##typeName)>); \ + (void)rMap; \ + rRet = VclPtr<typeName>::Create(pParent); \ + } + +#define VCL_BUILDER_FACTORY_ARGS(typeName,arg1) \ + extern "C" SAL_DLLPUBLIC_EXPORT void make##typeName(VclPtr<vcl::Window> & rRet, const VclPtr<vcl::Window> & pParent, VclBuilder::stringmap & rMap) \ + { \ + static_assert(std::is_same_v<std::remove_pointer_t<VclBuilder::customMakeWidget>, \ + decltype(make##typeName)>); \ + (void)rMap; \ + rRet = VclPtr<typeName>::Create(pParent,arg1); \ + } + +#define VCL_BUILDER_FACTORY_CONSTRUCTOR(typeName,arg2) \ + extern "C" SAL_DLLPUBLIC_EXPORT void make##typeName(VclPtr<vcl::Window> & rRet, const VclPtr<vcl::Window> & pParent, VclBuilder::stringmap & rMap) \ + { \ + static_assert(std::is_same_v<std::remove_pointer_t<VclBuilder::customMakeWidget>, \ + decltype(make##typeName)>); \ + OUString sBorder = BuilderUtils::extractCustomProperty(rMap); \ + WinBits wb = arg2; \ + if (!sBorder.isEmpty()) \ + wb |= WB_BORDER; \ + rRet = VclPtr<typeName>::Create(pParent,wb); \ + } + +#define VCL_BUILDER_FACTORY_EXTERN(typeName) \ + extern "C" void make##typeName(VclPtr<vcl::Window> & rRet, const VclPtr<vcl::Window> & pParent, VclBuilder::stringmap & rMap) + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/builderpage.hxx b/include/vcl/builderpage.hxx new file mode 100644 index 000000000..e77cf47c4 --- /dev/null +++ b/include/vcl/builderpage.hxx @@ -0,0 +1,50 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_BUILDERPAGE_HXX +#define INCLUDED_VCL_BUILDERPAGE_HXX + +#include <vcl/weld.hxx> + +class VCL_DLLPUBLIC BuilderPage +{ +public: + BuilderPage(weld::Widget* pParent, weld::DialogController* pController, + const OUString& rUIXMLDescription, const OString& rID, bool bIsMobile = false); + virtual ~BuilderPage() COVERITY_NOEXCEPT_FALSE; + + /* The title of the page, in an Assistant the dialog may append this page title to the + dialog title. + + While in a Dialog hosting a single Page it may use the title as + the dialog title. + */ + void SetPageTitle(const OUString& rPageTitle) { m_aPageTitle = rPageTitle; } + const OUString& GetPageTitle() const { return m_aPageTitle; } + + // In a Notebook or Assistant the controller typically calls Activate on entering + // this page, and Deactivate on leaving + virtual void Activate(); + virtual void Deactivate(); + + void SetHelpId(const OString& rHelpId) { m_xContainer->set_help_id(rHelpId); } + OString GetHelpId() const { return m_xContainer->get_help_id(); } + +protected: + weld::DialogController* m_pDialogController; + std::unique_ptr<weld::Builder> m_xBuilder; + std::unique_ptr<weld::Container> m_xContainer; + +private: + OUString m_aPageTitle; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/cairo.hxx b/include/vcl/cairo.hxx new file mode 100644 index 000000000..87d820ab8 --- /dev/null +++ b/include/vcl/cairo.hxx @@ -0,0 +1,69 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_CAIRO_HXX +#define INCLUDED_VCL_CAIRO_HXX + +#include <sal/config.h> +#include <vcl/vclptr.hxx> +#include <memory> + +typedef struct _cairo_surface cairo_surface_t; +typedef struct _cairo cairo_t; + +class VirtualDevice; + +namespace cairo { + + typedef std::shared_ptr<cairo_surface_t> CairoSurfaceSharedPtr; + typedef std::shared_ptr<cairo_t> CairoSharedPtr; + struct Surface; + typedef std::shared_ptr<Surface> SurfaceSharedPtr; + + /** Cairo surface interface + + For each cairo-supported platform, there's an implementation of + this interface + */ + struct Surface + { + public: + virtual ~Surface() {} + + // Query methods + virtual CairoSharedPtr getCairo() const = 0; + virtual CairoSurfaceSharedPtr getCairoSurface() const = 0; + virtual SurfaceSharedPtr getSimilar(int cairo_content_type, int width, int height) const = 0; + + /// factory for VirDev on this surface + virtual VclPtr<VirtualDevice> createVirtualDevice() const = 0; + + /// Resize the surface (possibly destroying content), only possible for X11 typically + /// so on failure caller must create a new surface instead + virtual bool Resize( int /*width*/, int /*height*/ ) { return false; } + + /// Flush all pending output to surface + virtual void flush() const = 0; + }; + +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/canvastools.hxx b/include/vcl/canvastools.hxx new file mode 100644 index 000000000..5a46886e5 --- /dev/null +++ b/include/vcl/canvastools.hxx @@ -0,0 +1,167 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_CANVASTOOLS_HXX +#define INCLUDED_VCL_CANVASTOOLS_HXX + +#include <com/sun/star/uno/Reference.hxx> +#include <com/sun/star/uno/Sequence.hxx> +#include <basegfx/numeric/ftools.hxx> +#include <basegfx/range/b2irectangle.hxx> + +#include <vcl/dllapi.h> + +class Point; +class Size; +namespace tools { class Rectangle; } +class BitmapEx; +class Color; + +namespace basegfx +{ + class B2DVector; + class B2DPoint; + class B2DRange; + class B2IPoint; + class B2IRange; +} + +namespace com::sun::star::geometry +{ + struct RealSize2D; + struct IntegerPoint2D; + struct IntegerSize2D; + struct IntegerRectangle2D; +} + +namespace com::sun::star::rendering +{ + class XBitmap; + class XIntegerReadOnlyBitmap; +} + +namespace com::sun::star::rendering { class XColorSpace; } + +namespace vcl::unotools +{ + // Bitmap conversions + + + /** Create an XBitmap from VCL BitmapEx + */ + css::uno::Reference< css::rendering::XBitmap > + VCL_DLLPUBLIC xBitmapFromBitmapEx( const ::BitmapEx& inputBitmap ); + + /** Create a BitmapEx from an XBitmap + */ + ::BitmapEx VCL_DLLPUBLIC bitmapExFromXBitmap( const css::uno::Reference< css::rendering::XIntegerReadOnlyBitmap >& xInputBitmap ); + + // Color conversions (vcl/tools Color <-> canvas standard color space) + + + /** Create a device-specific color sequence from VCL/Tools color + + Note that this method assumes a color space equivalent to + the one returned from createStandardColorSpace() + */ + css::uno::Sequence< double > + VCL_DLLPUBLIC colorToStdColorSpaceSequence( const Color& rColor ); + + /** Convert color to device color sequence + + @param rColor + Color to convert + + @param xColorSpace + Color space to convert into + */ + css::uno::Sequence< double > + VCL_DLLPUBLIC colorToDoubleSequence( const Color& rColor, + const css::uno::Reference< css::rendering::XColorSpace >& xColorSpace ); + + /** Convert from standard device color space to VCL/Tools color + + Note that this method assumes a color space equivalent to + the one returned from createStandardColorSpace() + */ + Color VCL_DLLPUBLIC stdColorSpaceSequenceToColor( + const css::uno::Sequence< double >& rColor ); + + /** Convert color to device color sequence + + @param rColor + Color sequence to convert from + + @param xColorSpace + Color space to convert from + */ + Color VCL_DLLPUBLIC doubleSequenceToColor( const css::uno::Sequence< double >& rColor, + const css::uno::Reference< css::rendering::XColorSpace >& xColorSpace ); + + /// Convert [0,1] double value to [0,255] int + inline sal_Int8 toByteColor( double val ) + { + return sal::static_int_cast<sal_Int8>( + basegfx::fround(val*255.0)); + } + + /// Convert [0,255] int value to [0,1] double value + inline double toDoubleColor( sal_uInt8 val ) + { + return val / 255.0; + } + + /// Create a standard color space suitable for VCL RGB color + css::uno::Reference< css::rendering::XColorSpace> VCL_DLLPUBLIC createStandardColorSpace(); + + // Geometry conversions (vcl/tools <-> x) + + + // geometry::Real + css::geometry::RealSize2D VCL_DLLPUBLIC size2DFromSize( const Size& ); + + Size VCL_DLLPUBLIC sizeFromRealSize2D( const css::geometry::RealSize2D& ); + + // geometry::Integer + css::geometry::IntegerSize2D VCL_DLLPUBLIC integerSize2DFromSize( const Size& ); + + Size VCL_DLLPUBLIC sizeFromIntegerSize2D( const css::geometry::IntegerSize2D& ); + Point VCL_DLLPUBLIC pointFromIntegerPoint2D( const css::geometry::IntegerPoint2D& ); + tools::Rectangle VCL_DLLPUBLIC rectangleFromIntegerRectangle2D( const css::geometry::IntegerRectangle2D& ); + + // basegfx::B2D + Size VCL_DLLPUBLIC sizeFromB2DSize( const basegfx::B2DVector& ); + Point VCL_DLLPUBLIC pointFromB2DPoint( const basegfx::B2DPoint& ); + tools::Rectangle VCL_DLLPUBLIC rectangleFromB2DRectangle( const basegfx::B2DRange& ); + + basegfx::B2DVector VCL_DLLPUBLIC b2DSizeFromSize( const Size& ); + basegfx::B2DPoint VCL_DLLPUBLIC b2DPointFromPoint( const Point& ); + basegfx::B2DRange VCL_DLLPUBLIC b2DRectangleFromRectangle( const tools::Rectangle& ); + + // basegfx::B2I + Point VCL_DLLPUBLIC pointFromB2IPoint( const basegfx::B2IPoint& ); + tools::Rectangle VCL_DLLPUBLIC rectangleFromB2IRectangle( const basegfx::B2IRange& ); + basegfx::B2IPoint VCL_DLLPUBLIC b2IPointFromPoint(const Point&); + basegfx::B2IRectangle VCL_DLLPUBLIC b2IRectangleFromRectangle(const tools::Rectangle&); + +} + +#endif // INCLUDED_VCL_CANVASTOOLS_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/checksum.hxx b/include/vcl/checksum.hxx new file mode 100644 index 000000000..34d8ed77a --- /dev/null +++ b/include/vcl/checksum.hxx @@ -0,0 +1,84 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + + +#ifndef INCLUDED_VCL_INC_CHECKSUM_HXX +#define INCLUDED_VCL_INC_CHECKSUM_HXX + +#include <sal/config.h> +#include <sal/types.h> +#include <vcl/dllapi.h> + +#define BITMAP_CHECKSUM_SIZE 8 + +typedef sal_uInt64 BitmapChecksum; +typedef sal_uInt8 BitmapChecksumOctetArray[BITMAP_CHECKSUM_SIZE]; + +template< sal_uInt8 N = 0 > +inline void BCToBCOA( BitmapChecksum n, BitmapChecksumOctetArray p ) +{ + p[N] = static_cast<sal_uInt8>(n >> ( 8 * N )); + return BCToBCOA< N + 1 >( n, p ); +} + +template<> +inline void BCToBCOA< BITMAP_CHECKSUM_SIZE >( BitmapChecksum, BitmapChecksumOctetArray ) +{ + return; +} + +extern "C" { + +/*======================================================================== + * + * vcl_crc64 interface. + * + *======================================================================*/ +/** Evaluate CRC64 over given data. + + This function evaluates the CRC polynomial 0xEDB88320. + + @param Crc [in] CRC64 over previous data or zero. + @param Data [in] data buffer. + @param DatLen [in] data buffer length. + @return new CRC64 value. + */ +VCL_DLLPUBLIC sal_uInt64 vcl_crc64 ( + sal_uInt64 Crc, + const void *Data, sal_uInt32 DatLen +) SAL_THROW_EXTERN_C(); + + +const sal_uInt64* vcl_get_crc64_table(); + +} + +inline BitmapChecksum vcl_get_checksum ( + BitmapChecksum Checksum, + const void *Data, + sal_uInt32 DatLen +) +{ + return static_cast<BitmapChecksum>(vcl_crc64( Checksum, Data, DatLen )); +} + + +#endif // INCLUDED_VCL_INC_CHECKSUM_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/commandevent.hxx b/include/vcl/commandevent.hxx new file mode 100644 index 000000000..a22f751d6 --- /dev/null +++ b/include/vcl/commandevent.hxx @@ -0,0 +1,354 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_COMMANDEVENT_HXX +#define INCLUDED_VCL_COMMANDEVENT_HXX + +#include <memory> +#include <tools/gen.hxx> +#include <tools/solar.h> +#include <vcl/dllapi.h> +#include <vcl/keycodes.hxx> +#include <o3tl/typed_flags_set.hxx> +#include <rtl/ustring.hxx> +#include <vcl/GestureEvent.hxx> + +class CommandExtTextInputData; +class CommandWheelData; +class CommandScrollData; +class CommandModKeyData; +class CommandDialogData; +class CommandMediaData; +class CommandSelectionChangeData; +class CommandSwipeData; +class CommandLongPressData; +class CommandGestureData; + +enum class CommandEventId; + +enum class ExtTextInputAttr { + NONE = 0x0000, + GrayWaveline = 0x0010, + Underline = 0x0020, + BoldUnderline = 0x0040, + DottedUnderline = 0x0080, + DashDotUnderline = 0x0100, + DoubleUnderline = 0x0200, + Highlight = 0x0400, + RedText = 0x0800, + HalfToneText = 0x1000 +}; +namespace o3tl +{ + template<> struct typed_flags<ExtTextInputAttr> : is_typed_flags<ExtTextInputAttr, 0x1ff0> {}; +} + +#define EXTTEXTINPUT_CURSOR_INVISIBLE (sal_uInt16(0x0001)) +#define EXTTEXTINPUT_CURSOR_OVERWRITE (sal_uInt16(0x0002)) + + +class VCL_DLLPUBLIC CommandEvent +{ +private: + Point maPos; + void* mpData; + CommandEventId mnCommand; + bool mbMouseEvent; + +public: + CommandEvent(); + CommandEvent( const Point& rMousePos, CommandEventId nCmd, + bool bMEvt = false, const void* pCmdData = nullptr ); + + CommandEventId GetCommand() const { return mnCommand; } + const Point& GetMousePosPixel() const { return maPos; } + bool IsMouseEvent() const { return mbMouseEvent; } + void* GetEventData() const { return mpData; } + + const CommandExtTextInputData* GetExtTextInputData() const; + const CommandWheelData* GetWheelData() const; + const CommandScrollData* GetAutoScrollData() const; + const CommandModKeyData* GetModKeyData() const; + const CommandDialogData* GetDialogData() const; + CommandMediaData* GetMediaData() const; + const CommandSelectionChangeData* GetSelectionChangeData() const; + const CommandSwipeData* GetSwipeData() const; + const CommandLongPressData* GetLongPressData() const; + const CommandGestureData* GetGestureData() const; +}; + +class VCL_DLLPUBLIC CommandExtTextInputData +{ +private: + OUString maText; + std::unique_ptr<ExtTextInputAttr[]> mpTextAttr; + sal_Int32 mnCursorPos; + sal_uInt16 mnCursorFlags; + bool mbOnlyCursor; + +public: + CommandExtTextInputData( const OUString& rText, + const ExtTextInputAttr* pTextAttr, + sal_Int32 nCursorPos, + sal_uInt16 nCursorFlags, + bool bOnlyCursor ); + CommandExtTextInputData( const CommandExtTextInputData& rData ); + ~CommandExtTextInputData(); + + const OUString& GetText() const { return maText; } + const ExtTextInputAttr* GetTextAttr() const { return mpTextAttr.get(); } + + sal_Int32 GetCursorPos() const { return mnCursorPos; } + bool IsCursorVisible() const { return (mnCursorFlags & EXTTEXTINPUT_CURSOR_INVISIBLE) == 0; } + bool IsCursorOverwrite() const { return (mnCursorFlags & EXTTEXTINPUT_CURSOR_OVERWRITE) != 0; } + bool IsOnlyCursorChanged() const { return mbOnlyCursor; } +}; + +class VCL_DLLPUBLIC CommandInputContextData +{ +}; + +enum class CommandWheelMode +{ + NONE = 0, + SCROLL = 1, + ZOOM = 2, + DATAZOOM = 3 +}; + +// Magic value used in mnLines field in CommandWheelData +#define COMMAND_WHEEL_PAGESCROLL (sal_uLong(0xFFFFFFFF)) + +class VCL_DLLPUBLIC CommandWheelData +{ +private: + tools::Long mnDelta; + tools::Long mnNotchDelta; + double mnLines; + CommandWheelMode mnWheelMode; + sal_uInt16 mnCode; + bool mbHorz; + bool mbDeltaIsPixel; + +public: + CommandWheelData(); + CommandWheelData( tools::Long nWheelDelta, tools::Long nWheelNotchDelta, + double nScrollLines, + CommandWheelMode nWheelMode, sal_uInt16 nKeyModifier, + bool bHorz, bool bDeltaIsPixel = false ); + + tools::Long GetDelta() const { return mnDelta; } + tools::Long GetNotchDelta() const { return mnNotchDelta; } + double GetScrollLines() const { return mnLines; } + bool IsHorz() const { return mbHorz; } + bool IsDeltaPixel() const { return mbDeltaIsPixel; } + + CommandWheelMode GetMode() const { return mnWheelMode; } + + sal_uInt16 GetModifier() const + { return (mnCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2)); } + bool IsShift() const + { return ((mnCode & KEY_SHIFT) != 0); } + bool IsMod1() const + { return ((mnCode & KEY_MOD1) != 0); } + bool IsMod2() const + { return ((mnCode & KEY_MOD2) != 0); } +}; + +class CommandScrollData +{ +private: + tools::Long mnDeltaX; + tools::Long mnDeltaY; + +public: + CommandScrollData( tools::Long nDeltaX, tools::Long nDeltaY ); + + tools::Long GetDeltaX() const { return mnDeltaX; } + tools::Long GetDeltaY() const { return mnDeltaY; } +}; + +class CommandModKeyData +{ +private: + bool mbDown; + ModKeyFlags mnCode; + +public: + CommandModKeyData( ModKeyFlags nCode, bool bDown ); + + bool IsDown() const { return mbDown; } + bool IsMod1() const { return bool(mnCode & ModKeyFlags::Mod1Msk); } + bool IsMod2() const { return bool(mnCode & ModKeyFlags::Mod2Msk); } + bool IsLeftShift() const { return bool(mnCode & ModKeyFlags::LeftShift); } + bool IsRightShift() const { return bool(mnCode & ModKeyFlags::RightShift); } +}; + +enum class ShowDialogId +{ + Preferences = 1, + About = 2, +}; + +class VCL_DLLPUBLIC CommandDialogData +{ + ShowDialogId m_nDialogId; +public: + CommandDialogData( ShowDialogId nDialogId ) + : m_nDialogId( nDialogId ) + {} + + ShowDialogId GetDialogId() const { return m_nDialogId; } +}; + +// Media Commands +enum class MediaCommand +{ + ChannelDown = 1, // Decrement the channel value, for example, for a TV or radio tuner. + ChannelUp = 2, // Increment the channel value, for example, for a TV or radio tuner. + NextTrack = 3, // Go to next media track/slide. + Pause = 4, // Pause. If already paused, take no further action. This is a direct PAUSE command that has no state. + Play = 5, // Begin playing at the current position. If already paused, it will resume. This is a direct PLAY command that has no state. + PlayPause = 6, // Play or pause playback. + PreviousTrack = 7, // Go to previous media track/slide. + Record = 8, // Begin recording the current stream. + Rewind = 9,// Go backward in a stream at a higher rate of speed. + Stop = 10,// Stop playback. + MicOnOffToggle = 11,// Toggle the microphone. + MicrophoneVolumeDown = 12,// Increase microphone volume. + MicrophoneVolumeMute = 13,// Mute the microphone. + MicrophoneVolumeUp = 14,// Decrease microphone volume. + VolumeDown = 15,// Lower the volume. + VolumeMute = 16,// Mute the volume. + VolumeUp = 17,// Raise the volume. + Menu = 18,// Button Menu pressed. + PlayHold = 20,// Button Play (long) pressed. + NextTrackHold = 21,// Button Right holding pressed. +}; + +class VCL_DLLPUBLIC CommandMediaData +{ + MediaCommand m_nMediaId; + bool m_bPassThroughToOS; +public: + CommandMediaData(MediaCommand nMediaId) + : m_nMediaId(nMediaId) + , m_bPassThroughToOS(true) + { + } + MediaCommand GetMediaId() const { return m_nMediaId; } + void SetPassThroughToOS(bool bPassThroughToOS) { m_bPassThroughToOS = bPassThroughToOS; } + bool GetPassThroughToOS() const { return m_bPassThroughToOS; } +}; + +class CommandSelectionChangeData +{ +private: + sal_uLong mnStart; + sal_uLong mnEnd; + +public: + CommandSelectionChangeData( sal_uLong nStart, sal_uLong nEnd ); + + sal_uLong GetStart() const { return mnStart; } + sal_uLong GetEnd() const { return mnEnd; } +}; + +class VCL_DLLPUBLIC CommandSwipeData +{ + double mnVelocityX; +public: + CommandSwipeData() + : mnVelocityX(0) + { + } + CommandSwipeData(double nVelocityX) + : mnVelocityX(nVelocityX) + { + } + double getVelocityX() const { return mnVelocityX; } +}; + + +class VCL_DLLPUBLIC CommandLongPressData +{ + double mnX; + double mnY; +public: + CommandLongPressData() + : mnX(0) + , mnY(0) + { + } + CommandLongPressData(double nX, double nY) + : mnX(nX) + , mnY(nY) + { + } + double getX() const { return mnX; } + double getY() const { return mnY; } +}; + +class VCL_DLLPUBLIC CommandGestureData +{ +public: + double const mfX; + double const mfY; + double const mfOffset; + GestureEventType const meEventType; + PanningOrientation const meOrientation; + + CommandGestureData(double fX, double fY, GestureEventType eEventType, double fOffset, PanningOrientation eOrientation) + : mfX(fX) + , mfY(fY) + , mfOffset(fOffset) + , meEventType(eEventType) + , meOrientation(eOrientation) + {} +}; + +enum class CommandEventId +{ + NONE = 0, + ContextMenu = 1, + StartDrag = 2, + Wheel = 3, + StartAutoScroll = 4, + AutoScroll = 5, + StartExtTextInput = 7, + ExtTextInput = 8, + EndExtTextInput = 9, + InputContextChange = 10, + CursorPos = 11, + PasteSelection = 12, + ModKeyChange = 13, + InputLanguageChange = 15, + ShowDialog = 16, + Media = 17, + SelectionChange = 18, + PrepareReconversion = 19, + QueryCharPosition = 20, + Swipe = 21, + LongPress = 22, + Gesture = 23, +}; + +#endif // INCLUDED_VCL_COMMANDEVENT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/commandinfoprovider.hxx b/include/vcl/commandinfoprovider.hxx new file mode 100644 index 000000000..016e53f79 --- /dev/null +++ b/include/vcl/commandinfoprovider.hxx @@ -0,0 +1,107 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_VCL_COMMANDINFOPROVIDER_HXX +#define INCLUDED_VCL_COMMANDINFOPROVIDER_HXX + +#include <vcl/dllapi.h> +#include <vcl/image.hxx> +#include <vcl/keycod.hxx> + +namespace com::sun::star::frame { class XFrame; } +namespace com::sun::star::beans { struct PropertyValue; } + +namespace vcl::CommandInfoProvider { + + /** Return a label for the given command. + @param rsCommandName + The command name is expected to start with .uno: + @param rsModuleName + The current application module. + @return + The command properties. + */ + VCL_DLLPUBLIC css::uno::Sequence<css::beans::PropertyValue> GetCommandProperties(const OUString& rsCommandName, const OUString& rsModuleName); + + /** Return a label for the given command. + @param rProperties + The properties from GetCommandProperties. + @return + The command label. + */ + VCL_DLLPUBLIC OUString GetLabelForCommand(const css::uno::Sequence<css::beans::PropertyValue>& rProperties); + + VCL_DLLPUBLIC OUString GetMenuLabelForCommand(const css::uno::Sequence<css::beans::PropertyValue>& rProperties); + + VCL_DLLPUBLIC OUString GetPopupLabelForCommand(const css::uno::Sequence<css::beans::PropertyValue>& rProperties); + + VCL_DLLPUBLIC OUString GetTooltipLabelForCommand(const css::uno::Sequence<css::beans::PropertyValue>& rProperties); + + /** Return a tooltip for the given command. Falls back to label if command has no tooltip. + @param rsCommandName + The command name is expected to start with .uno: + @param rProperties + The properties from GetCommandProperties. + @param rxFrame + The frame is used to identify the module and document. + @return + The returned label contains the keyboard accelerator, if + one is defined and bIncludeShortcut is true. + */ + VCL_DLLPUBLIC OUString GetTooltipForCommand ( + const OUString& rsCommandName, + const css::uno::Sequence<css::beans::PropertyValue>& rProperties, + const css::uno::Reference<css::frame::XFrame>& rxFrame); + + /** Returns the shortcut for a command in human-readable form */ + VCL_DLLPUBLIC OUString GetCommandShortcut (const OUString& rCommandName, + const css::uno::Reference<css::frame::XFrame>& rxFrame); + + VCL_DLLPUBLIC KeyCode GetCommandKeyCodeShortcut (const OUString& rCommandName, + const css::uno::Reference<css::frame::XFrame>& rxFrame); + + VCL_DLLPUBLIC OUString GetRealCommandForCommand(const css::uno::Sequence<css::beans::PropertyValue>& rProperties); + + VCL_DLLPUBLIC css::uno::Reference<css::graphic::XGraphic> GetXGraphicForCommand( + const OUString& rsCommandName, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + vcl::ImageType eImageType = vcl::ImageType::Small); + + VCL_DLLPUBLIC Image GetImageForCommand( + const OUString& rsCommandName, + const css::uno::Reference<css::frame::XFrame>& rxFrame, + vcl::ImageType eImageType = vcl::ImageType::Small); + + VCL_DLLPUBLIC sal_Int32 GetPropertiesForCommand( + const OUString& rsCommandName, + const OUString& rsModuleName); + + VCL_DLLPUBLIC bool IsRotated(const OUString& rsCommandName, const OUString& rsModuleName); + VCL_DLLPUBLIC bool IsMirrored(const OUString& rsCommandName, const OUString& rsModuleName); + + /** Returns whether the command is experimental. */ + VCL_DLLPUBLIC bool IsExperimental( + const OUString& rsCommandName, + const OUString& rModuleName); + + VCL_DLLPUBLIC OUString GetModuleIdentifier(const css::uno::Reference<css::frame::XFrame>& rxFrame); +} + +#endif // INCLUDED_VCL_COMMANDINFOPROVIDER_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/ctrl.hxx b/include/vcl/ctrl.hxx new file mode 100644 index 000000000..a6797cc73 --- /dev/null +++ b/include/vcl/ctrl.hxx @@ -0,0 +1,239 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_CTRL_HXX +#define INCLUDED_VCL_CTRL_HXX + +#include <rtl/ustring.hxx> +#include <tools/link.hxx> +#include <tools/gen.hxx> +#include <vcl/dllapi.h> +#include <vcl/window.hxx> +#include <optional> +#include <vector> + +// forward +class StyleSettings; +class Control; + +namespace vcl +{ + +struct VCL_DLLPUBLIC ControlLayoutData +{ + // contains the string really displayed + // there must be exactly one bounding rectangle in m_aUnicodeBoundRects + // for every character in m_aDisplayText + OUString m_aDisplayText; + // the bounding rectangle of every character + // where one character may consist of many glyphs + std::vector< tools::Rectangle > m_aUnicodeBoundRects; + // start indices of lines + std::vector< tools::Long > m_aLineIndices; + // notify parent control on destruction + VclPtr<const Control> m_pParent; + + ControlLayoutData(); + ~ControlLayoutData(); + + tools::Rectangle GetCharacterBounds( tools::Long nIndex ) const; + // returns the character index for corresponding to rPoint (in control coordinates) + // -1 is returned if no character is at that point + tools::Long GetIndexForPoint( const Point& rPoint ) const; + // returns the number of lines in the result of GetDisplayText() + tools::Long GetLineCount() const; + // returns the interval [start,end] of line nLine + // returns [-1,-1] for an invalid line + ::Pair GetLineStartEnd( tools::Long nLine ) const; + /** ToRelativeLineIndex changes a layout data index to a count relative to its line. + + This is equivalent to getting the line start/end pairs with + GetLineStartEnd until the index lies within [start,end] of a line + + @param nIndex + the absolute index inside the display text to be changed to a relative index + + @returns + the relative index inside the displayed line or -1 if the absolute index does + not match any line + */ + tools::Long ToRelativeLineIndex( tools::Long nIndex ) const; +}; + +} // namespace vcl + +class VCL_DLLPUBLIC Control : public vcl::Window +{ +protected: + mutable std::optional<vcl::ControlLayoutData> mxLayoutData; + VclPtr<OutputDevice> mpReferenceDevice; + +private: + bool mbHasControlFocus; + bool mbShowAccelerator; + Link<Control&,void> maLoseFocusHdl; + + SAL_DLLPRIVATE void ImplInitControlData(); + + Control (const Control &) = delete; + Control & operator= (const Control &) = delete; + +protected: + Control( WindowType nType ); + virtual void FillLayoutData() const; + + // helper method for composite controls + void AppendLayoutData( const Control& rSubControl ) const; + + /// creates the mpData->mpLayoutData structure + void CreateLayoutData() const; + /// determines whether we currently have layout data + bool HasLayoutData() const; + + /** this calls both our event listeners, and a specified handler + + If the Control instance is destroyed during any of those calls, the + method properly handles this (in particular, it doesn't crash :) + + @param nEvent + the event to notify to our event listeners + @param callHandler + the lambda function that calls the handler + @return + if the Control instance has been destroyed in any of the call + */ + bool ImplCallEventListenersAndHandler( + VclEventId nEvent, std::function<void()> const & callHandler + ); + + void CallEventListeners( VclEventId nEvent, void* pData = nullptr ); + + /** draws the given text onto the given device + + If no reference device is set, the draw request will simply be forwarded to OutputDevice::DrawText. Otherwise, + the text will be rendered according to the metrics at the reference device. + + return will contain the result of a GetTextRect call (either directly + at the target device, or taking the reference device into account) when + returning. + */ + tools::Rectangle DrawControlText( OutputDevice& _rTargetDevice, const tools::Rectangle& _rRect, + const OUString& _rStr, DrawTextFlags _nStyle, + std::vector< tools::Rectangle >* _pVector, OUString* _pDisplayText, + const Size* i_pDeviceSize = nullptr ) const; + + tools::Rectangle GetControlTextRect( OutputDevice& _rTargetDevice, const tools::Rectangle & rRect, + const OUString& _rStr, DrawTextFlags _nStyle, + Size* o_pDeviceSize = nullptr ) const; + + virtual const vcl::Font& + GetCanonicalFont( const StyleSettings& _rStyle ) const; + virtual const Color& + GetCanonicalTextColor( const StyleSettings& _rStyle ) const; + + void ImplInitSettings(); + + virtual void ApplySettings(vcl::RenderContext& rRenderContext) override; + +public: + SAL_DLLPRIVATE void ImplClearLayoutData() const; + /** draws a frame around the give rectangle, onto the given device + + only to be used from within the Window::Draw method of your sub class. + + The frame is always drawn with a single line (without 3D effects). In addition, any mono + color set at the control's settings is respected. Yet more additionally, if we're living + in a themed desktop, this theming is ignored. + + Note that this makes sense, since the *only known* clients of Window::Draw + are form controls, when printed or print-previewed. For form controls embedded in office documents, + you don't want to have the theme look. + + @param pDev + the device to draw onto + @param rRect + the rect for drawing the frame. Upon returning from the call, the rect will be inflated + by the space occupied by the drawn pixels. + */ + SAL_DLLPRIVATE void ImplDrawFrame( OutputDevice* pDev, tools::Rectangle& rRect ); + +public: + explicit Control( vcl::Window* pParent, WinBits nWinStyle = 0 ); + virtual ~Control() override; + virtual void dispose() override; + + virtual void EnableRTL ( bool bEnable = true ) override; + + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void StateChanged( StateChangedType nStateChange ) override; + virtual void Resize() override; + + // invalidates layout data + virtual void SetText( const OUString& rStr ) override; + // gets the displayed text + virtual OUString GetDisplayText() const override; + // returns the bounding box for the character at index nIndex (in control coordinates) + tools::Rectangle GetCharacterBounds( tools::Long nIndex ) const; + // returns the character index for corresponding to rPoint (in control coordinates) + // -1 is returned if no character is at that point + tools::Long GetIndexForPoint( const Point& rPoint ) const; + // returns the interval [start,end] of line nLine + // returns [-1,-1] for an invalid line + Pair GetLineStartEnd( tools::Long nLine ) const; + /** ToRelativeLineIndex changes a layout data index to a count relative to its line. + + This is equivalent to getting the line start/end pairs with + GetLineStartEnd() until the index lies within [start,end] of a line + + @param nIndex + the absolute index inside the display text to be changed to a relative index + + @returns + the relative index inside the displayed line or -1 if the absolute index does + not match any line + */ + tools::Long ToRelativeLineIndex( tools::Long nIndex ) const; + + void SetLoseFocusHdl( const Link<Control&,void>& rLink ) { maLoseFocusHdl = rLink; } + + /** determines whether the control currently has the focus + */ + bool HasControlFocus() const { return mbHasControlFocus; } + + void SetLayoutDataParent( const Control* pParent ) const; + + virtual Size GetOptimalSize() const override; + + /** sets a reference device used for rendering control text + @see DrawControlText + */ + void SetReferenceDevice( OutputDevice* _referenceDevice ); + OutputDevice* GetReferenceDevice() const; + + vcl::Font GetUnzoomedControlPointFont() const; + void SetShowAccelerator (bool val); + + void LogicMouseButtonDown(const MouseEvent& rMouseEvent) override; + void LogicMouseButtonUp(const MouseEvent& rMouseEvent) override; + void LogicMouseMove(const MouseEvent& rMouseEvent) override; +}; + +#endif // INCLUDED_VCL_CTRL_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/cursor.hxx b/include/vcl/cursor.hxx new file mode 100644 index 000000000..b6adf4926 --- /dev/null +++ b/include/vcl/cursor.hxx @@ -0,0 +1,113 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_CURSOR_HXX +#define INCLUDED_VCL_CURSOR_HXX + +#include <tools/gen.hxx> +#include <tools/link.hxx> +#include <vcl/dllapi.h> +#include <vcl/vclptr.hxx> +#include <rtl/ustring.hxx> +#include <memory> + +class Timer; +struct ImplCursorData; +class OutputDevice; +namespace vcl { class Window; } + +// Cursor styles +#define CURSOR_SHADOW (sal_uInt16(0x0001)) + +enum class CursorDirection +{ + NONE, LTR, RTL +}; + +namespace vcl +{ + +class VCL_DLLPUBLIC Cursor +{ +private: + std::unique_ptr<ImplCursorData> mpData; + VclPtr<vcl::Window> mpWindow; // only for shadow cursor + Size maSize; + Point maPos; + Degree10 mnOrientation; + sal_uInt16 mnStyle; + bool mbVisible; + CursorDirection mnDirection; + +public: + SAL_DLLPRIVATE void ImplDraw(); + DECL_DLLPRIVATE_LINK( ImplTimerHdl, Timer*, void ); + SAL_DLLPRIVATE void ImplShow(); + SAL_DLLPRIVATE void ImplHide(); + SAL_DLLPRIVATE void ImplResume( bool bRestore = false ); + SAL_DLLPRIVATE bool ImplSuspend(); + SAL_DLLPRIVATE void ImplNew(); + +public: + Cursor(); + Cursor( const Cursor& rCursor ); + ~Cursor(); + + void SetStyle( sal_uInt16 nStyle ); + sal_uInt16 GetStyle() const { return mnStyle; } + + void Show(); + void Hide(); + bool IsVisible() const { return mbVisible; } + + void SetWindow( vcl::Window* pWindow ); + + void SetPos( const Point& rNewPos ); + const Point& GetPos() const { return maPos; } + + void SetSize( const Size& rNewSize ); + const Size& GetSize() const { return maSize; } + void SetWidth( tools::Long nNewWidth ); + tools::Long GetWidth() const { return maSize.Width(); } + tools::Long GetHeight() const { return maSize.Height(); } + + void SetOrientation( Degree10 nOrientation = 0_deg10 ); + + void SetDirection( CursorDirection nDirection = CursorDirection::NONE ); + + Cursor& operator=( const Cursor& rCursor ); + bool operator==( const Cursor& rCursor ) const; + bool operator!=( const Cursor& rCursor ) const + { return !(Cursor::operator==( rCursor )); } + + void DrawToDevice(OutputDevice& rRenderContext); + +private: + void LOKNotify( vcl::Window* pWindow, const OUString& rAction ); + bool ImplPrepForDraw(const OutputDevice* pDevice, ImplCursorData& rData); + void ImplRestore(); + void ImplDoShow( bool bDrawDirect, bool bRestore ); + bool ImplDoHide( bool bStop ); +}; + +} // namespace vcl + +#endif // INCLUDED_VCL_CURSOR_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/customweld.hxx b/include/vcl/customweld.hxx new file mode 100644 index 000000000..e37555b36 --- /dev/null +++ b/include/vcl/customweld.hxx @@ -0,0 +1,191 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_CUSTOMWELD_HXX +#define INCLUDED_VCL_CUSTOMWELD_HXX + +#include <vcl/weld.hxx> + +class InputContext; + +namespace weld +{ +class VCL_DLLPUBLIC CustomWidgetController +{ +private: + Size m_aSize; + weld::DrawingArea* m_pDrawingArea; + DECL_LINK(DragBeginHdl, weld::DrawingArea&, bool); + +public: + virtual css::uno::Reference<css::accessibility::XAccessible> CreateAccessible() + { + return css::uno::Reference<css::accessibility::XAccessible>(); + } + // rRect is in Logical units rather than Pixels + virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) = 0; + virtual void Resize() {} + virtual bool MouseButtonDown(const MouseEvent&) { return false; } + virtual bool MouseMove(const MouseEvent&) { return false; } + virtual bool MouseButtonUp(const MouseEvent&) { return false; } + virtual void GetFocus() {} + virtual void LoseFocus() {} + virtual void StyleUpdated() { Invalidate(); } + virtual bool Command(const CommandEvent&) { return false; } + virtual bool KeyInput(const KeyEvent&) { return false; } + virtual tools::Rectangle GetFocusRect() { return tools::Rectangle(); } + virtual FactoryFunction GetUITestFactory() const { return nullptr; } + virtual OUString RequestHelp(tools::Rectangle&) { return OUString(); } + virtual OUString GetHelpText() const { return m_pDrawingArea->get_tooltip_text(); } + Size const& GetOutputSizePixel() const { return m_aSize; } + void SetOutputSizePixel(const Size& rSize) { m_aSize = rSize; } + virtual void SetDrawingArea(weld::DrawingArea* pDrawingArea) { m_pDrawingArea = pDrawingArea; } + weld::DrawingArea* GetDrawingArea() const { return m_pDrawingArea; } + void Invalidate() + { + if (!m_pDrawingArea) + return; + m_pDrawingArea->queue_draw(); + } + static bool IsUpdateMode() { return true; } + void Invalidate(const tools::Rectangle& rRect) + { + if (!m_pDrawingArea) + return; + m_pDrawingArea->queue_draw_area(rRect.Left(), rRect.Top(), rRect.GetWidth(), + rRect.GetHeight()); + } + virtual void Show() { m_pDrawingArea->show(); } + virtual void Hide() { m_pDrawingArea->hide(); } + void GrabFocus() { m_pDrawingArea->grab_focus(); } + bool HasFocus() const { return m_pDrawingArea->has_focus(); } + bool HasChildFocus() const { return m_pDrawingArea->has_child_focus(); } + bool IsVisible() const { return m_pDrawingArea->get_visible(); } + bool IsReallyVisible() const { return m_pDrawingArea->is_visible(); } + bool IsEnabled() const { return m_pDrawingArea->get_sensitive(); } + void Enable() const { m_pDrawingArea->set_sensitive(true); } + void Disable() const { m_pDrawingArea->set_sensitive(false); } + bool IsActive() const { return m_pDrawingArea->is_active(); } + int GetTextHeight() const { return m_pDrawingArea->get_text_height(); } + int GetTextWidth(const OUString& rText) const + { + return m_pDrawingArea->get_pixel_size(rText).Width(); + } + OUString GetAccessibleName() const { return m_pDrawingArea->get_accessible_name(); } + OUString GetAccessibleDescription() const + { + return m_pDrawingArea->get_accessible_description(); + } + void CaptureMouse() { m_pDrawingArea->grab_add(); } + bool IsMouseCaptured() const { return m_pDrawingArea->has_grab(); } + Point GetPointerPosPixel() const { return m_pDrawingArea->get_pointer_position(); } + void EnableRTL(bool bEnable) { m_pDrawingArea->set_direction(bEnable); } + bool IsRTLEnabled() const { return m_pDrawingArea->get_direction(); } + void ReleaseMouse() { m_pDrawingArea->grab_remove(); } + void SetPointer(PointerStyle ePointerStyle) { m_pDrawingArea->set_cursor(ePointerStyle); } + void SetHelpId(const OString& rHelpId) { m_pDrawingArea->set_help_id(rHelpId); } + void SetAccessibleName(const OUString& rName) { m_pDrawingArea->set_accessible_name(rName); } + void SetInputContext(const InputContext& rInputContext) + { + m_pDrawingArea->set_input_context(rInputContext); + } + void SetCursorRect(const tools::Rectangle& rCursorRect, int nExtTextInputWidth) + { + m_pDrawingArea->im_context_set_cursor_location(rCursorRect, nExtTextInputWidth); + } + virtual int GetSurroundingText(OUString& /*rSurrounding*/) { return -1; } + virtual bool DeleteSurroundingText(const Selection& /*rRange*/) { return false; } + css::uno::Reference<css::datatransfer::dnd::XDropTarget> GetDropTarget() + { + return m_pDrawingArea->get_drop_target(); + } + css::uno::Reference<css::datatransfer::clipboard::XClipboard> GetClipboard() const + { + return m_pDrawingArea->get_clipboard(); + } + void SetDragDataTransferrable(rtl::Reference<TransferDataContainer>& rTransferrable, + sal_uInt8 eDNDConstants) + { + m_pDrawingArea->enable_drag_source(rTransferrable, eDNDConstants); + m_pDrawingArea->connect_drag_begin(LINK(this, CustomWidgetController, DragBeginHdl)); + } + // return true to disallow drag, false to allow + virtual bool StartDrag() { return false; } + void set_size_request(int nWidth, int nHeight) + { + m_pDrawingArea->set_size_request(nWidth, nHeight); + } + void queue_resize() + { + if (!m_pDrawingArea) + return; + m_pDrawingArea->queue_resize(); + } + CustomWidgetController() + : m_pDrawingArea(nullptr) + { + } + virtual ~CustomWidgetController(); + + CustomWidgetController(CustomWidgetController const&) = default; + CustomWidgetController(CustomWidgetController&&) = default; + CustomWidgetController& operator=(CustomWidgetController const&) = default; + CustomWidgetController& operator=(CustomWidgetController&&) = default; +}; + +class VCL_DLLPUBLIC CustomWeld final +{ +private: + weld::CustomWidgetController& m_rWidgetController; + std::unique_ptr<weld::DrawingArea> m_xDrawingArea; + + DECL_DLLPRIVATE_LINK(DoResize, const Size& rSize, void); + DECL_DLLPRIVATE_LINK(DoPaint, weld::DrawingArea::draw_args, void); + DECL_DLLPRIVATE_LINK(DoMouseButtonDown, const MouseEvent&, bool); + DECL_DLLPRIVATE_LINK(DoMouseMove, const MouseEvent&, bool); + DECL_DLLPRIVATE_LINK(DoMouseButtonUp, const MouseEvent&, bool); + DECL_DLLPRIVATE_LINK(DoGetFocus, weld::Widget&, void); + DECL_DLLPRIVATE_LINK(DoLoseFocus, weld::Widget&, void); + DECL_DLLPRIVATE_LINK(DoKeyPress, const KeyEvent&, bool); + DECL_DLLPRIVATE_LINK(DoFocusRect, weld::Widget&, tools::Rectangle); + DECL_DLLPRIVATE_LINK(DoCommand, const CommandEvent&, bool); + DECL_DLLPRIVATE_LINK(DoStyleUpdated, weld::Widget&, void); + DECL_DLLPRIVATE_LINK(DoRequestHelp, tools::Rectangle&, OUString); + DECL_DLLPRIVATE_LINK(DoGetSurrounding, OUString&, int); + DECL_DLLPRIVATE_LINK(DoDeleteSurrounding, const Selection&, bool); + +public: + CustomWeld(weld::Builder& rBuilder, const OString& rDrawingId, + CustomWidgetController& rWidgetController); + void queue_draw() { m_xDrawingArea->queue_draw(); } + void queue_draw_area(int x, int y, int width, int height) + { + m_xDrawingArea->queue_draw_area(x, y, width, height); + } + void set_size_request(int nWidth, int nHeight) + { + m_xDrawingArea->set_size_request(nWidth, nHeight); + } + void show() { m_xDrawingArea->show(); } + void hide() { m_xDrawingArea->hide(); } + void set_margin_top(int nMargin) { m_xDrawingArea->set_margin_top(nMargin); } + void set_margin_bottom(int nMargin) { m_xDrawingArea->set_margin_bottom(nMargin); } + void set_sensitive(bool bSensitive) { m_xDrawingArea->set_sensitive(bSensitive); } + bool get_sensitive() const { return m_xDrawingArea->get_sensitive(); } + bool get_visible() const { return m_xDrawingArea->get_visible(); } + void set_visible(bool bVisible) { m_xDrawingArea->set_visible(bVisible); } + void set_grid_left_attach(int nAttach) { m_xDrawingArea->set_grid_left_attach(nAttach); } + int get_grid_left_attach() const { return m_xDrawingArea->get_grid_left_attach(); } + void set_help_id(const OString& rHelpId) { m_xDrawingArea->set_help_id(rHelpId); } + void set_tooltip_text(const OUString& rTip) { m_xDrawingArea->set_tooltip_text(rTip); } +}; +} +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/cvtgrf.hxx b/include/vcl/cvtgrf.hxx new file mode 100644 index 000000000..f3d2024e8 --- /dev/null +++ b/include/vcl/cvtgrf.hxx @@ -0,0 +1,50 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_CVTGRF_HXX +#define INCLUDED_VCL_CVTGRF_HXX + +#include <vcl/dllapi.h> +#include <tools/link.hxx> +#include <vcl/salctype.hxx> +#include <vcl/errcode.hxx> + + +class Graphic; + +class VCL_DLLPUBLIC GraphicConverter +{ +private: + + Link<ConvertData&,bool> maFilterHdl; + +public: + + GraphicConverter(); + + static ErrCode Import( SvStream& rIStm, Graphic& rGraphic, ConvertDataFormat nFormat = ConvertDataFormat::Unknown ); + static ErrCode Export( SvStream& rOStm, const Graphic& rGraphic, ConvertDataFormat nFormat ); + + void SetFilterHdl( const Link<ConvertData&,bool>& rLink ) { maFilterHdl = rLink; } + const Link<ConvertData&,bool>& GetFilterHdl() const { return maFilterHdl; } +}; + +#endif // INCLUDED_VCL_CVTGRF_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/decoview.hxx b/include/vcl/decoview.hxx new file mode 100644 index 000000000..4ab2fe70d --- /dev/null +++ b/include/vcl/decoview.hxx @@ -0,0 +1,95 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_DECOVIEW_HXX +#define INCLUDED_VCL_DECOVIEW_HXX + +#include <vcl/dllapi.h> +#include <vcl/outdev.hxx> +#include <vcl/vclptr.hxx> +#include <vcl/vclenum.hxx> +#include <o3tl/typed_flags_set.hxx> + +namespace tools { class Rectangle; } +class Point; +class Color; + +// Flags for DrawSymbol() +enum class DrawSymbolFlags +{ + NONE = 0x0000, + Mono = 0x0001, + Disable = 0x0002, +}; +namespace o3tl +{ + template<> struct typed_flags<DrawSymbolFlags> : is_typed_flags<DrawSymbolFlags, 0x03> {}; +} + +// Flags for DrawHighlightFrame() +enum class DrawHighlightFrameStyle +{ + In = 1, + Out = 2, +}; + +// Flags for DrawButton() +enum class DrawButtonFlags +{ + NONE = 0x0000, + Default = 0x0001, + NoLightBorder = 0x0002, + Pressed = 0x0004, + Checked = 0x0008, + DontKnow = 0x0010, + Mono = 0x0020, + Disabled = 0x0040, + Highlight = 0x0100, + Flat = 0x0200, + NoLeftLightBorder = 0x1000 +}; +namespace o3tl +{ + template<> struct typed_flags<DrawButtonFlags> : is_typed_flags<DrawButtonFlags, 0x137f> {}; +} + +class VCL_DLLPUBLIC DecorationView +{ +private: + VclPtr<OutputDevice> mpOutDev; + +public: + DecorationView(OutputDevice* pOutDev); + + void DrawSymbol( const tools::Rectangle& rRect, SymbolType eType, + const Color& rColor, DrawSymbolFlags nStyle = DrawSymbolFlags::NONE ); + void DrawFrame( const tools::Rectangle& rRect, + const Color& rLeftTopColor, + const Color& rRightBottomColor ); + void DrawHighlightFrame( const tools::Rectangle& rRect, + DrawHighlightFrameStyle nStyle ); + tools::Rectangle DrawFrame( const tools::Rectangle& rRect, DrawFrameStyle nStyle = DrawFrameStyle::Out, DrawFrameFlags nFlags = DrawFrameFlags::NONE ); + tools::Rectangle DrawButton( const tools::Rectangle& rRect, DrawButtonFlags nStyle ); + void DrawSeparator( const Point& rStart, const Point& rStop, bool bVertical = true ); + void DrawHandle(const tools::Rectangle& rRectangle); +}; + +#endif // INCLUDED_VCL_DECOVIEW_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/devicecoordinate.hxx b/include/vcl/devicecoordinate.hxx new file mode 100644 index 000000000..215f0ca74 --- /dev/null +++ b/include/vcl/devicecoordinate.hxx @@ -0,0 +1,27 @@ +/* -*- 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/. + */ + +#pragma once + +#include <config_vcl.h> + +#include <basegfx/point/b2dpoint.hxx> +typedef basegfx::B2DPoint DevicePoint; + +#if VCL_FLOAT_DEVICE_PIXEL + +typedef double DeviceCoordinate; + +#else /* !VCL_FLOAT_DEVICE_PIXEL */ + +typedef sal_Int32 DeviceCoordinate; + +#endif /* ! Carpet Cushion */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/dialoghelper.hxx b/include/vcl/dialoghelper.hxx new file mode 100644 index 000000000..eedc6d37a --- /dev/null +++ b/include/vcl/dialoghelper.hxx @@ -0,0 +1,35 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#include <vcl/dllapi.h> + +namespace vcl +{ +class Window; + +/* cancel dialogs that are a child of pParent + this is used by com.sun.star.embed.DocumentCloser which itself is only used by + extensions/source/activex/SOActiveX.cxx see extensions/source/activex/README.txt + possibly dubious if this actually works as expected +*/ +VCL_DLLPUBLIC void EndAllDialogs(vcl::Window const* pParent); + +/* returns true if a vcl PopupMenu is executing. Uses of this outside of vcl/toolkit + are possibly dubious. +*/ +VCL_DLLPUBLIC bool IsInPopupMenuExecute(); + +/* for LibreOffice kit */ +VCL_DLLPUBLIC void EnableDialogInput(vcl::Window* pDialog); +VCL_DLLPUBLIC void CloseTopLevel(vcl::Window* pDialog); +/// Pre-loads all modules containing UI information +VCL_DLLPUBLIC void VclBuilderPreload(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/dibtools.hxx b/include/vcl/dibtools.hxx new file mode 100644 index 000000000..6064491f8 --- /dev/null +++ b/include/vcl/dibtools.hxx @@ -0,0 +1,87 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_VCL_DIBTOOLS_HXX +#define INCLUDED_VCL_DIBTOOLS_HXX + +#include <vcl/dllapi.h> +#include <vcl/Scanline.hxx> + +// predefines + +class SvStream; +class BitmapEx; +class Bitmap; +class AlphaMask; + +// - Compression defines + +#define COMPRESS_NONE ( 0 ) +#define RLE_8 ( 1 ) +#define RLE_4 ( 2 ) +#define BITFIELDS ( 3UL ) +#define ZCOMPRESS ( ('S'|('D'<<8UL)) | 0x01000000UL ) /* == 'SD01' (binary) */ + +bool VCL_DLLPUBLIC ReadDIB( // ReadDIB(rBitmap, rIStm, true); + Bitmap& rTarget, + SvStream& rIStm, + bool bFileHeader, + bool bMSOFormat=false); + +bool VCL_DLLPUBLIC ReadDIBBitmapEx( + BitmapEx& rTarget, + SvStream& rIStm, + bool bFileHeader = true, + bool bMSOFormat = false); + +bool VCL_DLLPUBLIC ReadDIBV5( + Bitmap& rTarget, + AlphaMask& rTargetAlpha, + SvStream& rIStm); + +bool VCL_DLLPUBLIC ReadRawDIB( + BitmapEx& rTarget, + const unsigned char* pBuf, + const ScanlineFormat nFormat, + const int nHeight, + const int nStride); + + +bool VCL_DLLPUBLIC WriteDIB( + const Bitmap& rSource, + SvStream& rOStm, + bool bCompressed, + bool bFileHeader); + +// compressed, with file header +bool VCL_DLLPUBLIC WriteDIB( + const BitmapEx& rSource, + SvStream& rOStm, + bool bCompressed = true); + +bool VCL_DLLPUBLIC WriteDIBBitmapEx( + const BitmapEx& rSource, + SvStream& rOStm); + +// needed in emfio for emf/wmf migration +sal_uInt32 VCL_DLLPUBLIC getDIBV5HeaderSize(); + +#endif // INCLUDED_VCL_DIBTOOLS_HXX + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/dllapi.h b/include/vcl/dllapi.h new file mode 100644 index 000000000..ccfd5e3b8 --- /dev/null +++ b/include/vcl/dllapi.h @@ -0,0 +1,47 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_DLLAPI_H +#define INCLUDED_VCL_DLLAPI_H + +#include <sal/config.h> +#include <sal/types.h> + +#if defined VCL_DLLIMPLEMENTATION +#define VCL_DLLPUBLIC SAL_DLLPUBLIC_EXPORT +#else +#define VCL_DLLPUBLIC SAL_DLLPUBLIC_IMPORT +#endif +#define VCL_DLLPRIVATE SAL_DLLPRIVATE + +#if defined DLLIMPLEMENTATION_UITEST +#define UITEST_DLLPUBLIC SAL_DLLPUBLIC_EXPORT +#else +#define UITEST_DLLPUBLIC SAL_DLLPUBLIC_IMPORT +#endif + +#if (defined UNX && !defined MACOS) || defined _WIN32 +#define VCL_PLUGIN_PUBLIC VCL_DLLPUBLIC +#else +#define VCL_PLUGIN_PUBLIC SAL_DLLPRIVATE +#endif + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/dndhelp.hxx b/include/vcl/dndhelp.hxx new file mode 100644 index 000000000..511f2f453 --- /dev/null +++ b/include/vcl/dndhelp.hxx @@ -0,0 +1,110 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_DNDHELP_HXX +#define INCLUDED_VCL_DNDHELP_HXX + +#include <vcl/dllapi.h> +#include <cppuhelper/weak.hxx> +#include <com/sun/star/datatransfer/dnd/XDragGestureListener.hpp> +#include <com/sun/star/datatransfer/dnd/XDragSourceListener.hpp> +#include <com/sun/star/datatransfer/dnd/XDropTargetListener.hpp> + +namespace com::sun::star::datatransfer::dnd { + struct DragGestureEvent; + struct DragSourceDragEvent; + struct DragSourceDropEvent; + struct DragSourceEvent; + struct DropTargetDragEvent; + struct DropTargetDragEnterEvent; + struct DropTargetDropEvent; + struct DropTargetEvent; +} + +namespace vcl::unohelper +{ + +class VCL_DLLPUBLIC DragAndDropClient +{ +public: + virtual ~DragAndDropClient() COVERITY_NOEXCEPT_FALSE; + + // css::datatransfer::dnd::XDragGestureListener + /// @throws css::uno::RuntimeException + virtual void dragGestureRecognized( const css::datatransfer::dnd::DragGestureEvent& dge ); + + // css::datatransfer::dnd::XDragSourceListener + /// @throws css::uno::RuntimeException + virtual void dragDropEnd(const css::datatransfer::dnd::DragSourceDropEvent& dsde ); + + // css::datatransfer::dnd::XDropTargetListener + /// @throws css::uno::RuntimeException + virtual void drop( const css::datatransfer::dnd::DropTargetDropEvent& dtde ); + /// @throws css::uno::RuntimeException + virtual void dragEnter( const css::datatransfer::dnd::DropTargetDragEnterEvent& dtdee ); + /// @throws css::uno::RuntimeException + virtual void dragExit( const css::datatransfer::dnd::DropTargetEvent& dte ); + /// @throws css::uno::RuntimeException + virtual void dragOver( const css::datatransfer::dnd::DropTargetDragEvent& dtde ); +}; + +class DragAndDropWrapper final : + public css::datatransfer::dnd::XDragGestureListener, + public css::datatransfer::dnd::XDragSourceListener, + public css::datatransfer::dnd::XDropTargetListener, + public ::cppu::OWeakObject +{ +private: + DragAndDropClient* mpClient; + +public: + VCL_DLLPUBLIC DragAndDropWrapper( DragAndDropClient* pClient ); + virtual ~DragAndDropWrapper() override; + + // css::uno::XInterface + css::uno::Any SAL_CALL queryInterface( const css::uno::Type & rType ) override; + void SAL_CALL acquire() noexcept override { OWeakObject::acquire(); } + void SAL_CALL release() noexcept override { OWeakObject::release(); } + + // css::lang::XEventListener + void SAL_CALL disposing( const css::lang::EventObject& Source ) override; + + // css::datatransfer::dnd::XDragGestureListener + void SAL_CALL dragGestureRecognized( const css::datatransfer::dnd::DragGestureEvent& dge ) override; + + // css::datatransfer::dnd::XDragSourceListener + void SAL_CALL dragDropEnd( const css::datatransfer::dnd::DragSourceDropEvent& dsde ) override; + void SAL_CALL dragEnter( const css::datatransfer::dnd::DragSourceDragEvent& dsde ) override; + void SAL_CALL dragExit( const css::datatransfer::dnd::DragSourceEvent& dse ) override; + void SAL_CALL dragOver( const css::datatransfer::dnd::DragSourceDragEvent& dsde ) override; + void SAL_CALL dropActionChanged( const css::datatransfer::dnd::DragSourceDragEvent& dsde ) override; + + // css::datatransfer::dnd::XDropTargetListener + void SAL_CALL drop( const css::datatransfer::dnd::DropTargetDropEvent& dtde ) override; + void SAL_CALL dragEnter( const css::datatransfer::dnd::DropTargetDragEnterEvent& dtdee ) override; + void SAL_CALL dragExit( const css::datatransfer::dnd::DropTargetEvent& dte ) override; + void SAL_CALL dragOver( const css::datatransfer::dnd::DropTargetDragEvent& dtde ) override; + void SAL_CALL dropActionChanged( const css::datatransfer::dnd::DropTargetDragEvent& dtde ) override; +}; + +} // namespace vcl::unohelper + +#endif // INCLUDED_VCL_DNDHELP_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/dockingarea.hxx b/include/vcl/dockingarea.hxx new file mode 100644 index 000000000..40ffd2852 --- /dev/null +++ b/include/vcl/dockingarea.hxx @@ -0,0 +1,58 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_DOCKINGAREA_HXX +#define INCLUDED_VCL_DOCKINGAREA_HXX + +#include <config_options.h> +#include <vcl/window.hxx> +#include <memory> + +// A simple container for docked toolbars +// - its main purpose is theming support +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) DockingAreaWindow final : public vcl::Window +{ + class SAL_DLLPRIVATE ImplData; + +private: + std::unique_ptr<ImplData> mpImplData; + + DockingAreaWindow (const DockingAreaWindow &) = delete; + DockingAreaWindow & operator= (const DockingAreaWindow &) = delete; + +public: + explicit DockingAreaWindow( vcl::Window* pParent ); + virtual ~DockingAreaWindow() override; + virtual void dispose() override; + + void SetAlign( WindowAlign eNewAlign ); + WindowAlign GetAlign() const; + bool IsHorizontal() const; + + virtual void ApplySettings(vcl::RenderContext& rRenderContext) override; + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Resize() override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + virtual void StateChanged( StateChangedType nType ) override; + +}; + +#endif // INCLUDED_VCL_DOCKINGAREA_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/dockwin.hxx b/include/vcl/dockwin.hxx new file mode 100644 index 000000000..e6ce2b308 --- /dev/null +++ b/include/vcl/dockwin.hxx @@ -0,0 +1,255 @@ +/* -*- 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 . + */ + +#pragma once + +#include <vcl/dllapi.h> +#include <vcl/syswin.hxx> +#include <o3tl/deleter.hxx> +#include <memory> +#include <vector> + +class ToolBox; +class FloatingWindow; +enum class FloatWinPopupFlags; + +// data to be sent with docking events +struct DockingData +{ + Point maMousePos; // in + tools::Rectangle maTrackRect; // in/out + bool mbFloating; // out + + DockingData( const Point& rPt, const tools::Rectangle& rRect, bool b) : + maMousePos( rPt ), maTrackRect( rRect ), mbFloating( b ) + {}; +}; + +struct EndDockingData +{ + tools::Rectangle maWindowRect; // in + bool mbFloating; // in + bool mbCancelled; // in + + EndDockingData( const tools::Rectangle& rRect, bool b, bool bCancelled ) : + maWindowRect( rRect ), mbFloating( b ), mbCancelled( bCancelled ) + {}; +}; + +struct EndPopupModeData +{ + Point maFloatingPos; // in + bool mbTearoff; // in + + EndPopupModeData( const Point& rPos, bool bTearoff ) : + maFloatingPos( rPos ), mbTearoff( bTearoff ) + {}; +}; + +class ImplDockingWindowWrapper; + +class VCL_DLLPUBLIC DockingManager +{ + std::vector<std::unique_ptr<ImplDockingWindowWrapper, o3tl::default_delete<ImplDockingWindowWrapper>>> mvDockingWindows; + +public: + DockingManager(); + ~DockingManager(); + + DockingManager& operator=( DockingManager const & ) = delete; // MSVC2015 workaround + DockingManager( DockingManager const & ) = delete; // MSVC2015 workaround + + void AddWindow( const vcl::Window *pWin ); + void RemoveWindow( const vcl::Window *pWin ); + + ImplDockingWindowWrapper* GetDockingWindowWrapper( const vcl::Window *pWin ); + bool IsDockable( const vcl::Window *pWin ); + + bool IsFloating( const vcl::Window *pWin ); + void SetFloatingMode( const vcl::Window *pWin, bool bFloating ); + SystemWindow* GetFloatingWindow(const vcl::Window *pWin); + + void Lock( const vcl::Window *pWin ); + void Unlock( const vcl::Window *pWin ); + bool IsLocked( const vcl::Window *pWin ); + + void StartPopupMode( const vcl::Window *pWin, const tools::Rectangle& rRect, FloatWinPopupFlags nPopupModeFlags ); + void StartPopupMode( ToolBox *pParentToolBox, const vcl::Window *pWin ); + void StartPopupMode( ToolBox *pParentToolBox, const vcl::Window *pWin, FloatWinPopupFlags nPopupModeFlags ); + + void SetPopupModeEndHdl( const vcl::Window *pWindow, const Link<FloatingWindow*,void>& rLink ); + + bool IsInPopupMode( const vcl::Window *pWin ); + void EndPopupMode( const vcl::Window *pWin ); + + // required because those methods are not virtual in Window (!!!) and must + // be available from the toolkit + void SetPosSizePixel( vcl::Window const *pWin, tools::Long nX, tools::Long nY, + tools::Long nWidth, tools::Long nHeight, + PosSizeFlags nFlags ); + tools::Rectangle GetPosSizePixel( const vcl::Window *pWin ); +}; + + +class VCL_DLLPUBLIC DockingWindow + : public vcl::Window + , public VclBuilderContainer +{ + class SAL_DLLPRIVATE ImplData; +private: + VclPtr<FloatingWindow> mpFloatWin; + VclPtr<vcl::Window> mpOldBorderWin; + std::unique_ptr<ImplData> mpImplData; + Point maFloatPos; + Point maDockPos; + Point maMouseOff; + Size maMinOutSize; + tools::Long mnTrackX; + tools::Long mnTrackY; + tools::Long mnTrackWidth; + tools::Long mnTrackHeight; + sal_Int32 mnDockLeft; + sal_Int32 mnDockTop; + sal_Int32 mnDockRight; + sal_Int32 mnDockBottom; + WinBits mnFloatBits; + Idle maLayoutIdle; + bool mbDockCanceled:1, + mbDockable:1, + mbDocking:1, + mbDragFull:1, + mbLastFloatMode:1, + mbStartFloat:1, + mbDockBtn:1, + mbHideBtn:1, + mbIsCalculatingInitialLayoutSize:1; + +protected: + bool mbIsDeferredInit; + VclPtr<vcl::Window> mpDialogParent; +private: + + SAL_DLLPRIVATE void ImplInitDockingWindowData(); + SAL_DLLPRIVATE void setPosSizeOnContainee(); + DECL_DLLPRIVATE_LINK( ImplHandleLayoutTimerHdl, Timer*, void ); + + DockingWindow (const DockingWindow &) = delete; + DockingWindow & operator= (const DockingWindow &) = delete; + +protected: + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + SAL_DLLPRIVATE void ImplInitSettings(); + + SAL_DLLPRIVATE void DoInitialLayout(); + + void loadUI(vcl::Window* pParent, const OString& rID, const OUString& rUIXMLDescription, + const css::uno::Reference<css::frame::XFrame> &rFrame); + +public: + bool isLayoutEnabled() const; + void setOptimalLayoutSize(); + + //FIXME: is it okay to make this public? + void ImplStartDocking( const Point& rPos ); + SAL_DLLPRIVATE bool isDeferredInit() const { return mbIsDeferredInit; } + virtual void doDeferredInit(WinBits nBits); +protected: + DockingWindow( WindowType nType, const char* pIdleDebugName = "vcl::DockingWindow maLayoutIdle"); +public: + DockingWindow(vcl::Window* pParent, WinBits nStyle, const char* pIdleDebugName = "vcl::DockingWindow maLayoutIdle"); + DockingWindow(vcl::Window* pParent, const OString& rID, const OUString& rUIXMLDescription, + const char* pIdleDebugName = "vcl::DockingWindow maLayoutIdle", + const css::uno::Reference<css::frame::XFrame> &rFrame = css::uno::Reference<css::frame::XFrame>()); + virtual ~DockingWindow() override; + virtual void dispose() override; + + virtual void StartDocking(); + virtual bool Docking( const Point& rPos, tools::Rectangle& rRect ); + virtual void EndDocking( const tools::Rectangle& rRect, bool bFloatMode ); + virtual bool PrepareToggleFloatingMode(); + virtual void ToggleFloatingMode(); + + virtual void Resizing( Size& rSize ); + virtual bool Close(); + virtual void Tracking( const TrackingEvent& rTEvt ) override; + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + void SetMinOutputSizePixel( const Size& rSize ); + const Size& GetMinOutputSizePixel() const; + + void SetMaxOutputSizePixel( const Size& rSize ); + + bool IsDocking() const { return mbDocking; } + bool IsDockable() const { return mbDockable; } + bool IsDockingCanceled() const { return mbDockCanceled; } + + void SetFloatingMode( bool bFloatMode ); + bool IsFloatingMode() const; + SystemWindow* GetFloatingWindow() const; + + void SetFloatingPos( const Point& rNewPos ); + Point GetFloatingPos() const; + + void SetFloatStyle( WinBits nWinStyle ); + WinBits GetFloatStyle() const; + + virtual void setPosSizePixel( tools::Long nX, tools::Long nY, + tools::Long nWidth, tools::Long nHeight, + PosSizeFlags nFlags = PosSizeFlags::All ) override; + + Point GetPosPixel() const override; + Size GetSizePixel() const override; + void SetOutputSizePixel( const Size& rNewSize ) override; + Size GetOutputSizePixel() const; + + virtual void SetText( const OUString& rStr ) override; + virtual OUString GetText() const override; + virtual Size GetOptimalSize() const override; + virtual void queue_resize(StateChangedType eReason = StateChangedType::Layout) override; +}; + +class VCL_DLLPUBLIC DropdownDockingWindow : public DockingWindow +{ +protected: + VclPtr<vcl::Window> m_xBox; +public: + DropdownDockingWindow(vcl::Window* pParent, + const css::uno::Reference<css::frame::XFrame> &rFrame = css::uno::Reference<css::frame::XFrame>(), + bool bTearable = false); + virtual ~DropdownDockingWindow() override; + virtual void dispose() override; +}; + +class VCL_DLLPUBLIC ResizableDockingWindow : public DockingWindow +{ +protected: + VclPtr<vcl::Window> m_xBox; +public: + ResizableDockingWindow(vcl::Window* pParent, + const css::uno::Reference<css::frame::XFrame> &rFrame = css::uno::Reference<css::frame::XFrame>()); + void InvalidateChildSizeCache(); + ResizableDockingWindow(vcl::Window* pParent, WinBits nStyle); + virtual ~ResizableDockingWindow() override; + virtual void dispose() override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/embeddedfontshelper.hxx b/include/vcl/embeddedfontshelper.hxx new file mode 100644 index 000000000..4802c13a2 --- /dev/null +++ b/include/vcl/embeddedfontshelper.hxx @@ -0,0 +1,110 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_EMBEDDEDFONTSHELPER_HXX +#define INCLUDED_VCL_EMBEDDEDFONTSHELPER_HXX + +#include <vcl/dllapi.h> + +#include <rtl/ustring.hxx> +#include <tools/fontenum.hxx> +#include <tools/long.hxx> + +#include <string_view> +#include <vector> + +namespace com::sun::star::io { class XInputStream; } +namespace com::sun::star::uno { template <typename > class Reference; } + +/** + Helper functions for handling embedded fonts in documents. + +*/ +class VCL_DLLPUBLIC EmbeddedFontsHelper +{ +private: + std::vector<std::pair<OUString, OUString>> m_aAccumulatedFonts; + + /** + Adds the given font to the list of known fonts. The font is used only until application + exit. + + @param fontName name of the font (e.g. 'Times New Roman') + @param fileUrl URL of the font file + */ + static void activateFont( const OUString& fontName, const OUString& fileUrl ); + +public: + /// Specification of what kind of operation is allowed when embedding a font + enum class FontRights + { + ViewingAllowed, ///< Font may be embedded for viewing the document (but not editing) + EditingAllowed ///< Font may be embedded for editing document (implies viewing) + }; + + /** + Returns URL for a font file for the given font, or empty if it does not exist. + */ + static OUString fontFileUrl( + std::u16string_view familyName, FontFamily family, FontItalic italic, + FontWeight weight, FontPitch pitch, FontRights rights ); + + /** + Reads a font from the input stream, saves it to a temporary font file and adds it to the list of + fonts that activateFonts will activate. + @param stream stream of font data + @param fontName name of the font (e.g. 'Times New Roman') + @param extra additional text to use for name (e.g. to distinguish regular from bold, italic,...), "?" for unique + @param key key to xor the data with, from the start until the key's length (not repeated) + @param eot whether the data is compressed in Embedded OpenType format + */ + bool addEmbeddedFont( const css::uno::Reference< css::io::XInputStream >& stream, + const OUString& fontName, const char* extra, + std::vector< unsigned char > const & key, bool eot = false); + + /** + Returns a URL for a file where to store contents of a given temporary font. + The file may or not may not exist yet, and will be cleaned up automatically as appropriate. + Use activateTemporaryFont() to actually enable usage of the font. + + @param fontName name of the font (e.g. 'Times New Roman') + @param extra additional text to use for name (e.g. to distinguish regular from bold, italic,...), "?" for unique + */ + static OUString fileUrlForTemporaryFont( const OUString& fontName, const char* extra ); + + /** + Adds the accumulated fonts to the list of known fonts. The fonts are used only until application + exit. + */ + void activateFonts(); + + /** + Returns if the restrictions specified in the font (if present) allow embedding + the font for a particular purpose. + @param data font data + @param size size of the font data + @param rights type of operation to be allowed for the font + */ + static bool sufficientTTFRights( const void* data, tools::Long size, FontRights rights ); + + /** + Removes all temporary fonts in the path used by fileUrlForTemporaryFont(). + @internal + */ + static void clearTemporaryFontFiles(); + + ~EmbeddedFontsHelper() COVERITY_NOEXCEPT_FALSE + { + activateFonts(); + } +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/errcode.hxx b/include/vcl/errcode.hxx new file mode 100644 index 000000000..e43b6b65d --- /dev/null +++ b/include/vcl/errcode.hxx @@ -0,0 +1,279 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_ERRCODE_HXX +#define INCLUDED_VCL_ERRCODE_HXX + +#include <rtl/ustring.hxx> +#include <vcl/dllapi.h> +#include <ostream> + +/* + +01234567012345670123456701234567 +|| || || || | +Warning || || | + | || || || | + Dynamic || || | + | || || | + Subsystemarea| || | + | || | + | || | + | || | + Class| | + | | + | | + | | + Code +*/ + +#define ERRCODE_ERROR_MASK 0x3fffffffUL +#define ERRCODE_WARNING_MASK 0x80000000UL + +#define ERRCODE_CLASS_SHIFT 8 +#define ERRCODE_AREA_SHIFT 13 +#define ERRCODE_DYNAMIC_SHIFT 26 + +#define ERRCODE_CLASS_MASK (31UL << ERRCODE_CLASS_SHIFT) + +#define ERRCODE_DYNAMIC_COUNT 31UL +#define ERRCODE_DYNAMIC_MASK (31UL << ERRCODE_DYNAMIC_SHIFT) + +enum class ErrCodeArea; +enum class ErrCodeClass; + +enum class WarningFlag { Yes }; + +class SAL_WARN_UNUSED ErrCode final +{ +public: + explicit constexpr ErrCode(WarningFlag, ErrCodeArea nArea, ErrCodeClass nClass, sal_uInt16 nCode) + : m_value(ERRCODE_WARNING_MASK | (sal_uInt32(nArea) << ERRCODE_AREA_SHIFT) | (sal_uInt32(nClass) << ERRCODE_CLASS_SHIFT) | nCode) + { + assert(nCode <= 0xff && "code out of range"); + } + explicit constexpr ErrCode(ErrCodeArea nArea, ErrCodeClass nClass, sal_uInt16 nCode) + : m_value((sal_uInt32(nArea) << ERRCODE_AREA_SHIFT) | (sal_uInt32(nClass) << ERRCODE_CLASS_SHIFT) | nCode) + { + assert(nCode <= 0xff && "code out of range"); + } + explicit constexpr ErrCode(ErrCodeArea nArea, sal_uInt16 nClassAndCode) + : m_value((sal_uInt32(nArea) << ERRCODE_AREA_SHIFT) | nClassAndCode) {} + explicit constexpr ErrCode(sal_uInt32 nValue) + : m_value(nValue) {} + constexpr ErrCode() + : m_value(0) {} + + explicit operator sal_uInt32() const { return m_value; } + explicit operator bool() const { return m_value != 0; } + + bool operator<(ErrCode const & other) const { return m_value < other.m_value; } + bool operator<=(ErrCode const & other) const { return m_value <= other.m_value; } + bool operator>(ErrCode const & other) const { return m_value > other.m_value; } + bool operator>=(ErrCode const & other) const { return m_value >= other.m_value; } + bool operator==(ErrCode const & other) const { return m_value == other.m_value; } + bool operator!=(ErrCode const & other) const { return m_value != other.m_value; } + + /** convert to ERRCODE_NONE if it's a warning, else return the error */ + ErrCode IgnoreWarning() const { + return (m_value & ERRCODE_WARNING_MASK) + ? ErrCode(0) + : ErrCode(static_cast<sal_uInt32>(m_value & ERRCODE_ERROR_MASK)); + } + + bool IsWarning() const { + return m_value & ERRCODE_WARNING_MASK; + } + + ErrCode MakeWarning() const { + return ErrCode(m_value | ERRCODE_WARNING_MASK); + } + + bool IsError() const { + return m_value && !IsWarning(); + } + + bool IsDynamic() const { + return m_value & ERRCODE_DYNAMIC_MASK; + } + + sal_uInt32 GetDynamic() const { + return (m_value & ERRCODE_DYNAMIC_MASK) >> ERRCODE_DYNAMIC_SHIFT; + } + + ErrCode StripDynamic() const { + return ErrCode(m_value & ~ERRCODE_DYNAMIC_MASK); + } + + constexpr ErrCode StripWarningAndDynamic() const { + return ErrCode(m_value & ~(ERRCODE_DYNAMIC_MASK | ERRCODE_WARNING_MASK)); + } + + constexpr ErrCodeArea GetArea() const { + return static_cast<ErrCodeArea>((m_value >> ERRCODE_AREA_SHIFT) & 0x01fff); + } + + constexpr ErrCodeClass GetClass() const { + return static_cast<ErrCodeClass>((m_value >> ERRCODE_CLASS_SHIFT) & 0x1f); + } + + constexpr sal_uInt8 GetCode() const { + return static_cast<sal_uInt8>(m_value & 0xff); + } + + OUString toHexString() const { + return "0x" + OUString::number(m_value, 16); + } + + template <typename... Args> bool anyOf(Args... args) const + { + static_assert(sizeof...(args) > 0); + return (... || (*this == args)); + } + +private: + sal_uInt32 m_value; +}; + +VCL_DLLPUBLIC std::ostream& operator<<(std::ostream& os, const ErrCode& err); + +enum class ErrCodeArea { + Io = 0 , + Sfx = 2 , + Inet = 3 , + Vcl = 4 , + Svx = 8 , + So = 9 , + Sbx = 10, + Uui = 13, + Sc = 32, + Sd = 40, + Sw = 56, +}; + +enum class ErrCodeClass { + NONE = 0, + Abort = 1, + General = 2, + NotExists = 3, + AlreadyExists = 4, + Access = 5, + Path = 6, + Locking = 7, + Parameter = 8, + Space = 9, + NotSupported = 10, + Read = 11, + Write = 12, + Unknown = 13, + Version = 14, + Format = 15, + Create = 16, + Import = 17, + Export = 18, + So = 20, + Sbx = 21, + Runtime = 22, + Compiler = 23 +}; + +#define ERRCODE_NONE ErrCode(0) + +#define ERRCODE_IO_MISPLACEDCHAR ErrCode( ErrCodeArea::Io, ErrCodeClass::Parameter, 1 ) +#define ERRCODE_IO_NOTEXISTS ErrCode( ErrCodeArea::Io, ErrCodeClass::NotExists, 2 ) +#define ERRCODE_IO_ALREADYEXISTS ErrCode( ErrCodeArea::Io, ErrCodeClass::AlreadyExists, 3 ) +#define ERRCODE_IO_NOTADIRECTORY ErrCode( ErrCodeArea::Io, ErrCodeClass::Parameter, 4 ) +#define ERRCODE_IO_NOTAFILE ErrCode( ErrCodeArea::Io, ErrCodeClass::Parameter, 5 ) +#define ERRCODE_IO_INVALIDDEVICE ErrCode( ErrCodeArea::Io, ErrCodeClass::Path, 6 ) +#define ERRCODE_IO_ACCESSDENIED ErrCode( ErrCodeArea::Io, ErrCodeClass::Access, 7 ) +#define ERRCODE_IO_LOCKVIOLATION ErrCode( ErrCodeArea::Io, ErrCodeClass::Locking, 8 ) +#define ERRCODE_IO_OUTOFSPACE ErrCode( ErrCodeArea::Io, ErrCodeClass::Space, 9 ) +#define ERRCODE_IO_ISWILDCARD ErrCode( ErrCodeArea::Io, ErrCodeClass::Parameter, 11 ) +#define ERRCODE_IO_NOTSUPPORTED ErrCode( ErrCodeArea::Io, ErrCodeClass::NotSupported, 12 ) +#define ERRCODE_IO_GENERAL ErrCode( ErrCodeArea::Io, ErrCodeClass::General, 13 ) +#define ERRCODE_IO_TOOMANYOPENFILES ErrCode( ErrCodeArea::Io, ErrCodeClass::Space, 14 ) +#define ERRCODE_IO_CANTREAD ErrCode( ErrCodeArea::Io, ErrCodeClass::Read, 15 ) +#define ERRCODE_IO_CANTWRITE ErrCode( ErrCodeArea::Io, ErrCodeClass::Write, 16 ) +#define ERRCODE_IO_OUTOFMEMORY ErrCode( ErrCodeArea::Io, ErrCodeClass::Space, 17 ) +#define ERRCODE_IO_CANTSEEK ErrCode( ErrCodeArea::Io, ErrCodeClass::General, 18 ) +#define ERRCODE_IO_CANTTELL ErrCode( ErrCodeArea::Io, ErrCodeClass::General, 19 ) +#define ERRCODE_IO_WRONGVERSION ErrCode( ErrCodeArea::Io, ErrCodeClass::Version, 20 ) +#define ERRCODE_IO_WRONGFORMAT ErrCode( ErrCodeArea::Io, ErrCodeClass::Format, 21 ) +#define ERRCODE_IO_INVALIDCHAR ErrCode( ErrCodeArea::Io, ErrCodeClass::Parameter, 22 ) +#define ERRCODE_IO_UNKNOWN ErrCode( ErrCodeArea::Io, ErrCodeClass::Unknown, 23 ) +#define ERRCODE_IO_INVALIDACCESS ErrCode( ErrCodeArea::Io, ErrCodeClass::Access, 24 ) +#define ERRCODE_IO_CANTCREATE ErrCode( ErrCodeArea::Io, ErrCodeClass::Create, 25 ) +#define ERRCODE_IO_INVALIDPARAMETER ErrCode( ErrCodeArea::Io, ErrCodeClass::Parameter, 26 ) +#define ERRCODE_IO_ABORT ErrCode( ErrCodeArea::Io, ErrCodeClass::Abort, 27 ) +#define ERRCODE_IO_NOTEXISTSPATH ErrCode( ErrCodeArea::Io, ErrCodeClass::NotExists, 28 ) +#define ERRCODE_IO_PENDING ErrCode( ErrCodeArea::Io, ErrCodeClass::NotExists, 29 ) +#define ERRCODE_IO_RECURSIVE ErrCode( ErrCodeArea::Io, ErrCodeClass::Parameter, 30 ) +#define ERRCODE_IO_NAMETOOLONG ErrCode( ErrCodeArea::Io, ErrCodeClass::Parameter, 31 ) +#define ERRCODE_IO_INVALIDLENGTH ErrCode( ErrCodeArea::Io, ErrCodeClass::Parameter, 32 ) +#define ERRCODE_IO_CURRENTDIR ErrCode( ErrCodeArea::Io, ErrCodeClass::Parameter, 33 ) +#define ERRCODE_IO_NOTSAMEDEVICE ErrCode( ErrCodeArea::Io, ErrCodeClass::Parameter, 34 ) +#define ERRCODE_IO_DEVICENOTREADY ErrCode( ErrCodeArea::Io, ErrCodeClass::Read, 35 ) +#define ERRCODE_IO_BADCRC ErrCode( ErrCodeArea::Io, ErrCodeClass::Read, 36 ) +#define ERRCODE_IO_WRITEPROTECTED ErrCode( ErrCodeArea::Io, ErrCodeClass::Access, 37 ) +#define ERRCODE_IO_BROKENPACKAGE ErrCode( ErrCodeArea::Io, ErrCodeClass::Format, 38 ) +#define ERRCODE_IO_NOTSTORABLEINBINARYFORMAT ErrCode( ErrCodeArea::Io, ErrCodeClass::Format, 39 ) +#define ERRCODE_IO_FILTERDISABLED ErrCode( ErrCodeArea::Io, ErrCodeClass::Format, 40 ) + +// StreamErrorCodes + +#define SVSTREAM_GENERALERROR ERRCODE_IO_GENERAL +#define SVSTREAM_FILE_NOT_FOUND ERRCODE_IO_NOTEXISTS +#define SVSTREAM_PATH_NOT_FOUND ERRCODE_IO_NOTEXISTSPATH +#define SVSTREAM_TOO_MANY_OPEN_FILES ERRCODE_IO_TOOMANYOPENFILES +#define SVSTREAM_ACCESS_DENIED ERRCODE_IO_ACCESSDENIED +#define SVSTREAM_SHARING_VIOLATION ERRCODE_IO_LOCKVIOLATION +#define SVSTREAM_LOCKING_VIOLATION ERRCODE_IO_LOCKVIOLATION +#define SVSTREAM_SHARE_BUFF_EXCEEDED ERRCODE_IO_LOCKVIOLATION + +#define SVSTREAM_INVALID_ACCESS ERRCODE_IO_INVALIDACCESS +#define SVSTREAM_INVALID_HANDLE ERRCODE_IO_GENERAL +#define SVSTREAM_CANNOT_MAKE ERRCODE_IO_CANTCREATE +#define SVSTREAM_INVALID_PARAMETER ERRCODE_IO_INVALIDPARAMETER + +#define SVSTREAM_READ_ERROR ERRCODE_IO_CANTREAD +#define SVSTREAM_WRITE_ERROR ERRCODE_IO_CANTWRITE +#define SVSTREAM_SEEK_ERROR ERRCODE_IO_CANTSEEK + +#define SVSTREAM_OUTOFMEMORY ERRCODE_IO_OUTOFMEMORY + +#define SVSTREAM_FILEFORMAT_ERROR ERRCODE_IO_WRONGFORMAT +#define SVSTREAM_WRONGVERSION ERRCODE_IO_WRONGVERSION + +#define SVSTREAM_DISK_FULL ERRCODE_IO_OUTOFSPACE + +#define PRINTER_ABORT ERRCODE_IO_ABORT +#define PRINTER_GENERALERROR ERRCODE_IO_GENERAL + +#define ERRCODE_ABORT ERRCODE_IO_ABORT + +#define ERRCODE_INET_NAME_RESOLVE ErrCode(ErrCodeArea::Inet, ErrCodeClass::Read, 1) +#define ERRCODE_INET_CONNECT ErrCode(ErrCodeArea::Inet, ErrCodeClass::Read, 2) +#define ERRCODE_INET_READ ErrCode(ErrCodeArea::Inet, ErrCodeClass::Read, 3) +#define ERRCODE_INET_WRITE ErrCode(ErrCodeArea::Inet, ErrCodeClass::Write, 4) +#define ERRCODE_INET_GENERAL ErrCode(ErrCodeArea::Inet, ErrCodeClass::Write, 5) +#define ERRCODE_INET_OFFLINE ErrCode(ErrCodeArea::Inet, ErrCodeClass::Read, 6) + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/errinf.hxx b/include/vcl/errinf.hxx new file mode 100644 index 000000000..670c085cf --- /dev/null +++ b/include/vcl/errinf.hxx @@ -0,0 +1,229 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_ERRINF_HXX +#define INCLUDED_VCL_ERRINF_HXX + +#include <rtl/ustring.hxx> +#include <vcl/errcode.hxx> +#include <vcl/dllapi.h> +#include <o3tl/typed_flags_set.hxx> + +#include <vector> +#include <memory> + +#include <limits.h> + +namespace weld { class Window; } + +class ErrorHandler; +class ErrorContext; +class ErrorInfo; +class DynamicErrorInfo; +class ImplDynamicErrorInfo; +enum class DialogMask; + +class VCL_DLLPUBLIC ErrorStringFactory +{ +public: + static bool CreateString(const ErrorInfo*, OUString&); +}; + +typedef void (* DisplayFnPtr)(); + +typedef DialogMask WindowDisplayErrorFunc( + weld::Window*, DialogMask eMask, const OUString &rErr, const OUString &rAction); + +typedef void BasicDisplayErrorFunc( + const OUString &rErr, const OUString &rAction); + +class VCL_DLLPUBLIC ErrorRegistry +{ + friend class ErrorHandler; + friend class ErrorContext; + friend class ErrorStringFactory; + friend class ImplDynamicErrorInfo; + +public: + ErrorRegistry(); + + static void RegisterDisplay(BasicDisplayErrorFunc*); + static void RegisterDisplay(WindowDisplayErrorFunc*); + + static void SetLock(bool bLock); + static bool GetLock(); + + static void Reset(); + +private: + DisplayFnPtr pDsp; + bool bIsWindowDsp; + + bool m_bLock; + + sal_uInt16 nNextError; + + std::vector<ErrorHandler*> errorHandlers; + std::vector<ErrorContext*> contexts; + + DynamicErrorInfo* ppDynErrInfo[ERRCODE_DYNAMIC_COUNT]; +}; + +enum class DialogMask +{ + NONE = 0x0000, + ButtonsOk = 0x0001, + ButtonsCancel = 0x0002, + ButtonsRetry = 0x0004, + ButtonsNo = 0x0008, + ButtonsYes = 0x0010, + ButtonsYesNo = 0x0018, + + ButtonDefaultsOk = 0x0100, + ButtonDefaultsCancel = 0x0200, + ButtonDefaultsYes = 0x0300, + ButtonDefaultsNo = 0x0400, + + MessageError = 0x1000, + MessageWarning = 0x2000, + MessageInfo = 0x3000, + + MAX = USHRT_MAX, +}; +namespace o3tl +{ + template<> struct typed_flags<DialogMask> : is_typed_flags<DialogMask, 0xffff> {}; +} + +class SAL_WARN_UNUSED VCL_DLLPUBLIC ErrorHandler +{ + friend class ErrorStringFactory; + +public: + ErrorHandler(); + virtual ~ErrorHandler(); + + /** Handles an error. + + If nFlags is not set, the DynamicErrorInfo flags or the + resource flags will be used. Thus the order is: + + 1. nFlags, + 2. Resource Flags + 3. Dynamic Flags + 4. Default ButtonsOk, MessageError + + @param nErrCodeId error id + @param pParent parent window the error dialog will be modal for. nullptr for unrecommended "pick default" + @param nFlags error flags. + + @return what sort of dialog to use, with what buttons + */ + static DialogMask HandleError(ErrCode nId, weld::Window* pParent = nullptr, DialogMask nMask = DialogMask::MAX); + static bool GetErrorString(ErrCode nId, OUString& rStr); + +protected: + virtual bool CreateString(const ErrorInfo*, OUString &) const = 0; + +}; + +class SAL_WARN_UNUSED VCL_DLLPUBLIC ErrorInfo +{ +public: + ErrorInfo(ErrCode nArgUserId) : + nUserId(nArgUserId) {} + virtual ~ErrorInfo(); + + ErrCode const & GetErrorCode() const { return nUserId; } + + static std::unique_ptr<ErrorInfo> GetErrorInfo(ErrCode); + +private: + ErrCode nUserId; +}; + +class SAL_WARN_UNUSED VCL_DLLPUBLIC DynamicErrorInfo : public ErrorInfo +{ + friend class ImplDynamicErrorInfo; + +public: + DynamicErrorInfo(ErrCode nUserId, DialogMask nMask); + virtual ~DynamicErrorInfo() override; + + operator ErrCode() const; + DialogMask GetDialogMask() const; + +private: + std::unique_ptr<ImplDynamicErrorInfo> pImpl; + +}; + +class SAL_WARN_UNUSED VCL_DLLPUBLIC StringErrorInfo final : public DynamicErrorInfo +{ +public: + StringErrorInfo(ErrCode nUserId, + const OUString& aStringP, + DialogMask nMask = DialogMask::NONE); + + const OUString& GetErrorString() const { return aString; } + +private: + OUString aString; + +}; + +class SAL_WARN_UNUSED VCL_DLLPUBLIC TwoStringErrorInfo final : public DynamicErrorInfo +{ +public: + TwoStringErrorInfo(ErrCode nUserID, const OUString & rTheArg1, + const OUString & rTheArg2, DialogMask nMask): + DynamicErrorInfo(nUserID, nMask), aArg1(rTheArg1), aArg2(rTheArg2) {} + + const OUString& GetArg1() const { return aArg1; } + const OUString& GetArg2() const { return aArg2; } + +private: + OUString aArg1; + OUString aArg2; + +}; + +struct ImplErrorContext; + +class SAL_WARN_UNUSED VCL_DLLPUBLIC ErrorContext +{ + friend class ErrorHandler; + +public: + ErrorContext(weld::Window *pWin); + virtual ~ErrorContext(); + + virtual bool GetString(ErrCode nErrId, OUString& rCtxStr) = 0; + weld::Window* GetParent(); + + static ErrorContext* GetContext(); + +private: + std::unique_ptr<ImplErrorContext> pImpl; + +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/event.hxx b/include/vcl/event.hxx new file mode 100644 index 000000000..32ff5bcfa --- /dev/null +++ b/include/vcl/event.hxx @@ -0,0 +1,387 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_EVENT_HXX +#define INCLUDED_VCL_EVENT_HXX + +#include <vcl/dllapi.h> +#include <tools/gen.hxx> +#include <vcl/keycod.hxx> +#include <vcl/settings.hxx> +#include <vcl/vclptr.hxx> +#include <vcl/outdev.hxx> +#include <optional> + +class CommandEvent; + +enum class TextDirectionality { + LeftToRight_TopToBottom, + RightToLeft_TopToBottom, + TopToBottom_RightToLeft, + BottomToTop_LeftToRight +}; + +namespace vcl { + class Window; +} + +class VCL_DLLPUBLIC KeyEvent +{ +private: + vcl::KeyCode maKeyCode; + sal_uInt16 mnRepeat; + sal_Unicode mnCharCode; + +public: + KeyEvent(); + KeyEvent( sal_Unicode nChar, const vcl::KeyCode& rKeyCode, + sal_uInt16 nRepeat = 0 ); + + sal_Unicode GetCharCode() const { return mnCharCode; } + const vcl::KeyCode& GetKeyCode() const { return maKeyCode; } + sal_uInt16 GetRepeat() const { return mnRepeat; } + + KeyEvent LogicalTextDirectionality (TextDirectionality eMode) const; +}; + +inline KeyEvent::KeyEvent() +{ + mnCharCode = 0; + mnRepeat = 0; +} + +inline KeyEvent::KeyEvent( sal_Unicode nChar, const vcl::KeyCode& rKeyCode, + sal_uInt16 nRepeat ) : + maKeyCode( rKeyCode ) + +{ + mnCharCode = nChar; + mnRepeat = nRepeat; +} + + +enum class MouseEventModifiers +{ + NONE = 0, + // mouse move modifiers + SIMPLEMOVE = 0x0001, + DRAGMOVE = 0x0002, + DRAGCOPY = 0x0004, + ENTERWINDOW = 0x0010, + LEAVEWINDOW = 0x0020, + SYNTHETIC = 0x0040, + MODIFIERCHANGED = 0x0080, + // mouse up/down-button modifiers + SIMPLECLICK = 0x0100, + SELECT = 0x0200, + MULTISELECT = 0x0400, + RANGESELECT = 0x0800 +}; +namespace o3tl +{ + template<> struct typed_flags<MouseEventModifiers> : is_typed_flags<MouseEventModifiers, 0xff7> {}; +} + +// Mouse buttons +#define MOUSE_LEFT (sal_uInt16(0x0001)) +#define MOUSE_MIDDLE (sal_uInt16(0x0002)) +#define MOUSE_RIGHT (sal_uInt16(0x0004)) + +class VCL_DLLPUBLIC MouseEvent +{ +private: + Point maPos; + MouseEventModifiers mnMode; + sal_uInt16 mnClicks; + sal_uInt16 mnCode; + + // Set, if the document relative logic position are available + std::optional<Point> maLogicPosition; + +public: + explicit MouseEvent(); + explicit MouseEvent( const Point& rPos, sal_uInt16 nClicks = 1, + MouseEventModifiers nMode = MouseEventModifiers::NONE, sal_uInt16 nButtons = 0, + sal_uInt16 nModifier = 0 ); + + const Point& GetPosPixel() const { return maPos; } + MouseEventModifiers GetMode() const { return mnMode; } + + sal_uInt16 GetClicks() const { return mnClicks; } + + void setLogicPosition(Point aLogicPosition) + { + maLogicPosition = aLogicPosition; + } + + const std::optional<Point> & getLogicPosition() const + { + return maLogicPosition; + } + + bool IsEnterWindow() const + { return bool(mnMode & MouseEventModifiers::ENTERWINDOW); } + bool IsLeaveWindow() const + { return bool(mnMode & MouseEventModifiers::LEAVEWINDOW); } + bool IsSynthetic() const + { return bool(mnMode & MouseEventModifiers::SYNTHETIC); } + bool IsModifierChanged() const + { return bool(mnMode & MouseEventModifiers::MODIFIERCHANGED); } + + sal_uInt16 GetButtons() const + { return (mnCode & (MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT)); } + bool IsLeft() const + { return ((mnCode & MOUSE_LEFT) != 0); } + bool IsMiddle() const + { return ((mnCode & MOUSE_MIDDLE) != 0); } + bool IsRight() const + { return ((mnCode & MOUSE_RIGHT) != 0); } + + sal_uInt16 GetModifier() const + { return (mnCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2)); } + bool IsShift() const + { return ((mnCode & KEY_SHIFT) != 0); } + bool IsMod1() const + { return ((mnCode & KEY_MOD1) != 0); } + bool IsMod2() const + { return ((mnCode & KEY_MOD2) != 0); } + bool IsMod3() const + { return ((mnCode & KEY_MOD3) != 0); } +}; + +inline MouseEvent::MouseEvent() +{ + mnMode = MouseEventModifiers::NONE; + mnClicks = 0; + mnCode = 0; +} + +inline MouseEvent::MouseEvent( const Point& rPos, sal_uInt16 nClicks, + MouseEventModifiers nMode, + sal_uInt16 nButtons, sal_uInt16 nModifier ) : + maPos( rPos ) +{ + mnClicks = nClicks; + mnMode = nMode; + mnCode = nButtons | nModifier; +} + +enum class HelpEventMode +{ + NONE = 0x0000, + CONTEXT = 0x0001, + BALLOON = 0x0002, + QUICK = 0x0004 +}; +namespace o3tl +{ + template<> struct typed_flags<HelpEventMode> : is_typed_flags<HelpEventMode, 0x07> {}; +} + +class VCL_DLLPUBLIC HelpEvent +{ +private: + Point maPos; + HelpEventMode mnMode; + bool mbKeyboardActivated; + +public: + explicit HelpEvent( const Point& rMousePos, HelpEventMode nHelpMode ); + + const Point& GetMousePosPixel() const { return maPos; } + HelpEventMode GetMode() const { return mnMode; } + bool KeyboardActivated() const { return mbKeyboardActivated; } + void SetKeyboardActivated( bool bKeyboard ) { mbKeyboardActivated = bKeyboard; } +}; + +inline HelpEvent::HelpEvent( const Point& rMousePos, HelpEventMode nHelpMode ) : + maPos( rMousePos ) +{ + mnMode = nHelpMode; + mbKeyboardActivated = false; +} + +/// Event to pass information for UserDraw() handling eg. in comboboxes. +class VCL_DLLPUBLIC UserDrawEvent +{ +private: + /// RenderContext to which we should draw - can be a VirtualDevice or anything. + VclPtr<vcl::RenderContext> mpRenderContext; + + tools::Rectangle maOutRect; + sal_uInt16 mnItemId; + bool mbSelected; + +public: + UserDrawEvent(vcl::RenderContext* pRenderContext, + const tools::Rectangle& rOutRect, sal_uInt16 nId, bool bSelected = false) + : mpRenderContext(pRenderContext) + , maOutRect( rOutRect ) + , mnItemId(nId) + , mbSelected(bSelected) + { + } + + vcl::RenderContext* GetRenderContext() const { return mpRenderContext; } + const tools::Rectangle& GetRect() const { return maOutRect; } + sal_uInt16 GetItemId() const { return mnItemId; } + bool IsSelected() const { return mbSelected; } +}; + +class VCL_DLLPUBLIC TrackingEvent +{ +private: + MouseEvent maMEvt; + TrackingEventFlags mnFlags; + +public: + explicit TrackingEvent( const MouseEvent&, + TrackingEventFlags nTrackFlags = TrackingEventFlags::NONE ); + + const MouseEvent& GetMouseEvent() const { return maMEvt; } + + bool IsTrackingRepeat() const + { return bool(mnFlags & TrackingEventFlags::Repeat); } + bool IsTrackingEnded() const + { return bool(mnFlags & TrackingEventFlags::End); } + bool IsTrackingCanceled() const + { return bool(mnFlags & TrackingEventFlags::Cancel); } +}; + +inline TrackingEvent::TrackingEvent( const MouseEvent& rMEvt, + TrackingEventFlags nTrackFlags ) : + maMEvt( rMEvt ) +{ + mnFlags = nTrackFlags; +} + + +enum class MouseNotifyEvent +{ + NONE = 0, + MOUSEBUTTONDOWN = 1, + MOUSEBUTTONUP = 2, + MOUSEMOVE = 3, + KEYINPUT = 4, + KEYUP = 5, + GETFOCUS = 6, + LOSEFOCUS = 7, + COMMAND = 8 +}; + +class VCL_DLLPUBLIC NotifyEvent +{ +private: + VclPtr<vcl::Window> mpWindow; + void* mpData; + MouseNotifyEvent mnEventType; + +public: + NotifyEvent( MouseNotifyEvent nEventType, + vcl::Window* pWindow, + const void* pEvent = nullptr ); + ~NotifyEvent(); + // Avoid implicitly defined copy constructors/assignments for the + // DLLPUBLIC class (they may require forward-declared classes used + // internally to be defined in places using NotifyEvent) + NotifyEvent(const NotifyEvent&) = delete; + NotifyEvent(NotifyEvent&&) = delete; + NotifyEvent& operator=(const NotifyEvent&) = delete; + NotifyEvent& operator=(NotifyEvent&&) = delete; + + MouseNotifyEvent GetType() const { return mnEventType; } + vcl::Window* GetWindow() const { return mpWindow; } + void* GetData() const { return mpData; } + const KeyEvent* GetKeyEvent() const; + const MouseEvent* GetMouseEvent() const; + const CommandEvent* GetCommandEvent() const; +}; + +inline const KeyEvent* NotifyEvent::GetKeyEvent() const +{ + if ( (mnEventType == MouseNotifyEvent::KEYINPUT) || (mnEventType == MouseNotifyEvent::KEYUP) ) + return static_cast<const KeyEvent*>(mpData); + else + return nullptr; +} + +inline const MouseEvent* NotifyEvent::GetMouseEvent() const +{ + if ( (mnEventType >= MouseNotifyEvent::MOUSEBUTTONDOWN) && (mnEventType <= MouseNotifyEvent::MOUSEMOVE) ) + return static_cast<const MouseEvent*>(mpData); + else + return nullptr; +} + +inline const CommandEvent* NotifyEvent::GetCommandEvent() const +{ + if ( mnEventType == MouseNotifyEvent::COMMAND ) + return static_cast<const CommandEvent*>(mpData); + else + return nullptr; +} + + +enum class DataChangedEventType { + NONE = 0, + SETTINGS = 1, + DISPLAY = 2, + FONTS = 4, + PRINTER = 5, + FONTSUBSTITUTION = 6 +}; + +class VCL_DLLPUBLIC DataChangedEvent +{ +private: + void* mpData; + AllSettingsFlags mnFlags; + DataChangedEventType mnType; + +public: + explicit DataChangedEvent( DataChangedEventType nType, + const void* pData = nullptr, + AllSettingsFlags nFlags = AllSettingsFlags::NONE ); + + DataChangedEventType GetType() const { return mnType; } + AllSettingsFlags GetFlags() const { return mnFlags; } + + const AllSettings* GetOldSettings() const; +}; + +inline DataChangedEvent::DataChangedEvent( DataChangedEventType nType, + const void* pData, + AllSettingsFlags nChangeFlags ) +{ + mpData = const_cast<void*>(pData); + mnFlags = nChangeFlags; + mnType = nType; +} + +inline const AllSettings* DataChangedEvent::GetOldSettings() const +{ + if ( mnType == DataChangedEventType::SETTINGS ) + return static_cast<const AllSettings*>(mpData); + else + return nullptr; +} + +#endif // INCLUDED_VCL_EVENT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/evntpost.hxx b/include/vcl/evntpost.hxx new file mode 100644 index 000000000..ca6be18a6 --- /dev/null +++ b/include/vcl/evntpost.hxx @@ -0,0 +1,46 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_VCL_EVNTPOST_HXX +#define INCLUDED_VCL_EVNTPOST_HXX + +#include <config_options.h> +#include <tools/link.hxx> +#include <vcl/dllapi.h> + +struct ImplSVEvent; + +namespace vcl +{ + class UNLESS_MERGELIBS(VCL_DLLPUBLIC) EventPoster + { + ImplSVEvent * m_nId; + Link<LinkParamNone*,void> m_aLink; + + DECL_DLLPRIVATE_LINK( DoEvent_Impl, void*, void ); + + public: + EventPoster( const Link<LinkParamNone*,void>& rLink ); + ~EventPoster(); + void Post(); + }; +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/exceptiontypes.hxx b/include/vcl/exceptiontypes.hxx new file mode 100644 index 000000000..b0e63a982 --- /dev/null +++ b/include/vcl/exceptiontypes.hxx @@ -0,0 +1,32 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_EXCEPTIONTYPES_HXX +#define INCLUDED_VCL_EXCEPTIONTYPES_HXX + +enum class ExceptionCategory +{ + NONE, + System, + UserInterface +}; + +#endif // INCLUDED_VCL_EXCEPTIONTYPES_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/extoutdevdata.hxx b/include/vcl/extoutdevdata.hxx new file mode 100644 index 000000000..537414435 --- /dev/null +++ b/include/vcl/extoutdevdata.hxx @@ -0,0 +1,36 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_EXTOUTDEVDATA_HXX +#define INCLUDED_VCL_EXTOUTDEVDATA_HXX + +#include <vcl/dllapi.h> + +namespace vcl +{ +class VCL_DLLPUBLIC ExtOutDevData +{ +public: + virtual ~ExtOutDevData(); +}; +} + +#endif // INCLUDED_VCL_EXTOUTDEVDATA_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/fieldvalues.hxx b/include/vcl/fieldvalues.hxx new file mode 100644 index 000000000..999f3e5fa --- /dev/null +++ b/include/vcl/fieldvalues.hxx @@ -0,0 +1,80 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_FIELDVALUES_HXX +#define INCLUDED_VCL_FIELDVALUES_HXX + +#include <sal/config.h> + +#include <string_view> + +#include <vcl/dllapi.h> +#include <rtl/ustring.hxx> +#include <tools/fldunit.hxx> +#include <tools/mapunit.hxx> + +class LocaleDataWrapper; + +namespace vcl +{ +VCL_DLLPUBLIC FieldUnit EnglishStringToMetric(std::string_view rEnglishMetricString); + +VCL_DLLPUBLIC bool TextToValue(const OUString& rStr, double& rValue, sal_Int64 nBaseValue, + sal_uInt16 nDecDigits, const LocaleDataWrapper& rLocaleDataWrapper, + FieldUnit eUnit); + +VCL_DLLPUBLIC sal_Int64 ConvertValue(sal_Int64 nValue, sal_Int64 mnBaseValue, sal_uInt16 nDecDigits, + FieldUnit eInUnit, FieldUnit eOutUnit); +VCL_DLLPUBLIC sal_Int64 ConvertValue(sal_Int64 nValue, sal_uInt16 nDecDigits, MapUnit eInUnit, + FieldUnit eOutUnit); + +// for backwards compatibility +// caution: conversion to double loses precision +VCL_DLLPUBLIC double ConvertDoubleValue(double nValue, sal_Int64 mnBaseValue, sal_uInt16 nDecDigits, + FieldUnit eInUnit, FieldUnit eOutUnit); +VCL_DLLPUBLIC double ConvertDoubleValue(double nValue, sal_uInt16 nDecDigits, FieldUnit eInUnit, + MapUnit eOutUnit); +VCL_DLLPUBLIC double ConvertDoubleValue(double nValue, sal_uInt16 nDecDigits, MapUnit eInUnit, + FieldUnit eOutUnit); + +// for backwards compatibility +// caution: conversion to double loses precision +inline double ConvertDoubleValue(sal_Int64 nValue, sal_Int64 nBaseValue, sal_uInt16 nDecDigits, + FieldUnit eInUnit, FieldUnit eOutUnit) +{ + return ConvertDoubleValue(static_cast<double>(nValue), nBaseValue, nDecDigits, eInUnit, + eOutUnit); +} + +inline double ConvertDoubleValue(sal_Int64 nValue, sal_uInt16 nDecDigits, FieldUnit eInUnit, + MapUnit eOutUnit) +{ + return ConvertDoubleValue(static_cast<double>(nValue), nDecDigits, eInUnit, eOutUnit); +} + +inline double ConvertDoubleValue(sal_Int64 nValue, sal_uInt16 nDecDigits, MapUnit eInUnit, + FieldUnit eOutUnit) +{ + return ConvertDoubleValue(static_cast<double>(nValue), nDecDigits, eInUnit, eOutUnit); +} +} + +#endif // INCLUDED_VCL_FIELDVALUES_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/fileregistration.hxx b/include/vcl/fileregistration.hxx new file mode 100644 index 000000000..68a0f26a8 --- /dev/null +++ b/include/vcl/fileregistration.hxx @@ -0,0 +1,28 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#pragma once + +#include <sal/config.h> + +#include <vcl/dllapi.h> + +namespace weld +{ +class Window; +} + +namespace vcl::fileregistration +{ +VCL_DLLPUBLIC void LaunchRegistrationUI(); + +VCL_DLLPUBLIC void CheckFileExtRegistration(weld::Window* pDialogParent); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/filter/PDFiumLibrary.hxx b/include/vcl/filter/PDFiumLibrary.hxx new file mode 100644 index 000000000..3a4d0d83f --- /dev/null +++ b/include/vcl/filter/PDFiumLibrary.hxx @@ -0,0 +1,236 @@ +/* -*- 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/. + * + */ + +#pragma once + +#include <memory> + +#include <com/sun/star/util/DateTime.hpp> + +#include <vcl/dllapi.h> +#include <basegfx/vector/b2dsize.hxx> +#include <basegfx/range/b2drectangle.hxx> +#include <basegfx/point/b2dpoint.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <rtl/ustring.hxx> +#include <tools/color.hxx> +#include <tools/gen.hxx> +#include <vcl/checksum.hxx> +#include <vcl/Scanline.hxx> +#include <vcl/pdf/PDFAnnotationSubType.hxx> +#include <vcl/pdf/PDFPageObjectType.hxx> +#include <vcl/pdf/PDFSegmentType.hxx> +#include <vcl/pdf/PDFBitmapType.hxx> +#include <vcl/pdf/PDFObjectType.hxx> +#include <vcl/pdf/PDFTextRenderMode.hxx> +#include <vcl/pdf/PDFFillMode.hxx> +#include <vcl/pdf/PDFFindFlags.hxx> +#include <vcl/pdf/PDFErrorType.hxx> + +class SvMemoryStream; + +namespace vcl::pdf +{ +inline constexpr OStringLiteral constDictionaryKeyTitle = "T"; +inline constexpr OStringLiteral constDictionaryKeyContents = "Contents"; +inline constexpr OStringLiteral constDictionaryKeyPopup = "Popup"; +inline constexpr OStringLiteral constDictionaryKeyModificationDate = "M"; +inline constexpr OStringLiteral constDictionaryKeyInteriorColor = "IC"; + +class PDFiumBitmap; +class PDFiumDocument; +class PDFiumPageObject; + +class VCL_DLLPUBLIC PDFium +{ +public: + virtual ~PDFium() = default; + + virtual const OUString& getLastError() const = 0; + + virtual std::unique_ptr<PDFiumDocument> openDocument(const void* pData, int nSize, + const OString& rPassword) + = 0; + virtual PDFErrorType getLastErrorCode() = 0; + virtual std::unique_ptr<PDFiumBitmap> createBitmap(int nWidth, int nHeight, int nAlpha) = 0; +}; + +class PDFiumPage; + +class VCL_DLLPUBLIC PDFiumBitmap +{ +public: + virtual ~PDFiumBitmap() = default; + virtual void fillRect(int left, int top, int width, int height, sal_uInt32 nColor) = 0; + virtual void renderPageBitmap(PDFiumDocument* pDoc, PDFiumPage* pPage, int nStartX, int nStartY, + int nSizeX, int nSizeY) + = 0; + virtual ConstScanline getBuffer() = 0; + virtual int getStride() = 0; + virtual int getWidth() = 0; + virtual int getHeight() = 0; + virtual PDFBitmapType getFormat() = 0; +}; + +class VCL_DLLPUBLIC PDFiumAnnotation +{ +public: + virtual ~PDFiumAnnotation() = default; + virtual PDFAnnotationSubType getSubType() = 0; + virtual basegfx::B2DRectangle getRectangle() = 0; + virtual bool hasKey(OString const& rKey) = 0; + virtual PDFObjectType getValueType(OString const& rKey) = 0; + virtual OUString getString(OString const& rKey) = 0; + virtual std::unique_ptr<PDFiumAnnotation> getLinked(OString const& rKey) = 0; + virtual int getObjectCount() = 0; + virtual std::unique_ptr<PDFiumPageObject> getObject(int nIndex) = 0; + virtual std::vector<std::vector<basegfx::B2DPoint>> getInkStrokes() = 0; + virtual std::vector<basegfx::B2DPoint> getVertices() = 0; + virtual Color getColor() = 0; + virtual Color getInteriorColor() = 0; + virtual float getBorderWidth() = 0; + virtual basegfx::B2DSize getBorderCornerRadius() = 0; + virtual size_t getAttachmentPointsCount() = 0; + virtual std::vector<basegfx::B2DPoint> getAttachmentPoints(size_t nIndex) = 0; + virtual std::vector<basegfx::B2DPoint> getLineGeometry() = 0; +}; + +class PDFiumTextPage; + +class VCL_DLLPUBLIC PDFiumPathSegment +{ +public: + virtual ~PDFiumPathSegment() = default; + virtual basegfx::B2DPoint getPoint() const = 0; + virtual bool isClosed() const = 0; + virtual PDFSegmentType getType() const = 0; +}; + +class VCL_DLLPUBLIC PDFiumPageObject +{ +public: + virtual ~PDFiumPageObject() = default; + + virtual PDFPageObjectType getType() = 0; + virtual OUString getText(std::unique_ptr<PDFiumTextPage> const& pTextPage) = 0; + + virtual int getFormObjectCount() = 0; + virtual std::unique_ptr<PDFiumPageObject> getFormObject(int nIndex) = 0; + + virtual basegfx::B2DHomMatrix getMatrix() = 0; + virtual basegfx::B2DRectangle getBounds() = 0; + virtual double getFontSize() = 0; + virtual OUString getFontName() = 0; + virtual PDFTextRenderMode getTextRenderMode() = 0; + virtual Color getFillColor() = 0; + virtual Color getStrokeColor() = 0; + virtual double getStrokeWidth() = 0; + // Path + virtual int getPathSegmentCount() = 0; + virtual std::unique_ptr<PDFiumPathSegment> getPathSegment(int index) = 0; + virtual Size getImageSize(PDFiumPage& rPage) = 0; + virtual std::unique_ptr<PDFiumBitmap> getImageBitmap() = 0; + virtual bool getDrawMode(PDFFillMode& eFillMode, bool& bStroke) = 0; +}; + +class VCL_DLLPUBLIC PDFiumSearchHandle +{ +public: + virtual ~PDFiumSearchHandle() = default; + + virtual bool findNext() = 0; + virtual bool findPrev() = 0; + virtual int getSearchResultIndex() = 0; + virtual int getSearchCount() = 0; +}; + +class VCL_DLLPUBLIC PDFiumTextPage +{ +public: + virtual ~PDFiumTextPage() = default; + + virtual int countChars() = 0; + virtual unsigned int getUnicode(int index) = 0; + virtual std::unique_ptr<PDFiumSearchHandle> + findStart(const OUString& rFindWhat, PDFFindFlags nFlags, sal_Int32 nStartIndex) = 0; + + /// Returned rect is no longer upside down and is in mm100. + virtual basegfx::B2DRectangle getCharBox(int nIndex, double fPageHeight) = 0; +}; + +class VCL_DLLPUBLIC PDFiumPage +{ +public: + virtual ~PDFiumPage() = default; + + virtual int getObjectCount() = 0; + virtual std::unique_ptr<PDFiumPageObject> getObject(int nIndex) = 0; + + virtual int getAnnotationCount() = 0; + virtual int getAnnotationIndex(std::unique_ptr<PDFiumAnnotation> const& rAnnotation) = 0; + + virtual std::unique_ptr<PDFiumAnnotation> getAnnotation(int nIndex) = 0; + + virtual std::unique_ptr<PDFiumTextPage> getTextPage() = 0; + + /// Get bitmap checksum of the page, without annotations/commenting. + virtual BitmapChecksum getChecksum(int nMDPPerm) = 0; + + virtual double getWidth() = 0; + virtual double getHeight() = 0; + + virtual bool hasTransparency() = 0; + + virtual bool hasLinks() = 0; +}; + +/// Represents one digital signature, as exposed by PDFium. +class VCL_DLLPUBLIC PDFiumSignature +{ +public: + virtual ~PDFiumSignature() = default; + + virtual std::vector<int> getByteRange() = 0; + virtual int getDocMDPPermission() = 0; + virtual std::vector<unsigned char> getContents() = 0; + virtual OString getSubFilter() = 0; + virtual OUString getReason() = 0; + virtual css::util::DateTime getTime() = 0; +}; + +class VCL_DLLPUBLIC PDFiumDocument +{ +public: + virtual ~PDFiumDocument() = default; + + // Page size in points + virtual basegfx::B2DSize getPageSize(int nIndex) = 0; + virtual int getPageCount() = 0; + virtual int getSignatureCount() = 0; + virtual int getFileVersion() = 0; + virtual bool saveWithVersion(SvMemoryStream& rStream, int nFileVersion) = 0; + + virtual std::unique_ptr<PDFiumPage> openPage(int nIndex) = 0; + virtual std::unique_ptr<PDFiumSignature> getSignature(int nIndex) = 0; + virtual std::vector<unsigned int> getTrailerEnds() = 0; +}; + +struct VCL_DLLPUBLIC PDFiumLibrary final +{ + static std::shared_ptr<PDFium>& get(); +}; + +// Tools + +VCL_DLLPUBLIC OUString convertPdfDateToISO8601(OUString const& rInput); + +} // namespace vcl::pdf + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/filter/PngImageReader.hxx b/include/vcl/filter/PngImageReader.hxx new file mode 100644 index 000000000..bbb5b7c8d --- /dev/null +++ b/include/vcl/filter/PngImageReader.hxx @@ -0,0 +1,56 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_FILTER_PNGIMAGEREADER_HXX +#define INCLUDED_VCL_FILTER_PNGIMAGEREADER_HXX + +#include <sal/config.h> + +#include <memory> + +#include <vcl/dllapi.h> + +#include <com/sun/star/uno/Reference.hxx> + +namespace com::sun::star::task +{ +class XStatusIndicator; +} + +class BitmapEx; +class SvStream; + +namespace vcl +{ +class VCL_DLLPUBLIC PngImageReader +{ + SvStream& mrStream; + css::uno::Reference<css::task::XStatusIndicator> mxStatusIndicator; + +public: + PngImageReader(SvStream& rStream); + + // Returns true if image was successfully read without errors. + // A usable bitmap may be returned even if there were errors (e.g. incomplete image). + bool read(BitmapEx& rBitmap); + // Returns a bitmap without indicating if there were errors. + BitmapEx read(); + + // Returns the contents of the msOG chunk (containing a Gif image), if it exists. + // Does not change position in the stream. + static std::unique_ptr<sal_uInt8[]> getMicrosoftGifChunk(SvStream& rStream, + sal_Int32* chunkSize = nullptr); +}; + +} // namespace vcl + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/filter/SvmReader.hxx b/include/vcl/filter/SvmReader.hxx new file mode 100644 index 000000000..d16a775e3 --- /dev/null +++ b/include/vcl/filter/SvmReader.hxx @@ -0,0 +1,94 @@ +/* -*- 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 . + */ + +#pragma once + +#include <vcl/gdimtf.hxx> + +class SvStream; + +class VCL_DLLPUBLIC SvmReader +{ +private: + SvStream& mrStream; + + void ReadColor(::Color& rColor); + +public: + SvmReader(SvStream& rIStm); + + SvStream& Read(GDIMetaFile& rMetaFile, ImplMetaReadData* pData = nullptr); + rtl::Reference<MetaAction> MetaActionHandler(ImplMetaReadData* pData); + rtl::Reference<MetaAction> LineColorHandler(); + rtl::Reference<MetaAction> FillColorHandler(); + rtl::Reference<MetaAction> RectHandler(); + rtl::Reference<MetaAction> PointHandler(); + rtl::Reference<MetaAction> PixelHandler(); + rtl::Reference<MetaAction> LineHandler(); + rtl::Reference<MetaAction> RoundRectHandler(); + rtl::Reference<MetaAction> EllipseHandler(); + rtl::Reference<MetaAction> ArcHandler(); + rtl::Reference<MetaAction> PieHandler(); + rtl::Reference<MetaAction> ChordHandler(); + rtl::Reference<MetaAction> PolyLineHandler(); + rtl::Reference<MetaAction> PolygonHandler(); + rtl::Reference<MetaAction> PolyPolygonHandler(); + rtl::Reference<MetaAction> TextHandler(const ImplMetaReadData* pData); + rtl::Reference<MetaAction> TextArrayHandler(const ImplMetaReadData* pData); + rtl::Reference<MetaAction> StretchTextHandler(const ImplMetaReadData* pData); + rtl::Reference<MetaAction> TextRectHandler(const ImplMetaReadData* pData); + rtl::Reference<MetaAction> TextLineHandler(); + rtl::Reference<MetaAction> BmpHandler(); + rtl::Reference<MetaAction> BmpScaleHandler(); + rtl::Reference<MetaAction> BmpScalePartHandler(); + rtl::Reference<MetaAction> BmpExHandler(); + rtl::Reference<MetaAction> BmpExScaleHandler(); + rtl::Reference<MetaAction> BmpExScalePartHandler(); + rtl::Reference<MetaAction> MaskHandler(); + rtl::Reference<MetaAction> MaskScaleHandler(); + rtl::Reference<MetaAction> MaskScalePartHandler(); + rtl::Reference<MetaAction> GradientHandler(); + rtl::Reference<MetaAction> GradientExHandler(); + rtl::Reference<MetaAction> HatchHandler(); + rtl::Reference<MetaAction> WallpaperHandler(); + rtl::Reference<MetaAction> ClipRegionHandler(); + rtl::Reference<MetaAction> ISectRectClipRegionHandler(); + rtl::Reference<MetaAction> ISectRegionClipRegionHandler(); + rtl::Reference<MetaAction> MoveClipRegionHandler(); + rtl::Reference<MetaAction> TextColorHandler(); + rtl::Reference<MetaAction> TextFillColorHandler(); + rtl::Reference<MetaAction> TextLineColorHandler(); + rtl::Reference<MetaAction> OverlineColorHandler(); + rtl::Reference<MetaAction> TextAlignHandler(); + rtl::Reference<MetaAction> MapModeHandler(); + rtl::Reference<MetaAction> FontHandler(ImplMetaReadData* pData); + rtl::Reference<MetaAction> PushHandler(); + rtl::Reference<MetaAction> PopHandler(); + rtl::Reference<MetaAction> RasterOpHandler(); + rtl::Reference<MetaAction> TransparentHandler(); + rtl::Reference<MetaAction> FloatTransparentHandler(ImplMetaReadData* pData); + rtl::Reference<MetaAction> EPSHandler(); + rtl::Reference<MetaAction> RefPointHandler(); + rtl::Reference<MetaAction> CommentHandler(); + rtl::Reference<MetaAction> LayoutModeHandler(); + rtl::Reference<MetaAction> TextLanguageHandler(); + static rtl::Reference<MetaAction> DefaultHandler(); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/filter/SvmWriter.hxx b/include/vcl/filter/SvmWriter.hxx new file mode 100644 index 000000000..ef8cf8c52 --- /dev/null +++ b/include/vcl/filter/SvmWriter.hxx @@ -0,0 +1,94 @@ +/* -*- 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 . + */ + +#pragma once + +#include <vcl/gdimtf.hxx> +#include <vcl/metaact.hxx> + +class SvStream; + +class VCL_DLLPUBLIC SvmWriter +{ +private: + SvStream& mrStream; + + void WriteColor(::Color aColor); + +public: + SvmWriter(SvStream& rIStm); + + SvStream& Write(const GDIMetaFile& rMetaFile); + static BitmapChecksum GetChecksum(const GDIMetaFile& rMetaFile); + void MetaActionHandler(MetaAction* pAction, ImplMetaWriteData* pData); + void ActionHandler(const MetaAction* pAction); + void PixelHandler(const MetaPixelAction* pAction); + void PointHandler(const MetaPointAction* pAction); + void LineHandler(const MetaLineAction* pAction); + void RectHandler(const MetaRectAction* pAction); + void RoundRectHandler(const MetaRoundRectAction* pAction); + void EllipseHandler(const MetaEllipseAction* pAction); + void ArcHandler(const MetaArcAction* pAction); + void PieHandler(const MetaPieAction* pAction); + void ChordHandler(const MetaChordAction* pAction); + void PolyLineHandler(const MetaPolyLineAction* pAction); + void PolygonHandler(const MetaPolygonAction* pAction); + void PolyPolygonHandler(const MetaPolyPolygonAction* pAction); + void TextHandler(const MetaTextAction* pAction, const ImplMetaWriteData* pData); + void TextArrayHandler(const MetaTextArrayAction* pAction, const ImplMetaWriteData* pData); + void StretchTextHandler(const MetaStretchTextAction* pAction, const ImplMetaWriteData* pData); + void TextRectHandler(const MetaTextRectAction* pAction, const ImplMetaWriteData* pData); + void TextLineHandler(const MetaTextLineAction* pAction); + void BmpHandler(const MetaBmpAction* pAction); + void BmpScaleHandler(const MetaBmpScaleAction* pAction); + void BmpScalePartHandler(const MetaBmpScalePartAction* pAction); + void BmpExHandler(const MetaBmpExAction* pAction); + void BmpExScaleHandler(const MetaBmpExScaleAction* pAction); + void BmpExScalePartHandler(const MetaBmpExScalePartAction* pAction); + void MaskHandler(const MetaMaskAction* pAction); + void MaskScaleHandler(const MetaMaskScaleAction* pAction); + void MaskScalePartHandler(const MetaMaskScalePartAction* pAction); + void GradientHandler(const MetaGradientAction* pAction); + void GradientExHandler(const MetaGradientExAction* pAction); + void HatchHandler(const MetaHatchAction* pAction); + void WallpaperHandler(const MetaWallpaperAction* pAction); + void ClipRegionHandler(const MetaClipRegionAction* pAction); + void ISectRectClipRegionHandler(const MetaISectRectClipRegionAction* pAction); + void ISectRegionClipRegionHandler(const MetaISectRegionClipRegionAction* pAction); + void MoveClipRegionHandler(const MetaMoveClipRegionAction* pAction); + void LineColorHandler(const MetaLineColorAction* pAction); + void FillColorHandler(const MetaFillColorAction* pAction); + void TextColorHandler(const MetaTextColorAction* pAction); + void TextFillColorHandler(const MetaTextFillColorAction* pAction); + void TextLineColorHandler(const MetaTextLineColorAction* pAction); + void OverlineColorHandler(const MetaOverlineColorAction* pAction); + void TextAlignHandler(const MetaTextAlignAction* pAction); + void MapModeHandler(const MetaMapModeAction* pAction); + void FontHandler(const MetaFontAction* pAction, ImplMetaWriteData* pData); + void PushHandler(const MetaPushAction* pAction); + void PopHandler(const MetaPopAction* pAction); + void RasterOpHandler(const MetaRasterOpAction* pAction); + void TransparentHandler(const MetaTransparentAction* pAction); + void FloatTransparentHandler(const MetaFloatTransparentAction* pAction); + void EPSHandler(const MetaEPSAction* pAction); + void RefPointHandler(const MetaRefPointAction* pAction); + void CommentHandler(const MetaCommentAction* pAction); + void LayoutModeHandler(const MetaLayoutModeAction* pAction); + void TextLanguageHandler(const MetaTextLanguageAction* pAction); +}; diff --git a/include/vcl/filter/pdfdocument.hxx b/include/vcl/filter/pdfdocument.hxx new file mode 100644 index 000000000..fbe0be89c --- /dev/null +++ b/include/vcl/filter/pdfdocument.hxx @@ -0,0 +1,645 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_FILTER_PDFDOCUMENT_HXX +#define INCLUDED_VCL_FILTER_PDFDOCUMENT_HXX + +#include <memory> +#include <map> +#include <vector> + +#include <tools/stream.hxx> +#include <vcl/dllapi.h> +#include <rtl/strbuf.hxx> + +#include <vcl/filter/pdfobjectcontainer.hxx> + +namespace com::sun::star::security +{ +class XCertificate; +} + +namespace com::sun::star::uno +{ +template <class interface_type> class Reference; +} + +namespace tools +{ +class Rectangle; +} + +namespace vcl::filter +{ +class PDFTrailerElement; +class PDFReferenceElement; +class PDFDocument; +class PDFDictionaryElement; +class PDFArrayElement; +class PDFStreamElement; +class PDFNumberElement; + +/// A byte range in a PDF file. +class VCL_DLLPUBLIC PDFElement +{ + bool m_bVisiting = false; + bool m_bParsing = false; + +public: + PDFElement() = default; + virtual bool Read(SvStream& rStream) = 0; + virtual ~PDFElement() = default; + void setVisiting(bool bVisiting) { m_bVisiting = bVisiting; } + bool alreadyVisiting() const { return m_bVisiting; } + void setParsing(bool bParsing) { m_bParsing = bParsing; } + bool alreadyParsing() const { return m_bParsing; } + + virtual void writeString(OStringBuffer& rBuffer) = 0; +}; + +/// Indirect object: something with a unique ID. +class VCL_DLLPUBLIC PDFObjectElement final : public PDFElement +{ + /// The document owning this element. + PDFDocument& m_rDoc; + double m_fObjectValue; + double m_fGenerationValue; + /// If set, the object contains this number element (outside any dictionary/array). + PDFNumberElement* m_pNumberElement; + /// Position after the '<<' token. + sal_uInt64 m_nDictionaryOffset; + /// Length of the dictionary buffer till (before) the '>>' token. + sal_uInt64 m_nDictionaryLength; + PDFDictionaryElement* m_pDictionaryElement; + /// Position after the '[' token, if m_pArrayElement is set. + sal_uInt64 m_nArrayOffset; + /// Length of the array buffer till (before) the ']' token. + sal_uInt64 m_nArrayLength; + /// The contained direct array, if any. + PDFArrayElement* m_pArrayElement; + /// The stream of this object, used when this is an object stream. + PDFStreamElement* m_pStreamElement; + /// Objects of an object stream. + std::vector<std::unique_ptr<PDFObjectElement>> m_aStoredElements; + /// Elements of an object in an object stream. + std::vector<std::unique_ptr<PDFElement>> m_aElements; + /// Uncompressed buffer of an object in an object stream. + std::unique_ptr<SvMemoryStream> m_pStreamBuffer; + /// List of all reference elements inside this object's dictionary and + /// nested dictionaries. + std::vector<PDFReferenceElement*> m_aDictionaryReferences; + + bool m_bParsed; + + void parseIfNecessary(); + +public: + PDFObjectElement(PDFDocument& rDoc, double fObjectValue, double fGenerationValue); + bool Read(SvStream& rStream) override; + PDFElement* Lookup(const OString& rDictionaryKey); + PDFObjectElement* LookupObject(const OString& rDictionaryKey); + double GetObjectValue() const; + void SetDictionaryOffset(sal_uInt64 nDictionaryOffset); + sal_uInt64 GetDictionaryOffset(); + void SetDictionaryLength(sal_uInt64 nDictionaryLength); + sal_uInt64 GetDictionaryLength(); + PDFDictionaryElement* GetDictionary(); + void SetDictionary(PDFDictionaryElement* pDictionaryElement); + void SetNumberElement(PDFNumberElement* pNumberElement); + PDFNumberElement* GetNumberElement() const; + /// Get access to the parsed key-value items from the object dictionary. + const std::map<OString, PDFElement*>& GetDictionaryItems(); + const std::vector<PDFReferenceElement*>& GetDictionaryReferences() const; + void AddDictionaryReference(PDFReferenceElement* pReference); + void SetArray(PDFArrayElement* pArrayElement); + void SetStream(PDFStreamElement* pStreamElement); + /// Access to the stream of the object, if it has any. + PDFStreamElement* GetStream() const; + void SetArrayOffset(sal_uInt64 nArrayOffset); + sal_uInt64 GetArrayOffset() const; + void SetArrayLength(sal_uInt64 nArrayLength); + sal_uInt64 GetArrayLength() const; + PDFArrayElement* GetArray(); + /// Parse objects stored in this object stream. + void ParseStoredObjects(); + std::vector<std::unique_ptr<PDFElement>>& GetStoredElements(); + SvMemoryStream* GetStreamBuffer() const; + void SetStreamBuffer(std::unique_ptr<SvMemoryStream>& pStreamBuffer); + PDFDocument& GetDocument(); + + void writeString(OStringBuffer& /*rBuffer*/) override { assert(false && "not implemented"); } +}; + +/// Array object: a list. +class VCL_DLLPUBLIC PDFArrayElement final : public PDFElement +{ + std::vector<PDFElement*> m_aElements; + /// The object that contains this array. + PDFObjectElement* m_pObject; + +public: + PDFArrayElement(PDFObjectElement* pObject); + bool Read(SvStream& rStream) override; + void PushBack(PDFElement* pElement); + const std::vector<PDFElement*>& GetElements() const; + PDFElement* GetElement(size_t nIndex) const { return m_aElements[nIndex]; } + + void writeString(OStringBuffer& rBuffer) override + { + rBuffer.append("[ "); + for (auto& rElement : m_aElements) + { + rElement->writeString(rBuffer); + rBuffer.append(" "); + } + rBuffer.append("]"); + } +}; + +/// Reference object: something with a unique ID. +class VCL_DLLPUBLIC PDFReferenceElement final : public PDFElement +{ + PDFDocument& m_rDoc; + int m_fObjectValue; + int m_fGenerationValue; + /// Location after the 'R' token. + sal_uInt64 m_nOffset = 0; + /// The element providing the object number. + PDFNumberElement& m_rObject; + +public: + PDFReferenceElement(PDFDocument& rDoc, PDFNumberElement& rObject, + PDFNumberElement const& rGeneration); + bool Read(SvStream& rStream) override; + /// Assuming the reference points to a number object, return its value. + double LookupNumber(SvStream& rStream) const; + /// Lookup referenced object, without assuming anything about its contents. + PDFObjectElement* LookupObject(); + int GetObjectValue() const; + int GetGenerationValue() const; + sal_uInt64 GetOffset() const; + PDFNumberElement& GetObjectElement() const; + + void writeString(OStringBuffer& rBuffer) override + { + rBuffer.append(sal_Int32(GetObjectValue())); + rBuffer.append(' '); + rBuffer.append(sal_Int32(GetGenerationValue())); + rBuffer.append(" R"); + } +}; + +/// Stream object: a byte array with a known length. +class VCL_DLLPUBLIC PDFStreamElement final : public PDFElement +{ + size_t m_nLength; + sal_uInt64 m_nOffset; + /// The byte array itself. + SvMemoryStream m_aMemory; + +public: + explicit PDFStreamElement(size_t nLength); + bool Read(SvStream& rStream) override; + sal_uInt64 GetOffset() const; + SvMemoryStream& GetMemory(); + + void writeString(OStringBuffer& rBuffer) override + { + rBuffer.append("stream\n"); + rBuffer.append(static_cast<const char*>(m_aMemory.GetData()), m_aMemory.GetSize()); + rBuffer.append("\nendstream\n"); + } +}; + +/// Name object: a key string. +class VCL_DLLPUBLIC PDFNameElement final : public PDFElement +{ + OString m_aValue; + /// Offset after the '/' token. + sal_uInt64 m_nLocation = 0; + +public: + PDFNameElement(); + bool Read(SvStream& rStream) override; + void SetValue(const OString& rValue) { m_aValue = rValue; } + const OString& GetValue() const; + sal_uInt64 GetLocation() const; + sal_uInt64 GetLength() const { return m_aValue.getLength(); } + + void writeString(OStringBuffer& rBuffer) override + { + rBuffer.append("/"); + rBuffer.append(m_aValue); + } +}; + +/// Dictionary object: a set key-value pairs. +class VCL_DLLPUBLIC PDFDictionaryElement final : public PDFElement +{ + /// Key-value pairs when the dictionary is a nested value. + std::map<OString, PDFElement*> m_aItems; + /// Offset after the '<<' token. + sal_uInt64 m_nLocation = 0; + /// Position after the '/' token. + std::map<OString, sal_uInt64> m_aDictionaryKeyOffset; + /// Length of the dictionary key and value, till (before) the next token. + std::map<OString, sal_uInt64> m_aDictionaryKeyValueLength; + +public: + PDFDictionaryElement(); + bool Read(SvStream& rStream) override; + + static PDFElement* Lookup(const std::map<OString, PDFElement*>& rDictionary, + const OString& rKey); + void SetKeyOffset(const OString& rKey, sal_uInt64 nOffset); + sal_uInt64 GetKeyOffset(const OString& rKey) const; + void SetKeyValueLength(const OString& rKey, sal_uInt64 nLength); + sal_uInt64 GetKeyValueLength(const OString& rKey) const; + const std::map<OString, PDFElement*>& GetItems() const; + /// Looks up an object which is only referenced in this dictionary. + PDFObjectElement* LookupObject(const OString& rDictionaryKey); + /// Looks up an element which is contained in this dictionary. + PDFElement* LookupElement(const OString& rDictionaryKey); + sal_uInt64 GetLocation() const { return m_nLocation; } + void insert(OString const& rKey, PDFElement* pPDFElement) + { + m_aItems.emplace(rKey, pPDFElement); + } + + void writeString(OStringBuffer& rBuffer) override + { + rBuffer.append("<< "); + for (auto& rPair : m_aItems) + { + rBuffer.append("/"); + rBuffer.append(rPair.first); + rBuffer.append(" "); + rPair.second->writeString(rBuffer); + rBuffer.append(" "); + } + rBuffer.append(">>"); + } +}; + +enum class TokenizeMode +{ + /// Full file. + END_OF_STREAM, + /// Till the first %%EOF token. + EOF_TOKEN, + /// Till the end of the current object. + END_OF_OBJECT, + /// Same as END_OF_OBJECT, but for object streams (no endobj keyword). + STORED_OBJECT +}; + +/// The type column of an entry in a cross-reference stream. +enum class XRefEntryType +{ + /// xref "f" or xref stream "0". + FREE, + /// xref "n" or xref stream "1". + NOT_COMPRESSED, + /// xref stream "2". + COMPRESSED +}; + +/// An entry in a cross-reference stream. +class XRefEntry +{ + XRefEntryType m_eType = XRefEntryType::NOT_COMPRESSED; + /** + * Non-compressed: The byte offset of the object, starting from the + * beginning of the file. + * Compressed: The object number of the object stream in which this object is + * stored. + */ + sal_uInt64 m_nOffset = 0; + /// Are changed as part of an incremental update?. + bool m_bDirty = false; + +public: + XRefEntry(); + + void SetType(XRefEntryType eType) { m_eType = eType; } + + XRefEntryType GetType() const { return m_eType; } + + void SetOffset(sal_uInt64 nOffset) { m_nOffset = nOffset; } + + sal_uInt64 GetOffset() const { return m_nOffset; } + + void SetDirty(bool bDirty) { m_bDirty = bDirty; } + + bool GetDirty() const { return m_bDirty; } +}; + +/// Hex string: in <AABB> form. +class VCL_DLLPUBLIC PDFHexStringElement final : public PDFElement +{ + OString m_aValue; + +public: + bool Read(SvStream& rStream) override; + const OString& GetValue() const; + + void writeString(OStringBuffer& rBuffer) override + { + rBuffer.append("<"); + rBuffer.append(m_aValue); + rBuffer.append(">"); + } +}; + +/// Literal string: in (asdf) form. +class VCL_DLLPUBLIC PDFLiteralStringElement final : public PDFElement +{ + OString m_aValue; + +public: + bool Read(SvStream& rStream) override; + const OString& GetValue() const; + + void writeString(OStringBuffer& rBuffer) override + { + rBuffer.append("("); + rBuffer.append(m_aValue); + rBuffer.append(")"); + } +}; + +/// Numbering object: an integer or a real. +class VCL_DLLPUBLIC PDFNumberElement final : public PDFElement +{ + /// Input file start location. + sal_uInt64 m_nOffset = 0; + /// Input file token length. + sal_uInt64 m_nLength = 0; + double m_fValue = 0; + +public: + PDFNumberElement(); + bool Read(SvStream& rStream) override; + double GetValue() const; + void SetValue(double fValue) { m_fValue = fValue; } + + sal_uInt64 GetLocation() const; + sal_uInt64 GetLength() const; + + void writeString(OStringBuffer& rBuffer) override { rBuffer.append(m_fValue); } +}; + +/// A one-liner comment. +class VCL_DLLPUBLIC PDFCommentElement final : public PDFElement +{ + PDFDocument& m_rDoc; + OString m_aComment; + +public: + explicit PDFCommentElement(PDFDocument& rDoc); + bool Read(SvStream& rStream) override; + void writeString(OStringBuffer& /*rBuffer*/) override {} +}; + +/// End of a dictionary: '>>'. +class VCL_DLLPUBLIC PDFEndDictionaryElement final : public PDFElement +{ + /// Offset before the '>>' token. + sal_uInt64 m_nLocation = 0; + +public: + PDFEndDictionaryElement(); + bool Read(SvStream& rStream) override; + sal_uInt64 GetLocation() const; + + void writeString(OStringBuffer& /*rBuffer*/) override {} +}; + +/// End of a stream: 'endstream' keyword. +class VCL_DLLPUBLIC PDFEndStreamElement final : public PDFElement +{ +public: + bool Read(SvStream& rStream) override; + + void writeString(OStringBuffer& /*rBuffer*/) override {} +}; + +/// End of an object: 'endobj' keyword. +class VCL_DLLPUBLIC PDFEndObjectElement final : public PDFElement +{ +public: + bool Read(SvStream& rStream) override; + + void writeString(OStringBuffer& /*rBuffer*/) override {} +}; + +/// End of an array: ']'. +class VCL_DLLPUBLIC PDFEndArrayElement final : public PDFElement +{ + /// Location before the ']' token. + sal_uInt64 m_nOffset = 0; + +public: + PDFEndArrayElement(); + bool Read(SvStream& rStream) override; + sal_uInt64 GetOffset() const; + + void writeString(OStringBuffer& /*rBuffer*/) override {} +}; + +/// Boolean object: a 'true' or a 'false'. +class VCL_DLLPUBLIC PDFBooleanElement final : public PDFElement +{ + bool m_aValue; + +public: + explicit PDFBooleanElement(bool bValue) + : m_aValue(bValue) + { + } + + bool Read(SvStream& rStream) override; + + void writeString(OStringBuffer& rBuffer) override + { + rBuffer.append(m_aValue ? "true" : "false"); + } +}; + +/// Null object: the 'null' singleton. +class VCL_DLLPUBLIC PDFNullElement final : public PDFElement +{ +public: + bool Read(SvStream& rStream) override; + + void writeString(OStringBuffer& rBuffer) override { rBuffer.append("null"); } +}; + +/** + * In-memory representation of an on-disk PDF document. + * + * The PDF element list is not meant to be saved back to disk, but some + * elements remember their source offset / length, and based on that it's + * possible to modify the input file. + */ +class VCL_DLLPUBLIC PDFDocument final : public PDFObjectContainer +{ + /// This vector owns all elements. + std::vector<std::unique_ptr<PDFElement>> m_aElements; + /// Object ID <-> object offset map. + std::map<size_t, XRefEntry> m_aXRef; + /// Object offset <-> Object pointer map. + std::map<size_t, PDFObjectElement*> m_aOffsetObjects; + /// Object ID <-> Object pointer map. + std::map<size_t, PDFObjectElement*> m_aIDObjects; + /// List of xref offsets we know. + std::vector<size_t> m_aStartXRefs; + /// Offsets of trailers, from latest to oldest. + std::vector<size_t> m_aTrailerOffsets; + /// Trailer offset <-> Trailer pointer map. + std::map<size_t, PDFTrailerElement*> m_aOffsetTrailers; + /// List of EOF offsets we know. + std::vector<size_t> m_aEOFs; + PDFTrailerElement* m_pTrailer = nullptr; + /// When m_pTrailer is nullptr, this can still have a dictionary. + PDFObjectElement* m_pXRefStream = nullptr; + /// All editing takes place in this buffer, if it happens. + SvMemoryStream m_aEditBuffer; + + /// Signature line in PDF format, to be consumed by the next Sign() invocation. + std::vector<sal_Int8> m_aSignatureLine; + + /// 0-based page number where m_aSignatureLine should be placed. + size_t m_nSignaturePage = 0; + + /// Suggest a minimal, yet free signature ID to use for the next signature. + sal_uInt32 GetNextSignature(); + /// Write the signature object as part of signing. + sal_Int32 WriteSignatureObject(const OUString& rDescription, bool bAdES, + sal_uInt64& rLastByteRangeOffset, sal_Int64& rContentOffset); + /// Write the appearance object as part of signing. + sal_Int32 WriteAppearanceObject(tools::Rectangle& rSignatureRectangle); + /// Write the annot object as part of signing. + sal_Int32 WriteAnnotObject(PDFObjectElement const& rFirstPage, sal_Int32 nSignatureId, + sal_Int32 nAppearanceId, + const tools::Rectangle& rSignatureRectangle); + /// Write the updated Page object as part of signing. + bool WritePageObject(PDFObjectElement& rFirstPage, sal_Int32 nAnnotId); + /// Write the updated Catalog object as part of signing. + bool WriteCatalogObject(sal_Int32 nAnnotId, PDFReferenceElement*& pRoot); + /// Write the updated cross-references as part of signing. + void WriteXRef(sal_uInt64 nXRefOffset, PDFReferenceElement const* pRoot); + +public: + PDFDocument(); + virtual ~PDFDocument(); + PDFDocument& operator=(const PDFDocument&) = delete; + PDFDocument(const PDFDocument&) = delete; + /// @name Low-level functions, to be used by PDFElement subclasses. + //@{ + /// Decode a hex dump. + static std::vector<unsigned char> DecodeHexString(PDFHexStringElement const* pElement); + static OUString DecodeHexStringUTF16BE(PDFHexStringElement const& rElement); + static OString ReadKeyword(SvStream& rStream); + static size_t FindStartXRef(SvStream& rStream); + void ReadXRef(SvStream& rStream); + void ReadXRefStream(SvStream& rStream); + static void SkipWhitespace(SvStream& rStream); + /// Instead of all whitespace, just skip CR and NL characters. + static void SkipLineBreaks(SvStream& rStream); + size_t GetObjectOffset(size_t nIndex) const; + const std::vector<std::unique_ptr<PDFElement>>& GetElements() const; + std::vector<PDFObjectElement*> GetPages(); + PDFObjectElement* GetCatalog(); + /// Remember the end location of an EOF token. + void PushBackEOF(size_t nOffset); + /// Look up object based on object number, possibly by parsing object streams. + PDFObjectElement* LookupObject(size_t nObjectNumber); + /// Access to the input document, even after the input stream is gone. + SvMemoryStream& GetEditBuffer(); + /// Tokenize elements from current offset. + bool Tokenize(SvStream& rStream, TokenizeMode eMode, + std::vector<std::unique_ptr<PDFElement>>& rElements, + PDFObjectElement* pObjectElement); + /// Register an object (owned directly or indirectly by m_aElements) as a provider for a given ID. + void SetIDObject(size_t nID, PDFObjectElement* pObject); + //@} + + /// @name High-level functions, to be used by others. + //@{ + /// Read elements from the start of the stream till its end. + bool Read(SvStream& rStream); + /// Calls Read() first and if it fails it tries to fixup and then retry. + bool ReadWithPossibleFixup(SvStream& rStream); + void SetSignatureLine(std::vector<sal_Int8>&& rSignatureLine); + void SetSignaturePage(size_t nPage); + /// Sign the read document with xCertificate in the edit buffer. + bool Sign(const css::uno::Reference<css::security::XCertificate>& xCertificate, + const OUString& rDescription, bool bAdES); + /// Serializes the contents of the edit buffer. + bool Write(SvStream& rStream); + /// Get a list of signatures embedded into this document. + std::vector<PDFObjectElement*> GetSignatureWidgets(); + /// Remove the nth signature from read document in the edit buffer. + bool RemoveSignature(size_t nPosition); + //@} + + /// See vcl::PDFObjectContainer::createObject(). + sal_Int32 createObject() override; + /// See vcl::PDFObjectContainer::updateObject(). + bool updateObject(sal_Int32 n) override; + /// See vcl::PDFObjectContainer::writeBuffer(). + bool writeBuffer(const void* pBuffer, sal_uInt64 nBytes) override; + void checkAndEnableStreamEncryption(sal_Int32 /*nObject*/) override {} + void disableStreamEncryption() override {} +}; + +/// The trailer singleton is at the end of the doc. +class VCL_DLLPUBLIC PDFTrailerElement final : public PDFElement +{ + PDFDocument& m_rDoc; + PDFDictionaryElement* m_pDictionaryElement; + /// Location of the end of the trailer token. + sal_uInt64 m_nOffset = 0; + +public: + explicit PDFTrailerElement(PDFDocument& rDoc); + bool Read(SvStream& rStream) override; + PDFElement* Lookup(const OString& rDictionaryKey); + sal_uInt64 GetLocation() const; + + void SetDictionary(PDFDictionaryElement* pDictionaryElement) + { + m_pDictionaryElement = pDictionaryElement; + } + + PDFDictionaryElement* GetDictionary() { return m_pDictionaryElement; } + + void writeString(OStringBuffer& /*rBuffer*/) override { assert(false && "not implemented"); } +}; + +class VCL_DLLPUBLIC PDFObjectParser final +{ + const std::vector<std::unique_ptr<PDFElement>>& mrElements; + +public: + PDFObjectParser(std::vector<std::unique_ptr<PDFElement>> const& rElements) + : mrElements(rElements) + { + } + + size_t parse(PDFElement* pParsingElement, size_t nStartIndex = 0, int nCurrentDepth = 0); +}; + +} // namespace vcl::filter + +#endif // INCLUDED_VCL_FILTER_PDFDOCUMENT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/filter/pdfobjectcontainer.hxx b/include/vcl/filter/pdfobjectcontainer.hxx new file mode 100644 index 000000000..f6614f09e --- /dev/null +++ b/include/vcl/filter/pdfobjectcontainer.hxx @@ -0,0 +1,40 @@ +/* -*- 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/. + */ + +#pragma once + +#include <sal/types.h> + +namespace vcl +{ +/// Allows creating, updating and writing PDF objects in a container. +class SAL_NO_VTABLE SAL_DLLPUBLIC_RTTI PDFObjectContainer +{ +public: + /* adds an entry to m_aObjects and returns its index+1, + * sets the offset to ~0 + */ + virtual sal_Int32 createObject() = 0; + /* sets the offset of object n to the current position of output file+1 + */ + virtual bool updateObject(sal_Int32 n) = 0; + + // Write pBuffer to the end of the output. + virtual bool writeBuffer(const void* pBuffer, sal_uInt64 nBytes) = 0; + + virtual void checkAndEnableStreamEncryption(sal_Int32 nObject) = 0; + + virtual void disableStreamEncryption() = 0; + +protected: + ~PDFObjectContainer() noexcept = default; +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/fntstyle.hxx b/include/vcl/fntstyle.hxx new file mode 100644 index 000000000..03814c262 --- /dev/null +++ b/include/vcl/fntstyle.hxx @@ -0,0 +1,41 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_FNTSTYLE_HXX +#define INCLUDED_VCL_FNTSTYLE_HXX + +#include <sal/types.h> +#include <o3tl/typed_flags_set.hxx> + +enum class FontRelief { NONE, Embossed, Engraved, FontRelief_FORCE_EQUAL_SIZE=SAL_MAX_ENUM }; + +enum class FontKerning +{ + NONE = 0x00, + FontSpecific = 0x01, + Asian = 0x02, +}; +namespace o3tl +{ + template<> struct typed_flags<FontKerning> : is_typed_flags<FontKerning, 0x03> {}; +} + +#endif // INCLUDED_VCL_FNTSTYLE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/font.hxx b/include/vcl/font.hxx new file mode 100644 index 000000000..9f910688d --- /dev/null +++ b/include/vcl/font.hxx @@ -0,0 +1,194 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_FONT_HXX +#define INCLUDED_VCL_FONT_HXX + +#include <rtl/ustring.hxx> +#include <sal/types.h> +#include <vcl/dllapi.h> +#include <tools/color.hxx> +#include <tools/fontenum.hxx> +#include <tools/long.hxx> +#include <tools/degree.hxx> +#include <i18nlangtag/lang.h> +#include <vcl/fntstyle.hxx> +#include <o3tl/cow_wrapper.hxx> + +class Size; +class LanguageTag; +class SvStream; + +class ImplFont; +class FontAttributes; +namespace vcl { class Font; } +// need to first declare these outside the vcl namespace, or the friend declarations won't work right +VCL_DLLPUBLIC SvStream& ReadFont( SvStream& rIStm, vcl::Font& ); +VCL_DLLPUBLIC SvStream& WriteFont( SvStream& rOStm, const vcl::Font& ); + +namespace vcl { + +class SAL_WARN_UNUSED VCL_DLLPUBLIC Font +{ +public: + explicit Font(); + Font( const Font& ); // TODO make me explicit + Font( Font&& ) noexcept; + explicit Font( const OUString& rFamilyName, const Size& ); + explicit Font( const OUString& rFamilyName, const OUString& rStyleName, const Size& ); + explicit Font( FontFamily eFamily, const Size& ); + virtual ~Font(); + + const OUString& GetFamilyName() const; + FontFamily GetFamilyType(); + FontFamily GetFamilyType() const; + const OUString& GetStyleName() const; + + FontWeight GetWeight(); + FontWeight GetWeight() const; + FontItalic GetItalic(); + FontItalic GetItalic() const; + FontPitch GetPitch(); + FontPitch GetPitch() const; + FontWidth GetWidthType(); + FontWidth GetWidthType() const; + TextAlign GetAlignment() const; + rtl_TextEncoding GetCharSet() const; + + bool IsSymbolFont() const; + + void SetFamilyName( const OUString& rFamilyName ); + void SetStyleName( const OUString& rStyleName ); + void SetFamily( FontFamily ); + + void SetPitch( FontPitch ePitch ); + void SetItalic( FontItalic ); + void SetWeight( FontWeight ); + void SetWidthType( FontWidth ); + void SetAlignment( TextAlign ); + void SetCharSet( rtl_TextEncoding ); + + void SetSymbolFlag( bool ); + + // Device dependent functions + int GetQuality() const; + + void SetQuality(int); + void IncreaseQualityBy(int); + void DecreaseQualityBy(int); + + // setting the color on the font is obsolete, the only remaining + // valid use is for keeping backward compatibility with old MetaFiles + const Color& GetColor() const; + const Color& GetFillColor() const; + + bool IsTransparent() const; + + void SetColor( const Color& ); + void SetFillColor( const Color& ); + + void SetTransparent( bool bTransparent ); + + void SetFontSize( const Size& ); + const Size& GetFontSize() const; + void SetFontHeight( tools::Long nHeight ); + tools::Long GetFontHeight() const; + void SetAverageFontWidth( tools::Long nWidth ); + tools::Long GetAverageFontWidth() const; + + // tdf#127471 for corrections on EMF/WMF we need the AvgFontWidth in Windows-specific notation + tools::Long GetOrCalculateAverageFontWidth() const; + + // Prefer LanguageTag over LanguageType + void SetLanguageTag( const LanguageTag & ); + const LanguageTag& GetLanguageTag() const; + void SetCJKContextLanguageTag( const LanguageTag& ); + const LanguageTag& GetCJKContextLanguageTag() const; + void SetLanguage( LanguageType ); + LanguageType GetLanguage() const; + void SetCJKContextLanguage( LanguageType ); + LanguageType GetCJKContextLanguage() const; + + void SetOrientation( Degree10 nLineOrientation ); + Degree10 GetOrientation() const; + void SetVertical( bool bVertical ); + bool IsVertical() const; + void SetKerning( FontKerning nKerning ); + FontKerning GetKerning() const; + bool IsKerning() const; + + void SetOutline( bool bOutline ); + bool IsOutline() const; + void SetShadow( bool bShadow ); + bool IsShadow() const; + void SetRelief( FontRelief ); + FontRelief GetRelief() const; + void SetUnderline( FontLineStyle ); + FontLineStyle GetUnderline() const; + void SetOverline( FontLineStyle ); + FontLineStyle GetOverline() const; + void SetStrikeout( FontStrikeout ); + FontStrikeout GetStrikeout() const; + void SetEmphasisMark( FontEmphasisMark ); + FontEmphasisMark GetEmphasisMark() const; + void SetWordLineMode( bool bWordLine ); + bool IsWordLineMode() const; + + void Merge( const Font& rFont ); + void GetFontAttributes( FontAttributes& rAttrs ) const; + + Font& operator=( const Font& ); + Font& operator=( Font&& ) noexcept; + bool operator==( const Font& ) const; + bool operator!=( const Font& rFont ) const + { return !(Font::operator==( rFont )); } + bool IsSameInstance( const Font& ) const; + bool EqualIgnoreColor( const Font& ) const; + + // Compute value usable as hash. + size_t GetHashValue() const; + size_t GetHashValueIgnoreColor() const; + + friend VCL_DLLPUBLIC SvStream& ::ReadFont( SvStream& rIStm, vcl::Font& ); + friend VCL_DLLPUBLIC SvStream& ::WriteFont( SvStream& rOStm, const vcl::Font& ); + + static Font identifyFont( const void* pBuffer, sal_uInt32 nLen ); + + typedef o3tl::cow_wrapper< ImplFont > ImplType; + + inline bool IsUnderlineAbove() const; + +private: + ImplType mpImplFont; +}; + +inline bool Font::IsUnderlineAbove() const +{ + if (!IsVertical()) + return false; + // the underline is right for Japanese only + return (LANGUAGE_JAPANESE == GetLanguage()) || + (LANGUAGE_JAPANESE == GetCJKContextLanguage()); +} + +} + +#endif // _VCL_FONT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/font/Feature.hxx b/include/vcl/font/Feature.hxx new file mode 100644 index 000000000..3026f105f --- /dev/null +++ b/include/vcl/font/Feature.hxx @@ -0,0 +1,121 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_FONT_FEATURE_HXX +#define INCLUDED_VCL_FONT_FEATURE_HXX + +#include <vcl/dllapi.h> +#include <rtl/ustring.hxx> +#include <unotools/resmgr.hxx> +#include <vector> + +namespace vcl::font +{ +constexpr uint32_t featureCode(const char sFeature[4]) +{ + return static_cast<uint32_t>(sFeature[0]) << 24U | static_cast<uint32_t>(sFeature[1]) << 16U + | static_cast<uint32_t>(sFeature[2]) << 8U | static_cast<uint32_t>(sFeature[3]); +} + +VCL_DLLPUBLIC OUString featureCodeAsString(uint32_t nFeature); + +enum class FeatureParameterType +{ + BOOL, + ENUM +}; + +enum class FeatureType +{ + OpenType, + Graphite +}; + +struct VCL_DLLPUBLIC FeatureParameter +{ +private: + uint32_t m_nCode; + OUString m_sDescription; + TranslateId m_pDescriptionID; + +public: + FeatureParameter(uint32_t nCode, OUString aDescription); + FeatureParameter(uint32_t nCode, TranslateId pDescriptionID); + + uint32_t getCode() const; + OUString getDescription() const; +}; + +class VCL_DLLPUBLIC FeatureDefinition +{ +private: + OUString m_sDescription; + TranslateId m_pDescriptionID; + OUString m_sNumericPart; + uint32_t m_nCode; + uint32_t m_nDefault; + FeatureParameterType m_eType; + // the index of the parameter defines the enum value, string is the description + std::vector<FeatureParameter> m_aEnumParameters; + +public: + FeatureDefinition(); + FeatureDefinition(uint32_t nCode, OUString const& rDescription, + FeatureParameterType eType = FeatureParameterType::BOOL, + std::vector<FeatureParameter>&& rEnumParameters + = std::vector<FeatureParameter>{}, + uint32_t nDefault = 0); + FeatureDefinition(uint32_t nCode, TranslateId pDescriptionID, + OUString const& rNumericPart = OUString()); + FeatureDefinition(uint32_t nCode, TranslateId pDescriptionID, + std::vector<FeatureParameter> aEnumParameters); + + const std::vector<FeatureParameter>& getEnumParameters() const; + uint32_t getCode() const; + OUString getDescription() const; + FeatureParameterType getType() const; + uint32_t getDefault() const; + + operator bool() const; +}; + +struct VCL_DLLPUBLIC FeatureID +{ + uint32_t m_aFeatureCode; + uint32_t m_aScriptCode; + uint32_t m_aLanguageCode; +}; + +struct Feature +{ + Feature(); + Feature(FeatureID const& rID, FeatureType eType); + + FeatureID m_aID; + FeatureType m_eType; + FeatureDefinition m_aDefinition; +}; + +// This is basically duplicates hb_feature_t to avoid including HarfBuzz +// headers here, so the member types should remain compatible. +struct FeatureSetting +{ + FeatureSetting(OString feature); + + uint32_t m_nTag; + uint32_t m_nValue; + unsigned int m_nStart; + unsigned int m_nEnd; +}; + +} // namespace vcl::font + +#endif // INCLUDED_VCL_FONT_FEATURE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/font/FeatureParser.hxx b/include/vcl/font/FeatureParser.hxx new file mode 100644 index 000000000..93fe6eabe --- /dev/null +++ b/include/vcl/font/FeatureParser.hxx @@ -0,0 +1,48 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_FONT_FEATUREPASER_HXX +#define INCLUDED_VCL_FONT_FEATUREPASER_HXX + +#include <vcl/dllapi.h> +#include <rtl/ustring.hxx> +#include <vector> +#include <unordered_map> + +#include <vcl/font/Feature.hxx> + +namespace vcl::font +{ +// These must not conflict with font name lists which use ; and , +constexpr const char FeaturePrefix = ':'; +constexpr const char FeatureSeparator = '&'; + +VCL_DLLPUBLIC OUString trimFontNameFeatures(OUString const& rFontName); + +class VCL_DLLPUBLIC FeatureParser +{ +private: + OUString m_sLanguage; + std::vector<FeatureSetting> m_aFeatures; + +public: + FeatureParser(std::u16string_view sFontName); + + OUString const& getLanguage() const { return m_sLanguage; } + + std::vector<FeatureSetting> const& getFeatures() const { return m_aFeatures; } + + std::unordered_map<uint32_t, uint32_t> getFeaturesMap() const; +}; + +} // namespace vcl::font + +#endif // INCLUDED_VCL_FONT_FEATUREPASER_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/fontcapabilities.hxx b/include/vcl/fontcapabilities.hxx new file mode 100644 index 000000000..9698be7a5 --- /dev/null +++ b/include/vcl/fontcapabilities.hxx @@ -0,0 +1,203 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_FONTCAPABILITIES_HXX +#define INCLUDED_VCL_FONTCAPABILITIES_HXX + +#include <optional> +#include <bitset> + +//See OS/2 table, i.e. http://www.microsoft.com/typography/otspec/os2.htm#ur +namespace vcl +{ + namespace UnicodeCoverage + { + enum UnicodeCoverageEnum + { + BASIC_LATIN = 0, + LATIN_1_SUPPLEMENT = 1, + LATIN_EXTENDED_A = 2, + LATIN_EXTENDED_B = 3, + IPA_EXTENSIONS = 4, + SPACING_MODIFIER_LETTERS = 5, + COMBINING_DIACRITICAL_MARKS = 6, + GREEK_AND_COPTIC = 7, + COPTIC = 8, + CYRILLIC = 9, + ARMENIAN = 10, + HEBREW = 11, + VAI = 12, + ARABIC = 13, + NKO = 14, + DEVANAGARI = 15, + BENGALI = 16, + GURMUKHI = 17, + GUJARATI = 18, + ODIA = 19, + TAMIL = 20, + TELUGU = 21, + KANNADA = 22, + MALAYALAM = 23, + THAI = 24, + LAO = 25, + GEORGIAN = 26, + BALINESE = 27, + HANGUL_JAMO = 28, + LATIN_EXTENDED_ADDITIONAL = 29, + GREEK_EXTENDED = 30, + GENERAL_PUNCTUATION = 31, + SUPERSCRIPTS_AND_SUBSCRIPTS = 32, + CURRENCY_SYMBOLS = 33, + COMBINING_DIACRITICAL_MARKS_FOR_SYMBOLS = 34, + LETTERLIKE_SYMBOLS = 35, + NUMBER_FORMS = 36, + ARROWS = 37, + MATHEMATICAL_OPERATORS = 38, + MISCELLANEOUS_TECHNICAL = 39, + CONTROL_PICTURES = 40, + OPTICAL_CHARACTER_RECOGNITION = 41, + ENCLOSED_ALPHANUMERICS = 42, + BOX_DRAWING = 43, + BLOCK_ELEMENTS = 44, + GEOMETRIC_SHAPES = 45, + MISCELLANEOUS_SYMBOLS = 46, + DINGBATS = 47, + CJK_SYMBOLS_AND_PUNCTUATION = 48, + HIRAGANA = 49, + KATAKANA = 50, + BOPOMOFO = 51, + HANGUL_COMPATIBILITY_JAMO = 52, + PHAGS_PA = 53, + ENCLOSED_CJK_LETTERS_AND_MONTHS = 54, + CJK_COMPATIBILITY = 55, + HANGUL_SYLLABLES = 56, + NONPLANE_0 = 57, + PHOENICIAN = 58, + CJK_UNIFIED_IDEOGRAPHS = 59, + PRIVATE_USE_AREA_PLANE_0 = 60, + CJK_STROKES = 61, + ALPHABETIC_PRESENTATION_FORMS = 62, + ARABIC_PRESENTATION_FORMS_A = 63, + COMBINING_HALF_MARKS = 64, + VERTICAL_FORMS = 65, + SMALL_FORM_VARIANTS = 66, + ARABIC_PRESENTATION_FORMS_B = 67, + HALFWIDTH_AND_FULLWIDTH_FORMS = 68, + SPECIALS = 69, + TIBETAN = 70, + SYRIAC = 71, + THAANA = 72, + SINHALA = 73, + MYANMAR = 74, + ETHIOPIC = 75, + CHEROKEE = 76, + UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS = 77, + OGHAM = 78, + RUNIC = 79, + KHMER = 80, + MONGOLIAN = 81, + BRAILLE_PATTERNS = 82, + YI_SYLLABLES = 83, + TAGALOG = 84, + OLD_ITALIC = 85, + GOTHIC = 86, + DESERET = 87, + BYZANTINE_MUSICAL_SYMBOLS = 88, + MATHEMATICAL_ALPHANUMERIC_SYMBOLS = 89, + PRIVATE_USE_PLANE_15 = 90, + VARIATION_SELECTORS = 91, + TAGS = 92, + LIMBU = 93, + TAI_LE = 94, + NEW_TAI_LUE = 95, + BUGINESE = 96, + GLAGOLITIC = 97, + TIFINAGH = 98, + YIJING_HEXAGRAM_SYMBOLS = 99, + SYLOTI_NAGRI = 100, + LINEAR_B_SYLLABARY = 101, + ANCIENT_GREEK_NUMBERS = 102, + UGARITIC = 103, + OLD_PERSIAN = 104, + SHAVIAN = 105, + OSMANYA = 106, + CYPRIOT_SYLLABARY = 107, + KHAROSHTHI = 108, + TAI_XUAN_JING_SYMBOLS = 109, + CUNEIFORM = 110, + COUNTING_ROD_NUMERALS = 111, + SUNDANESE = 112, + LEPCHA = 113, + OL_CHIKI = 114, + SAURASHTRA = 115, + KAYAH_LI = 116, + REJANG = 117, + CHAM = 118, + ANCIENT_SYMBOLS = 119, + PHAISTOS_DISC = 120, + CARIAN = 121, + DOMINO_TILES = 122, + RESERVED1 = 123, + RESERVED2 = 124, + RESERVED3 = 125, + RESERVED4 = 126, + RESERVED5 = 127, + MAX_UC_ENUM = 128 + }; + }; + + namespace CodePageCoverage + { + enum CodePageCoverageEnum + { + CP1252 = 0, + CP1250 = 1, + CP1251 = 2, + CP1253 = 3, + CP1254 = 4, + CP1255 = 5, + CP1256 = 6, + CP1257 = 7, + CP1258 = 8, + CP874 = 16, + CP932 = 17, + CP936 = 18, + CP949 = 19, + CP950 = 20, + CP1361 = 21, + CP869 = 48, + CP866 = 49, + CP865 = 50, + CP864 = 51, + CP863 = 52, + CP862 = 53, + CP861 = 54, + CP860 = 55, + CP857 = 56, + CP855 = 57, + CP852 = 58, + CP775 = 59, + CP737 = 60, + CP780 = 61, + CP850 = 62, + CP437 = 63, + MAX_CP_ENUM = 64 + }; + }; + + struct FontCapabilities + { + std::optional<std::bitset<UnicodeCoverage::MAX_UC_ENUM>> oUnicodeRange; + std::optional<std::bitset<CodePageCoverage::MAX_CP_ENUM>> oCodePageRange; + }; +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/fontcharmap.hxx b/include/vcl/fontcharmap.hxx new file mode 100644 index 000000000..ade1da6e7 --- /dev/null +++ b/include/vcl/fontcharmap.hxx @@ -0,0 +1,174 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_FONTCHARMAP_HXX +#define INCLUDED_FONTCHARMAP_HXX + +#include <vcl/dllapi.h> +#include <vcl/vclenum.hxx> +#include <tools/ref.hxx> + +class ImplFontCharMap; +class CmapResult; +class FontCharMap; +class OutputDevice; + +typedef tools::SvRef<ImplFontCharMap> ImplFontCharMapRef; +typedef tools::SvRef<FontCharMap> FontCharMapRef; + +class VCL_DLLPUBLIC FontCharMap final : public SvRefBase +{ +public: + /** A new FontCharMap is created based on a "default" map, which includes + all codepoints in the Unicode BMP range, including surrogates. + **/ + FontCharMap(); + + /** A new FontCharMap is created based on the CmapResult + */ + FontCharMap( const CmapResult& rCR ); + + virtual ~FontCharMap() override; + + /** Get the default font character map + + @returns the default font character map. + */ + static FontCharMapRef GetDefaultMap( bool bSymbols ); + + /** Determines if the font character map is the "default". The default map + includes all codepoints in the Unicode BMP range, including surrogates. + + @returns true if default map, false if not default map. + */ + bool IsDefaultMap() const; + + /** Does the font character map include the UCS4 character? + + @returns true if character exists in font character map, false is not. + */ + bool HasChar( sal_UCS4 ) const; + + /** Returns the number of chars supported by the font, which + are inside the unicode range from cMin to cMax (inclusive). + + @param cMin Lowest codepoint in range to be counted + @param cMax Highest codepoint in range to be counted + + @returns number of characters in the font charmap between the two + codepoints. + */ + int CountCharsInRange( sal_UCS4 cMin, sal_UCS4 cMax ) const; + + /** Get the number of characters in the font character map. + + @returns number of characters in the font character map. + */ + int GetCharCount() const; + + /** Get the first character in the font character map. + + @returns first character in the font character map. + */ + sal_UCS4 GetFirstChar() const; + + /** Get the last character in the font character map. + + @returns last character in the font character map. + */ + sal_UCS4 GetLastChar() const; + + /** Get the next character in the font character map. This is important + because character maps (e.g. the default map which holds the characters + in the BMP plane) can have discontiguous ranges. + + @param cChar Character from which to find next character + + @returns next character in the font character map. + */ + sal_UCS4 GetNextChar( sal_UCS4 cChar ) const; + + /** Get the previous character in the font character map. This is important + because character maps (e.g. the default map which holds the characters + in the BMP plane) can have discontiguous ranges. + + @param cChar Character from which to find previous character + + @returns previous character in the font character map. + */ + sal_UCS4 GetPrevChar( sal_UCS4 cChar ) const; + + /** Get the index of a particular character in the font character map. The + index is different from the codepoint, because font character maps can + + determine the index. + + @param cChar Character used to find index number + + @returns Index of character in font character map. + */ + int GetIndexFromChar( sal_UCS4 cChar ) const; + + /** Get the character at a particular index in the font character map. The + index is different from the codepoint, because font character maps can + + determine the character. + + @param nCharIndex Index used to find the character + + @returns Character in font character map. + */ + sal_UCS4 GetCharFromIndex( int nCharIndex ) const; + + int GetGlyphIndex( sal_UCS4 ) const; + + bool isSymbolic() const; + +private: + ImplFontCharMapRef mpImplFontCharMap; + + friend class ::OutputDevice; + + int findRangeIndex( sal_UCS4 ) const; + + FontCharMap( ImplFontCharMapRef const & pIFCMap ); + + // prevent assignment and copy construction + FontCharMap( const FontCharMap& ) = delete; + void operator=( const FontCharMap& ) = delete; +}; + +// CmapResult is a normalized version of the many CMAP formats +class VCL_PLUGIN_PUBLIC CmapResult +{ +public: + explicit CmapResult( bool bSymbolic = false, + const sal_UCS4* pRangeCodes = nullptr, int nRangeCount = 0 ); + + const sal_UCS4* mpRangeCodes; + const int* mpStartGlyphs; + const sal_uInt16* mpGlyphIds; + int mnRangeCount; + bool mbSymbolic; + bool mbRecoded; +}; + +#endif // INCLUDED_FONTCHARMAP_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/formatter.hxx b/include/vcl/formatter.hxx new file mode 100644 index 000000000..2049d1e12 --- /dev/null +++ b/include/vcl/formatter.hxx @@ -0,0 +1,316 @@ +/* -*- 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 . + */ + +#pragma once + +#include <config_options.h> +#include <i18nlangtag/lang.h> +#include <tools/link.hxx> +#include <tools/solar.h> +#include <vcl/settings.hxx> +#include <map> +#include <memory> +#include <string_view> + +class SvNumberFormatter; + +namespace validation +{ + // the states of our automat. + enum State + { + START, // at the very start of the string + NUM_START, // the very start of the number + + DIGIT_PRE_COMMA, // some pre-comma digits are read, perhaps including some thousand separators + + DIGIT_POST_COMMA, // reading digits after the comma + EXPONENT_START, // at the very start of the exponent value + // (means: not including the "e" which denotes the exponent) + EXPONENT_DIGIT, // currently reading the digits of the exponent + + END // reached the end of the string + }; + + // a row in the transition table (means the set of states to be reached from a given state) + typedef ::std::map< sal_Unicode, State > StateTransitions; + + // a single transition + typedef StateTransitions::value_type Transition; + + // the complete transition table + typedef ::std::map< State, StateTransitions > TransitionTable; + + // the validator class + class NumberValidator + { + private: + TransitionTable m_aTransitions; + + public: + NumberValidator( const sal_Unicode _cThSep, const sal_Unicode _cDecSep ); + + bool isValidNumericFragment( std::u16string_view _rText ); + + private: + bool implValidateNormalized( const OUString& _rText ); + }; +} + +enum class FORMAT_CHANGE_TYPE +{ + KEYONLY = 0x00, // only a new key was set + FORMATTER = 0x01, // a new formatter was set, usually implies a change of the key, too + PRECISION = 0x02, // a new precision was set + THOUSANDSSEP = 0x03, // the thousands separator setting changed + CURRENCY_SYMBOL = 0x10, + CURRSYM_POSITION = 0x20, +}; + +class VCL_DLLPUBLIC Formatter +{ +public: + // A SvNumberFormatter is very expensive (regarding time and space), it is a Singleton + class StaticFormatter + { + static SvNumberFormatter* s_cFormatter; + static sal_uLong s_nReferences; + public: + StaticFormatter(); + ~StaticFormatter(); + + operator SvNumberFormatter* () const { return GetFormatter(); } + UNLESS_MERGELIBS(VCL_DLLPUBLIC) static SvNumberFormatter* GetFormatter(); + }; + +protected: + OUString m_sLastValidText; + // Has nothing to do with the current value. It is the last text, which was valid at input (checked by CheckText, + // not yet through formatter) + Selection m_aLastSelection; + + double m_dMinValue; + double m_dMaxValue; + bool m_bHasMin : 1; + bool m_bHasMax : 1; + + bool m_bWrapOnLimits : 1; + bool m_bStrictFormat : 1; + + bool m_bEnableEmptyField : 1; + bool m_bAutoColor : 1; + bool m_bEnableNaN : 1; + bool m_bDisableRemainderFactor : 1; + enum valueState { valueDirty, valueString, valueDouble }; + valueState m_ValueState; + double m_dCurrentValue; + double m_dDefaultValue; + + sal_uLong m_nFormatKey; + SvNumberFormatter* m_pFormatter; + StaticFormatter m_aStaticFormatter; + + double m_dSpinSize; + double m_dSpinFirst; + double m_dSpinLast; + + // There is a difference, when text formatting is enabled, if LostFocus formats the current String and displays it, + // or if a double is created from the String and then + bool m_bTreatAsNumber; + // And with the following members we can use it for formatted text output as well ... + OUString m_sCurrentTextValue; + OUString m_sDefaultText; + + // The last color from the Formatter at the last output operation (not we would use it, but you can get it) + const Color* m_pLastOutputColor; + + bool m_bUseInputStringForFormatting; + + Link<sal_Int64*, TriState> m_aInputHdl; + Link<LinkParamNone*, bool> m_aOutputHdl; + +public: + Formatter(); + virtual ~Formatter(); + + void SetFieldText(const OUString& rText, const Selection& rNewSelection); + + virtual Selection GetEntrySelection() const = 0; + virtual OUString GetEntryText() const = 0; + virtual SelectionOptions GetEntrySelectionOptions() const = 0; + virtual void SetEntryText(const OUString& rText, const Selection& rSel) = 0; + virtual void SetEntryTextColor(const Color* pColor) = 0; + virtual void FieldModified() = 0; + + // Min-/Max-management + bool HasMinValue() const { return m_bHasMin; } + virtual void ClearMinValue() { m_bHasMin = false; } + virtual void SetMinValue(double dMin); + double GetMinValue() const { return m_dMinValue; } + + bool HasMaxValue() const { return m_bHasMax; } + virtual void ClearMaxValue() { m_bHasMax = false; } + virtual void SetMaxValue(double dMax); + double GetMaxValue() const { return m_dMaxValue; } + + // Current value + void SetValue(double dVal); + double GetValue(); + // The default implementation uses a formatter, if available + + void SetTextValue(const OUString& rText); + // The String is transformed to a double (with a formatter) and SetValue is called afterwards + + bool IsEmptyFieldEnabled() const { return m_bEnableEmptyField; } + void EnableEmptyField(bool bEnable); + // If disabled, the value will be reset to the last valid value on leave + + void SetDefaultValue(double dDefault) { m_dDefaultValue = dDefault; m_ValueState = valueDirty; } + // If the current String is invalid, GetValue() returns this value + double GetDefaultValue() const { return m_dDefaultValue; } + + void SetLastSelection(const Selection& rSelection) { m_aLastSelection = rSelection; } + + // Settings for the format + sal_uLong GetFormatKey() const { return m_nFormatKey; } + void SetFormatKey(sal_uLong nFormatKey); + + SvNumberFormatter* GetOrCreateFormatter() const { return m_pFormatter ? m_pFormatter : const_cast<Formatter*>(this)->CreateFormatter(); } + + SvNumberFormatter* GetFormatter() const { return m_pFormatter; } + void SetFormatter(SvNumberFormatter* pFormatter, bool bResetFormat = true); + // If bResetFormat is sal_False, the old format is tried to be kept. (expensive, if it is no default format, available in all formatters) + // If sal_True, the new FormatKey is set to zero + + bool GetThousandsSep() const; + void SetThousandsSep(bool _bUseSeparator); + // the is no check if the current format is numeric, so be cautious when calling these functions + + void DisableRemainderFactor(); + bool GetDisableRemainderFactor() const { return m_bDisableRemainderFactor; } + + void SetWrapOnLimits(bool bWrapOnLimits) { m_bWrapOnLimits = bWrapOnLimits; } + + sal_uInt16 GetDecimalDigits() const; + void SetDecimalDigits(sal_uInt16 _nPrecision); + // There is no check if the current format is numeric, so be cautious when calling these functions + + SvNumberFormatter* StandardFormatter() { return m_aStaticFormatter; } + // If no new Formatter is created explicitly, this can be used in SetFormatter... + + OUString GetFormat(LanguageType& eLang) const; + bool SetFormat(const OUString& rFormatString, LanguageType eLang); + // sal_False, if the FormatString could not be set (and very probably is invalid) + // This Object is shared via all instances, so be careful! + + bool IsStrictFormat() const { return m_bStrictFormat; } + void SetStrictFormat(bool bEnable) { m_bStrictFormat = bEnable; } + // Check format during input + + virtual void SetSpinSize(double dStep) { m_dSpinSize = dStep; } + double GetSpinSize() const { return m_dSpinSize; } + + void SetSpinFirst(double dFirst) { m_dSpinFirst = dFirst; } + double GetSpinFirst() const { return m_dSpinFirst; } + + void SetSpinLast(double dLast) { m_dSpinLast = dLast; } + double GetSpinLast() const { return m_dSpinLast; } + + bool TreatingAsNumber() const { return m_bTreatAsNumber; } + void TreatAsNumber(bool bDoSo) { m_bTreatAsNumber = bDoSo; } + + void SetInputHdl(const Link<sal_Int64*,TriState>& rLink) { m_aInputHdl = rLink; } + void SetOutputHdl(const Link<LinkParamNone*, bool>& rLink) { m_aOutputHdl = rLink; } +public: + + //The following methods are interesting, if m_bTreatAsNumber is set to sal_False + //If someone does not care about all the double handling and just wants to print the text formatted. + //(((The text will be formatted, using the Formatter, and then set) + void SetTextFormatted(const OUString& rText); + OUString const & GetTextValue() const; + + void SetDefaultText(const OUString& rDefault) { m_sDefaultText = rDefault; } + const OUString& GetDefaultText() const { return m_sDefaultText; } + + // The last colour from the Formatter's last output operation. Output operations get triggered by: + // SetValue, SetTextValue, SetTextFormatted, also indirectly via SetMin - / -MaxValue + const Color* GetLastOutputColor() const { return m_pLastOutputColor; } + + /** reformats the current text. Interesting if the user entered some text in an "input format", and + this should be formatted in the "output format" (which may differ, e.g. by additional numeric + digits or such). + */ + void Commit(); + + // enable automatic coloring. if set to sal_True, and the format the field is working with for any current value + // says that it has to be painted in a special color (e.g. a format where negative numbers should be printed + // red), the text is painted with that color automatically. + // The color used is the same as returned by GetLastOutputColor() + void SetAutoColor(bool _bAutomatic); + + /** enables handling of not-a-number value. + + When this is set to <FALSE/> (the default), then invalid inputs (i.e. text which cannot be + interpreted, according to the current formatting) will be handled as if the default value + has been entered. GetValue the will return this default value. + + When set to <TRUE/>, then GetValue will return NaN (not a number, see <method scope="rtl::math">isNan</method>) + when the current input is invalid. + + Note that setting this to <TRUE/> implies that upon leaving the control, the input + will *not* be corrected to a valid value. For example, if the user enters "foo" in the + control, and then tabs out of it, the text "foo" will persist, and GetValue will + return NaN in subsequent calls. + */ + void EnableNotANumber( bool _bEnable ); + + /** When being set to true, the strings in the field are formatted using the + InputLine format. That's also what you get in Calc when you edit a cell + using F2 + */ + void UseInputStringForFormatting(); + bool IsUsingInputStringForFormatting() const { return m_bUseInputStringForFormatting;} + + void Modify(bool makeValueDirty = true); + + void EntryLostFocus(); + + void ReFormat(); + + // any aspect of the current format has changed + virtual void FormatChanged(FORMAT_CHANGE_TYPE nWhat); + +protected: + + // Override CheckText for input-time checks + virtual bool CheckText(const OUString&) const { return true; } + + void ImplSetTextImpl(const OUString& rNew, Selection const * pNewSel); + void ImplSetValue(double dValue, bool bForce); + bool ImplGetValue(double& dNewVal); + + void ImplSetFormatKey(sal_uLong nFormatKey); + // SetFormatKey without FormatChanged notification + + SvNumberFormatter* CreateFormatter() { SetFormatter(StandardFormatter()); return m_pFormatter; } + + virtual void UpdateCurrentValue(double dCurrentValue) { m_dCurrentValue = dCurrentValue; } +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/gdimetafiletools.hxx b/include/vcl/gdimetafiletools.hxx new file mode 100644 index 000000000..665683dd2 --- /dev/null +++ b/include/vcl/gdimetafiletools.hxx @@ -0,0 +1,55 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_VCL_GDIMETAFILETOOLS_HXX +#define INCLUDED_VCL_GDIMETAFILETOOLS_HXX + +#include <config_options.h> +#include <vcl/dllapi.h> + +class GDIMetaFile; + +// #i121267# Added tooling to be able to support old exporters which are based on +// metafiles as graphic content, but do not implement using the contained clip +// regions. +// The given metafile will internally clip it's graphic content against the +// included clip regions so that it is safe to ignore clip actions there. This +// is not done completely, but implemented and extended as needed (on demand) +// since all this is a workaround; the better and long term solution will be to +// reimplement these im/exports to use primitives and not metafiles as base +// information. + +void clipMetafileContentAgainstOwnRegions(GDIMetaFile& rSource); + +// Allow to check if a Metafile contains clipping or not + +bool usesClipActions(const GDIMetaFile& rSource); + +// hook to access metafile members in classes of modules above vcl. Currently +// used in MetafilePrimitive2D to be able to access the local Metafile member +// e.g. from vcl module +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetafileAccessor +{ +public: + virtual void accessMetafile(GDIMetaFile& rTargetMetafile) const = 0; + virtual ~MetafileAccessor(); +}; + +#endif // INCLUDED_VCL_GDIMETAFILETOOLS_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/gdimtf.hxx b/include/vcl/gdimtf.hxx new file mode 100644 index 000000000..f86376754 --- /dev/null +++ b/include/vcl/gdimtf.hxx @@ -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 . + */ + +#ifndef INCLUDED_VCL_GDIMTF_HXX +#define INCLUDED_VCL_GDIMTF_HXX + +#include <vcl/dllapi.h> +#include <tools/gen.hxx> +#include <tools/solar.h> +#include <vcl/mapmod.hxx> +#include <vcl/bitmap.hxx> +#include <vcl/vclptr.hxx> +#include <vector> + +class OutputDevice; +class MetaAction; +class SvStream; +class Color; +class BitmapEx; +namespace tools { + class Polygon; + class PolyPolygon; +} +class Gradient; +struct ImplMetaReadData; + +#define GDI_METAFILE_END (size_t(0xFFFFFFFF)) + +enum class MtfConversion +{ + N1BitThreshold, + N8BitGreys +}; + + +typedef Color (*ColorExchangeFnc)( const Color& rColor, const void* pColParam ); +typedef BitmapEx (*BmpExchangeFnc)( const BitmapEx& rBmpEx, const void* pBmpParam ); + +class VCL_DLLPUBLIC GDIMetaFile final +{ +private: + ::std::vector< rtl::Reference<MetaAction> > m_aList; + size_t m_nCurrentActionElement; + + MapMode m_aPrefMapMode; + Size m_aPrefSize; + GDIMetaFile* m_pPrev; + GDIMetaFile* m_pNext; + VclPtr<OutputDevice> m_pOutDev; + bool m_bPause; + bool m_bRecord; + bool m_bUseCanvas; + + + SAL_DLLPRIVATE static Color ImplColAdjustFnc( const Color& rColor, const void* pColParam ); + SAL_DLLPRIVATE static BitmapEx ImplBmpAdjustFnc( const BitmapEx& rBmpEx, const void* pBmpParam ); + + SAL_DLLPRIVATE static Color ImplColConvertFnc( const Color& rColor, const void* pColParam ); + SAL_DLLPRIVATE static BitmapEx ImplBmpConvertFnc( const BitmapEx& rBmpEx, const void* pBmpParam ); + + SAL_DLLPRIVATE static Color ImplColMonoFnc( const Color& rColor, const void* pColParam ); + SAL_DLLPRIVATE static BitmapEx ImplBmpMonoFnc( const BitmapEx& rBmpEx, const void* pBmpParam ); + + SAL_DLLPRIVATE static Color ImplColReplaceFnc( const Color& rColor, const void* pColParam ); + SAL_DLLPRIVATE static BitmapEx ImplBmpReplaceFnc( const BitmapEx& rBmpEx, const void* pBmpParam ); + + SAL_DLLPRIVATE void ImplExchangeColors( ColorExchangeFnc pFncCol, const void* pColParam, + BmpExchangeFnc pFncBmp, const void* pBmpParam ); + + SAL_DLLPRIVATE static Point ImplGetRotatedPoint( const Point& rPt, const Point& rRotatePt, + const Size& rOffset, double fSin, double fCos ); + SAL_DLLPRIVATE static tools::Polygon ImplGetRotatedPolygon( const tools::Polygon& rPoly, const Point& rRotatePt, + const Size& rOffset, double fSin, double fCos ); + SAL_DLLPRIVATE static tools::PolyPolygon ImplGetRotatedPolyPolygon( const tools::PolyPolygon& rPoly, const Point& rRotatePt, + const Size& rOffset, double fSin, double fCos ); + SAL_DLLPRIVATE static void ImplAddGradientEx( GDIMetaFile& rMtf, + const OutputDevice& rMapDev, + const tools::PolyPolygon& rPolyPoly, + const Gradient& rGrad ); + + SAL_DLLPRIVATE bool ImplPlayWithRenderer(OutputDevice& rOut, const Point& rPos, Size rLogicDestSize); + + void Linker( OutputDevice* pOut, bool bLink ); + +public: + GDIMetaFile(); + GDIMetaFile( const GDIMetaFile& rMtf ); + ~GDIMetaFile(); + + GDIMetaFile& operator=( const GDIMetaFile& rMtf ); + bool operator==( const GDIMetaFile& rMtf ) const; + bool operator!=( const GDIMetaFile& rMtf ) const { return !( *this == rMtf ); } + + void Clear(); + void Mirror( BmpMirrorFlags nMirrorFlags ); + void Move( tools::Long nX, tools::Long nY ); + // additional Move method getting specifics how to handle MapMode( MapUnit::MapPixel ) + void Move( tools::Long nX, tools::Long nY, tools::Long nDPIX, tools::Long nDPIY ); + void Scale( double fScaleX, double fScaleY ); + void Scale( const Fraction& rScaleX, const Fraction& rScaleY ); + void Rotate( Degree10 nAngle10 ); + void Clip( const tools::Rectangle& ); + bool HasTransparentActions() const; + + /* get the bound rect of the contained actions + * caveats: + * - clip actions will limit the contained actions, + * but the current clipregion of the passed OutputDevice will not + * - coordinates of actions will be transformed to preferred mapmode + * - the returned rectangle is relative to the preferred mapmode of the metafile + */ + tools::Rectangle GetBoundRect( OutputDevice& i_rReference ) const; + + void Adjust( short nLuminancePercent, short nContrastPercent, + short nChannelRPercent = 0, short nChannelGPercent = 0, + short nChannelBPercent = 0, double fGamma = 1.0, + bool bInvert = false, bool msoBrightness = false ); + + void Convert( MtfConversion eConversion ); + void ReplaceColors( const Color* pSearchColors, const Color* rReplaceColors, + sal_uLong nColorCount ); + + GDIMetaFile GetMonochromeMtf( const Color& rCol ) const; + + void Record( OutputDevice* pOutDev ); + bool IsRecord() const { return m_bRecord; } + + void Play(GDIMetaFile& rMtf); + void Play(OutputDevice& rOutDev, size_t nPos = GDI_METAFILE_END); + void Play(OutputDevice& rOutDev, const Point& rPos, const Size& rSize); + + void Pause( bool bPause ); + bool IsPause() const { return m_bPause; } + + void Stop(); + + void WindStart(); + void WindPrev(); + + size_t GetActionSize() const; + + void AddAction(const rtl::Reference<MetaAction>& pAction); + void AddAction(const rtl::Reference<MetaAction>& pAction, size_t nPos); + void push_back(const rtl::Reference<MetaAction>& pAction); + /** + * @param pAction takes ownership + * @param nAction the action to replace + */ + void ReplaceAction( rtl::Reference<MetaAction> pAction, size_t nAction ); + + MetaAction* FirstAction(); + MetaAction* NextAction(); + MetaAction* GetAction( size_t nAction ) const; + MetaAction* GetCurAction() const { return GetAction( m_nCurrentActionElement ); } + + const Size& GetPrefSize() const { return m_aPrefSize; } + void SetPrefSize( const Size& rSize ) { m_aPrefSize = rSize; } + + const MapMode& GetPrefMapMode() const { return m_aPrefMapMode; } + void SetPrefMapMode( const MapMode& rMapMode ) { m_aPrefMapMode = rMapMode; } + + + sal_uLong GetSizeBytes() const; + + /// Creates an antialiased thumbnail + bool CreateThumbnail(BitmapEx& rBitmapEx, + BmpConversion nColorConversion = BmpConversion::N24Bit, + BmpScaleFlag nScaleFlag = BmpScaleFlag::BestQuality) const; + + void UseCanvas( bool _bUseCanvas ); + bool GetUseCanvas() const { return m_bUseCanvas; } + + /// Dumps the meta actions as XML in metafile.xml. + void dumpAsXml(const char* pFileName = nullptr) const; +}; + +#endif // INCLUDED_VCL_GDIMTF_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/gfxlink.hxx b/include/vcl/gfxlink.hxx new file mode 100644 index 000000000..30228f339 --- /dev/null +++ b/include/vcl/gfxlink.hxx @@ -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 . + */ + +#ifndef INCLUDED_VCL_GFXLINK_HXX +#define INCLUDED_VCL_GFXLINK_HXX + +#include <tools/gen.hxx> +#include <vcl/dllapi.h> +#include <vcl/mapmod.hxx> +#include <vcl/BinaryDataContainer.hxx> +#include <memory> + +class SvStream; + +/** GfxLink graphic types that are supported by GfxLink. + * + * It is important that the numbers for native types stay the same, because + * they are used in serialization to MTF. + */ +enum class GfxLinkType +{ + NONE = 0, + EpsBuffer = 1, + NativeGif = 2, + NativeJpg = 3, + NativePng = 4, + NativeTif = 5, + NativeWmf = 6, + NativeMet = 7, + NativePct = 8, + NativeSvg = 9, + NativeMov = 10, + NativeBmp = 11, + NativePdf = 12, + NativeWebp = 13, // If a new type is added, make sure to change NativeLast too + + // Alias for when the first native type starts and last native + // type ends. + NativeFirst = NativeGif, + NativeLast = NativeWebp, +}; + +class Graphic; + +class VCL_DLLPUBLIC GfxLink +{ +private: + GfxLinkType meType; + sal_uInt32 mnUserId; + BinaryDataContainer maDataContainer; + mutable size_t maHash; + MapMode maPrefMapMode; + Size maPrefSize; + bool mbPrefMapModeValid; + bool mbPrefSizeValid; + +public: + GfxLink(); + explicit GfxLink(std::unique_ptr<sal_uInt8[]> pBuf, sal_uInt32 nBufSize, GfxLinkType nType); + explicit GfxLink(BinaryDataContainer const & rDataConainer, GfxLinkType nType); + + bool operator==( const GfxLink& ) const; + + GfxLinkType GetType() const { return meType;} + + size_t GetHash() const; + + void SetUserId( sal_uInt32 nUserId ) { mnUserId = nUserId; } + sal_uInt32 GetUserId() const { return mnUserId; } + + sal_uInt32 GetDataSize() const { return maDataContainer.getSize(); } + const sal_uInt8* GetData() const; + + const BinaryDataContainer& getDataContainer() const + { + return maDataContainer; + } + + const Size& GetPrefSize() const { return maPrefSize;} + void SetPrefSize( const Size& rPrefSize ); + bool IsPrefSizeValid() const { return mbPrefSizeValid;} + + const MapMode& GetPrefMapMode() const { return maPrefMapMode;} + void SetPrefMapMode( const MapMode& rPrefMapMode ); + bool IsPrefMapModeValid() const { return mbPrefMapModeValid;} + + bool IsNative() const; + + bool LoadNative( Graphic& rGraphic ) const; + + bool ExportNative( SvStream& rOStream ) const; + + bool IsEMF() const; // WMF & EMF stored under the same type (NativeWmf) +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/glyphitem.hxx b/include/vcl/glyphitem.hxx new file mode 100644 index 000000000..23ae5a877 --- /dev/null +++ b/include/vcl/glyphitem.hxx @@ -0,0 +1,57 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_GLYPHITEM_HXX +#define INCLUDED_VCL_GLYPHITEM_HXX + +#include <sal/types.h> +#include <vcl/dllapi.h> + +#include <vector> +#include <memory> + +class SalLayoutGlyphsImpl; + +class VCL_DLLPUBLIC SalLayoutGlyphs final +{ + std::unique_ptr<SalLayoutGlyphsImpl> m_pImpl; + // Extra items are in a dynamically allocated vector in order to save memory. + // The usual case should be that this stays unused (it should be only used + // when font fallback takes place). + std::unique_ptr<std::vector<std::unique_ptr<SalLayoutGlyphsImpl>>> m_pExtraImpls; + +public: + SalLayoutGlyphs(); + SalLayoutGlyphs(const SalLayoutGlyphs&) = delete; + SalLayoutGlyphs(SalLayoutGlyphs&&) noexcept; + ~SalLayoutGlyphs(); + + SalLayoutGlyphs& operator=(const SalLayoutGlyphs&) = delete; + SalLayoutGlyphs& operator=(SalLayoutGlyphs&&) noexcept; + + SalLayoutGlyphsImpl* Impl(unsigned int nLevel) const; + void AppendImpl(SalLayoutGlyphsImpl* pImpl); + + bool IsValid() const; + void Invalidate(); +}; + +#endif // INCLUDED_VCL_GLYPHITEM_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/glyphitemcache.hxx b/include/vcl/glyphitemcache.hxx new file mode 100644 index 000000000..ed48f8c34 --- /dev/null +++ b/include/vcl/glyphitemcache.hxx @@ -0,0 +1,111 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_GLYPHITEMCACHE_HXX +#define INCLUDED_VCL_GLYPHITEMCACHE_HXX + +#include <sal/types.h> +#include <vcl/dllapi.h> + +#include <o3tl/lru_map.hxx> +#include <o3tl/hash_combine.hxx> +#include <vcl/glyphitem.hxx> +#include <vcl/metric.hxx> +#include <vcl/outdev.hxx> +#include <vcl/vclptr.hxx> +#include <tools/gen.hxx> + +#include <optional> + +/** +A cache for SalLayoutGlyphs objects. + +Allows caching for OutputDevice::DrawText() and similar calls. Pass the text and the output device +for the call to OutputDevice::ImplLayout(). Items are cached per output device and its font. +If something more changes, call clear(). +*/ +class VCL_DLLPUBLIC SalLayoutGlyphsCache final +{ +public: + // NOTE: The lifetime of the returned value is guaranteed only until the next call + // to any function in this class. + const SalLayoutGlyphs* GetLayoutGlyphs(VclPtr<const OutputDevice> outputDevice, + const OUString& text, + const vcl::text::TextLayoutCache* layoutCache = nullptr) + { + return GetLayoutGlyphs(outputDevice, text, 0, text.getLength(), 0, layoutCache); + } + const SalLayoutGlyphs* GetLayoutGlyphs(VclPtr<const OutputDevice> outputDevice, + const OUString& text, sal_Int32 nIndex, sal_Int32 nLen, + tools::Long nLogicWidth = 0, + const vcl::text::TextLayoutCache* layoutCache = nullptr); + void clear(); + + static SalLayoutGlyphsCache* self(); + SalLayoutGlyphsCache(int size) // needs to be public for vcl::DeleteOnDeinit + : mCachedGlyphs(size) + { + } + +private: + struct CachedGlyphsKey + { + OUString text; + sal_Int32 index; + sal_Int32 len; + tools::Long logicWidth; + FontMetric fontMetric; + double fontScaleX; + double fontScaleY; + MapMode mapMode; + bool rtl; + bool artificialItalic; + bool artificialBold; + vcl::text::ComplexTextLayoutFlags layoutMode; + LanguageType digitLanguage; + size_t hashValue; + CachedGlyphsKey(const VclPtr<const OutputDevice>& dev, const OUString& t, sal_Int32 i, + sal_Int32 l, tools::Long w); + bool operator==(const CachedGlyphsKey& other) const; + }; + struct CachedGlyphsHash + { + size_t operator()(const CachedGlyphsKey& key) const { return key.hashValue; } + }; + struct GlyphsCost + { + size_t operator()(const SalLayoutGlyphs&) const; + }; + typedef o3tl::lru_map<CachedGlyphsKey, SalLayoutGlyphs, CachedGlyphsHash, + std::equal_to<CachedGlyphsKey>, GlyphsCost> + GlyphsCache; + GlyphsCache mCachedGlyphs; + // Last temporary glyphs returned (pointer is returned, so the object needs to be kept somewhere). + std::optional<CachedGlyphsKey> mLastTemporaryKey; + SalLayoutGlyphs mLastTemporaryGlyphs; + // If set, info about the last call which wanted a substring of the full text. + std::optional<CachedGlyphsKey> mLastSubstringKey; + + SalLayoutGlyphsCache(const SalLayoutGlyphsCache&) = delete; + SalLayoutGlyphsCache& operator=(const SalLayoutGlyphsCache&) = delete; +}; + +#endif // INCLUDED_VCL_GLYPHITEMCACHE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/gradient.hxx b/include/vcl/gradient.hxx new file mode 100644 index 000000000..f7c2bd2ec --- /dev/null +++ b/include/vcl/gradient.hxx @@ -0,0 +1,99 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_GRADIENT_HXX +#define INCLUDED_VCL_GRADIENT_HXX + +#include <sal/types.h> +#include <tools/color.hxx> +#include <tools/degree.hxx> +#include <tools/long.hxx> +#include <o3tl/cow_wrapper.hxx> + +#include <vcl/dllapi.h> +#include <vcl/vclenum.hxx> + +namespace tools { class Rectangle; } + +class Point; +class SvStream; +class GDIMetaFile; + +class VCL_DLLPUBLIC Gradient +{ +private: + class Impl; + ::o3tl::cow_wrapper<Impl> mpImplGradient; + +public: + Gradient(); + Gradient( const Gradient& rGradient ); + Gradient( Gradient&& rGradient ); + Gradient( GradientStyle eStyle, + const Color& rStartColor, + const Color& rEndColor ); + ~Gradient(); + + void SetStyle( GradientStyle eStyle ); + GradientStyle GetStyle() const; + + void SetStartColor( const Color& rColor ); + const Color& GetStartColor() const; + void SetEndColor( const Color& rColor ); + const Color& GetEndColor() const; + void MakeGrayscale(); + + void SetAngle( Degree10 nAngle ); + Degree10 GetAngle() const; + + void SetBorder( sal_uInt16 nBorder ); + sal_uInt16 GetBorder() const; + void SetOfsX( sal_uInt16 nOfsX ); + sal_uInt16 GetOfsX() const; + void SetOfsY( sal_uInt16 nOfsY ); + sal_uInt16 GetOfsY() const; + + void SetStartIntensity( sal_uInt16 nIntens ); + sal_uInt16 GetStartIntensity() const; + void SetEndIntensity( sal_uInt16 nIntens ); + sal_uInt16 GetEndIntensity() const; + + void SetSteps( sal_uInt16 nSteps ); + sal_uInt16 GetSteps() const; + + void GetBoundRect( const tools::Rectangle& rRect, tools::Rectangle &rBoundRect, Point& rCenter ) const; + + void AddGradientActions(tools::Rectangle const& rRect, GDIMetaFile& rMetaFile); + + Gradient& operator=( const Gradient& rGradient ); + Gradient& operator=( Gradient&& rGradient ); + bool operator==( const Gradient& rGradient ) const; + bool operator!=( const Gradient& rGradient ) const + { return !(Gradient::operator==( rGradient )); } + +private: + tools::Long GetMetafileSteps(tools::Rectangle const& rRect) const; + + void DrawComplexGradientToMetafile(tools::Rectangle const& rRect, GDIMetaFile& rMetaFile) const; + void DrawLinearGradientToMetafile(tools::Rectangle const& rRect, GDIMetaFile& rMetaFile) const; +}; + +#endif // INCLUDED_VCL_GRADIENT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/graph.hxx b/include/vcl/graph.hxx new file mode 100644 index 000000000..c97ee23d4 --- /dev/null +++ b/include/vcl/graph.hxx @@ -0,0 +1,208 @@ +/* -*- 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 . + */ + +#pragma once + +#include <memory> +#include <vcl/dllapi.h> +#include <tools/solar.h> +#include <rtl/ustring.hxx> +#include <vcl/bitmapex.hxx> +#include <vcl/animate/Animation.hxx> +#include <vcl/gfxlink.hxx> +#include <com/sun/star/uno/Reference.hxx> +#include <vcl/vectorgraphicdata.hxx> +#include <basegfx/vector/b2dsize.hxx> +#include <vcl/GraphicExternalLink.hxx> + +enum class GraphicType +{ + NONE, + Bitmap, + GdiMetafile, + Default +}; + +namespace com::sun::star::graphic { class XGraphic; } +namespace vcl { class Font; } + +class Bitmap; +class GDIMetaFile; +class SvStream; +class ImpGraphic; +class OutputDevice; +class GraphicReader; + +class SAL_WARN_UNUSED VCL_DLLPUBLIC GraphicConversionParameters +{ +private: + Size maSizePixel; // default is (0,0) + + bool mbUnlimitedSize : 1; // default is false + bool mbAntiAliase : 1; // default is false + bool mbSnapHorVerLines : 1; // default is false + +public: + GraphicConversionParameters( + const Size& rSizePixel = Size(), + bool bUnlimitedSize = false, + bool bAntiAliase = false, + bool bSnapHorVerLines = false) + : maSizePixel(rSizePixel), + mbUnlimitedSize(bUnlimitedSize), + mbAntiAliase(bAntiAliase), + mbSnapHorVerLines(bSnapHorVerLines) + { + } + + // data read access + const Size& getSizePixel() const { return maSizePixel; } + bool getUnlimitedSize() const { return mbUnlimitedSize; } + bool getAntiAliase() const { return mbAntiAliase; } + bool getSnapHorVerLines() const { return mbSnapHorVerLines; } +}; + +class Image; +class VCL_DLLPUBLIC Graphic +{ +private: + std::shared_ptr<ImpGraphic> mxImpGraphic; + SAL_DLLPRIVATE void ImplTestRefCount(); + +public: + SAL_DLLPRIVATE ImpGraphic* ImplGetImpGraphic() const { return mxImpGraphic.get(); } + + Graphic(); + Graphic(std::shared_ptr<GfxLink> const & rGfxLink, sal_Int32 nPageIndex = 0); + Graphic( const GraphicExternalLink& rGraphicLink ); + Graphic( const Graphic& rGraphic ); + Graphic( Graphic&& rGraphic ) noexcept; + Graphic( const Image& rImage ); + Graphic( const BitmapEx& rBmpEx ); + Graphic( const std::shared_ptr<VectorGraphicData>& rVectorGraphicDataPtr ); + Graphic( const Animation& rAnimation ); + Graphic( const GDIMetaFile& rMtf ); + Graphic( const css::uno::Reference< css::graphic::XGraphic >& rxGraphic ); + + Graphic& operator=( const Graphic& rGraphic ); + Graphic& operator=( Graphic&& rGraphic ) noexcept; + bool operator==( const Graphic& rGraphic ) const; + bool operator!=( const Graphic& rGraphic ) const; + + bool IsNone() const; + + void Clear(); + + GraphicType GetType() const; + void SetDefaultType(); + bool IsSupportedGraphic() const; + + bool IsTransparent() const; + bool IsAlpha() const; + bool IsAnimated() const; + bool IsEPS() const; + + bool isAvailable() const; + bool makeAvailable(); + + // #i102089# Access of Bitmap potentially will have to rasterconvert the Graphic + // if it is a MetaFile. To be able to control this conversion it is necessary to + // allow giving parameters which control AntiAliasing and LineSnapping of the + // MetaFile when played. Defaults will use a no-AAed, not snapped conversion as + // before. + BitmapEx GetBitmapEx(const GraphicConversionParameters& rParameters = GraphicConversionParameters()) const; + /// Gives direct access to the contained BitmapEx. + const BitmapEx& GetBitmapExRef() const; + + Animation GetAnimation() const; + const GDIMetaFile& GetGDIMetaFile() const; + + css::uno::Reference< css::graphic::XGraphic > GetXGraphic() const; + + Size GetPrefSize() const; + void SetPrefSize( const Size& rPrefSize ); + + MapMode GetPrefMapMode() const; + void SetPrefMapMode( const MapMode& rPrefMapMode ); + + basegfx::B2DSize GetPPI() const; + + Size GetSizePixel( const OutputDevice* pRefDevice = nullptr ) const; + + sal_uLong GetSizeBytes() const; + + void Draw(OutputDevice& rOutDev, const Point& rDestPt) const; + void Draw(OutputDevice& rOutDev, const Point& rDestPt, + const Size& rDestSize) const; + static void DrawEx(OutputDevice& rOutDev, const OUString& rText, + vcl::Font& rFont, const BitmapEx& rBitmap, + const Point& rDestPt, const Size& rDestSize); + + void StartAnimation(OutputDevice& rOutDev, + const Point& rDestPt, + const Size& rDestSize, + tools::Long nExtraData = 0, + OutputDevice* pFirstFrameOutDev = nullptr); + void StopAnimation( const OutputDevice* pOutputDevice, + tools::Long nExtraData ); + + void SetAnimationNotifyHdl( const Link<Animation*,void>& rLink ); + Link<Animation*,void> GetAnimationNotifyHdl() const; + + sal_uInt32 GetAnimationLoopCount() const; + + BitmapChecksum GetChecksum() const; + + OUString getOriginURL() const; + void setOriginURL(OUString const & rOriginURL); + + OString getUniqueID() const; + + std::shared_ptr<GraphicReader>& GetReaderContext(); + void SetReaderContext( const std::shared_ptr<GraphicReader> &pReader ); + void SetDummyContext(bool value); + bool IsDummyContext() const; + + void SetGfxLink(const std::shared_ptr<GfxLink>& rGfxLink); + const std::shared_ptr<GfxLink> & GetSharedGfxLink() const; + GfxLink GetGfxLink() const; + bool IsGfxLink() const; + + const std::shared_ptr<VectorGraphicData>& getVectorGraphicData() const; + + /// Get the page number of the multi-page source this Graphic is rendered from. + sal_Int32 getPageNumber() const; + + static const css::uno::Sequence<sal_Int8> & getUnoTunnelId(); +}; + +namespace std { + +template <> +struct hash<Graphic> +{ + std::size_t operator()(Graphic const & rGraphic) const + { + return static_cast<std::size_t>(rGraphic.GetChecksum()); + } +}; + +} // end namespace std + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/graphicfilter.hxx b/include/vcl/graphicfilter.hxx new file mode 100644 index 000000000..0e0351dc4 --- /dev/null +++ b/include/vcl/graphicfilter.hxx @@ -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 . + */ + +#ifndef INCLUDED_VCL_GRAPHICFILTER_HXX +#define INCLUDED_VCL_GRAPHICFILTER_HXX + +#include <tools/gen.hxx> +#include <vcl/dllapi.h> +#include <vcl/graph.hxx> +#include <vcl/errcode.hxx> +#include <o3tl/typed_flags_set.hxx> + +#include <memory> +#include <optional> + +namespace com::sun::star::beans { struct PropertyValue; } +namespace com::sun::star::uno { template <class E> class Sequence; } + +class INetURLObject; + +class FilterConfigCache; +class SvStream; +struct WmfExternal; +struct ConvertData; + +#define ERRCODE_GRFILTER_OPENERROR ErrCode(ErrCodeArea::Vcl, ErrCodeClass::General, 1) +#define ERRCODE_GRFILTER_IOERROR ErrCode(ErrCodeArea::Vcl, ErrCodeClass::General, 2) +#define ERRCODE_GRFILTER_FORMATERROR ErrCode(ErrCodeArea::Vcl, ErrCodeClass::General, 3) +#define ERRCODE_GRFILTER_VERSIONERROR ErrCode(ErrCodeArea::Vcl, ErrCodeClass::General, 4) +#define ERRCODE_GRFILTER_FILTERERROR ErrCode(ErrCodeArea::Vcl, ErrCodeClass::General, 5) +#define ERRCODE_GRFILTER_TOOBIG ErrCode(ErrCodeArea::Vcl, ErrCodeClass::General, 7) + +#define GRFILTER_OUTHINT_GREY 1 + +#define GRFILTER_FORMAT_NOTFOUND (sal_uInt16(0xFFFF)) +#define GRFILTER_FORMAT_DONTKNOW (sal_uInt16(0xFFFF)) + +enum class GraphicFilterImportFlags +{ + NONE = 0x000, + SetLogsizeForJpeg = 0x001, + DontSetLogsizeForJpeg = 0x002, + /// Only create a bitmap, do not read pixel data. + OnlyCreateBitmap = 0x020, + /// Read pixel data into an existing bitmap. + UseExistingBitmap = 0x040, +}; +namespace o3tl +{ + template<> struct typed_flags<GraphicFilterImportFlags> : is_typed_flags<GraphicFilterImportFlags, 0x0063> {}; +} + +#define IMP_BMP "SVBMP" +#define IMP_MOV "SVMOV" +#define IMP_SVMETAFILE "SVMETAFILE" +#define IMP_WMF "SVWMF" +#define IMP_EMF "SVEMF" +#define IMP_GIF "SVIGIF" +#define IMP_PNG "SVIPNG" +#define IMP_JPEG "SVIJPEG" +#define IMP_XBM "SVIXBM" +#define IMP_XPM "SVIXPM" +#define IMP_SVG "SVISVG" +#define IMP_PDF "SVIPDF" +#define IMP_TIFF "SVTIFF" +#define IMP_TGA "SVTGA" +#define IMP_PICT "SVPICT" +#define IMP_MET "SVMET" +#define IMP_RAS "SVRAS" +#define IMP_PCX "SVPCX" +#define IMP_EPS "SVIEPS" +#define IMP_PSD "SVPSD" +#define IMP_PCD "SVPCD" +#define IMP_PBM "SVPBM" +#define IMP_DXF "SVDXF" +#define IMP_WEBP "SVIWEBP" + +#define EXP_BMP "SVBMP" +#define EXP_SVMETAFILE "SVMETAFILE" +#define EXP_WMF "SVWMF" +#define EXP_EMF "SVEMF" +#define EXP_JPEG "SVEJPEG" +#define EXP_SVG "SVESVG" +#define EXP_PDF "SVEPDF" +#define EXP_PNG "SVEPNG" +#define EXP_TIFF "SVTIFF" +#define EXP_EPS "SVEEPS" +#define EXP_GIF "SVEGIF" +#define EXP_WEBP "SVEWEBP" + + +inline constexpr OUStringLiteral BMP_SHORTNAME = u"BMP"; +inline constexpr OUStringLiteral GIF_SHORTNAME = u"GIF"; +inline constexpr OUStringLiteral JPG_SHORTNAME = u"JPG"; +inline constexpr OUStringLiteral MET_SHORTNAME = u"MET"; +inline constexpr OUStringLiteral PCT_SHORTNAME = u"PCT"; +inline constexpr OUStringLiteral PNG_SHORTNAME = u"PNG"; +inline constexpr OUStringLiteral SVM_SHORTNAME = u"SVM"; +inline constexpr OUStringLiteral TIF_SHORTNAME = u"TIF"; +inline constexpr OUStringLiteral WMF_SHORTNAME = u"WMF"; +inline constexpr OUStringLiteral EMF_SHORTNAME = u"EMF"; +inline constexpr OUStringLiteral SVG_SHORTNAME = u"SVG"; +inline constexpr OUStringLiteral PDF_SHORTNAME = u"PDF"; +inline constexpr OUStringLiteral WEBP_SHORTNAME = u"WEBP"; + +// Info class for all supported file formats + +enum class GraphicFileFormat +{ + NOT = 0x0000, + BMP = 0x0001, + GIF = 0x0002, + JPG = 0x0003, + PCD = 0x0004, + PCX = 0x0005, + PNG = 0x0006, + TIF = 0x0007, + XBM = 0x0008, + XPM = 0x0009, + PBM = 0x000a, + PGM = 0x000b, + PPM = 0x000c, + RAS = 0x000d, + TGA = 0x000e, + PSD = 0x000f, + EPS = 0x0010, + WEBP = 0x0011, + DXF = 0x00f1, + MET = 0x00f2, + PCT = 0x00f3, + // retired SGF = 0x00f4, + SVM = 0x00f5, + WMF = 0x00f6, + // retired SGV = 0x00f7, + EMF = 0x00f8, + SVG = 0x00f9 +}; + + +class VCL_DLLPUBLIC GraphicDescriptor final +{ + SvStream* pFileStm; + + OUString aPathExt; + Size aPixSize; + Size aLogSize; + std::optional<Size> maPreferredLogSize; + std::optional<MapMode> maPreferredMapMode; + sal_uInt16 nBitsPerPixel; + sal_uInt16 nPlanes; + GraphicFileFormat nFormat; + bool bOwnStream; + sal_uInt8 mnNumberOfImageComponents; + bool bIsTransparent; + bool bIsAlpha; + + void ImpConstruct(); + + bool ImpDetectBMP( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectGIF( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectJPG( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectPCD( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectPCX( SvStream& rStm ); + bool ImpDetectPNG( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectTIF( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectXBM( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectXPM( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectPBM( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectPGM( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectPPM( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectRAS( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectTGA( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectPSD( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectEPS( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectWEBP( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectDXF( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectMET( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectPCT( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectSVM( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectWMF( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectEMF( SvStream& rStm, bool bExtendedInfo ); + bool ImpDetectSVG( SvStream& rStm, bool bExtendedInfo ); + GraphicDescriptor( const GraphicDescriptor& ) = delete; + GraphicDescriptor& operator=( const GraphicDescriptor& ) = delete; + +public: + + /** Ctor to set a filename + + Detect() must be called to identify the file + If the file has no unique header (Mtf's), the format + is determined from the extension */ + GraphicDescriptor( const INetURLObject& rPath ); + + /** Ctor using a stream + + Detect() must be called to identify the file + As some formats (Mtf's) do not have a unique header, it makes sense + to supply the file name (incl. ext.), so that the format can be + derived from the extension */ + GraphicDescriptor( SvStream& rInStream, const OUString* pPath ); + + ~GraphicDescriptor(); + + /** starts the detection + + if bExtendedInfo == true the file header is used to derive + as many properties as possible (size, color, etc.) */ + bool Detect( bool bExtendedInfo = false ); + + /** @return the file format, GraphicFileFormat::NOT if no format was recognized */ + GraphicFileFormat GetFileFormat() const { return nFormat; } + + /** @return graphic size in pixels or 0 size */ + const Size& GetSizePixel() const { return aPixSize; } + + /** @return the logical graphic size in 1/100mm or 0 size */ + const Size& GetSize_100TH_MM() const { return aLogSize; } + + /** + * Returns the logic size, according to the map mode available via GetPreferredMapMode(). Prefer + * this size over GetSize_100TH_MM(). + */ + const std::optional<Size>& GetPreferredLogSize() const { return maPreferredLogSize; } + + /** + * If available, this returns the map mode the graphic prefers, which may be other than pixel or + * 100th mm. Prefer this map mode over just assuming MapUnit::Map100thMM. + */ + const std::optional<MapMode>& GetPreferredMapMode() const { return maPreferredMapMode; } + + /** @return bits/pixel or 0 **/ + sal_uInt16 GetBitsPerPixel() const { return nBitsPerPixel; } + + /** @return number of color channels */ + sal_uInt8 GetNumberOfImageComponents() const { return mnNumberOfImageComponents; } + + /** @return whether image supports transparency */ + bool IsTransparent() const { return bIsTransparent; } + + /** @return whether image supports alpha values for translucent colours */ + bool IsAlpha() const { return bIsAlpha; } + + /** @return filter number that is needed by the GraphFilter to read this format */ + static OUString GetImportFormatShortName( GraphicFileFormat nFormat ); +}; + +/** Class to import and export graphic formats. */ +class VCL_DLLPUBLIC GraphicFilter +{ +public: + GraphicFilter( bool bUseConfig = true ); + ~GraphicFilter(); + + sal_uInt16 GetImportFormatCount() const; + sal_uInt16 GetImportFormatNumber( std::u16string_view rFormatName ); + sal_uInt16 GetImportFormatNumberForShortName( std::u16string_view rShortName ); + sal_uInt16 GetImportFormatNumberForTypeName( std::u16string_view rType ); + OUString GetImportFormatName( sal_uInt16 nFormat ); + OUString GetImportFormatTypeName( sal_uInt16 nFormat ); +#ifdef _WIN32 + OUString GetImportFormatMediaType( sal_uInt16 nFormat ); +#endif + OUString GetImportFormatShortName( sal_uInt16 nFormat ); + OUString GetImportWildcard( sal_uInt16 nFormat, sal_Int32 nEntry ); + + sal_uInt16 GetExportFormatCount() const; + sal_uInt16 GetExportFormatNumber( std::u16string_view rFormatName ); + sal_uInt16 GetExportFormatNumberForMediaType( std::u16string_view rShortName ); + sal_uInt16 GetExportFormatNumberForShortName( std::u16string_view rShortName ); + OUString GetExportInternalFilterName( sal_uInt16 nFormat ); + sal_uInt16 GetExportFormatNumberForTypeName( std::u16string_view rType ); + OUString GetExportFormatName( sal_uInt16 nFormat ); + OUString GetExportFormatMediaType( sal_uInt16 nFormat ); + OUString GetExportFormatShortName( sal_uInt16 nFormat ); + OUString GetExportWildcard( sal_uInt16 nFormat ); + bool IsExportPixelFormat( sal_uInt16 nFormat ); + + ErrCode ExportGraphic( const Graphic& rGraphic, const INetURLObject& rPath, + sal_uInt16 nFormat, + const css::uno::Sequence< css::beans::PropertyValue >* pFilterData = nullptr ); + ErrCode ExportGraphic( const Graphic& rGraphic, std::u16string_view rPath, + SvStream& rOStm, sal_uInt16 nFormat, + const css::uno::Sequence< css::beans::PropertyValue >* pFilterData = nullptr ); + + ErrCode CanImportGraphic( const INetURLObject& rPath, + sal_uInt16 nFormat, + sal_uInt16 * pDeterminedFormat); + + ErrCode ImportGraphic( Graphic& rGraphic, const INetURLObject& rPath, + sal_uInt16 nFormat = GRFILTER_FORMAT_DONTKNOW, + sal_uInt16 * pDeterminedFormat = nullptr, GraphicFilterImportFlags nImportFlags = GraphicFilterImportFlags::NONE ); + + ErrCode CanImportGraphic( std::u16string_view rPath, SvStream& rStream, + sal_uInt16 nFormat, + sal_uInt16 * pDeterminedFormat); + + ErrCode ImportGraphic( Graphic& rGraphic, std::u16string_view rPath, + SvStream& rStream, + sal_uInt16 nFormat = GRFILTER_FORMAT_DONTKNOW, + sal_uInt16 * pDeterminedFormat = nullptr, GraphicFilterImportFlags nImportFlags = GraphicFilterImportFlags::NONE ); + + /// Imports multiple graphics. + /// + /// The resulting graphic is added to rGraphics on success, nullptr is added on failure. + void ImportGraphics(std::vector< std::shared_ptr<Graphic> >& rGraphics, std::vector< std::unique_ptr<SvStream> > vStreams); + + /** + Tries to ensure all Graphic objects are available (Graphic::isAvailable()). Only an optimization, may + not process all items. + */ + void MakeGraphicsAvailableThreaded(std::vector< Graphic* >& rGraphics); + + // Setting sizeLimit limits how much will be read from the stream. + Graphic ImportUnloadedGraphic(SvStream& rIStream, sal_uInt64 sizeLimit = 0, const Size* pSizeHint = nullptr); + + const ErrCode& GetLastError() const { return *mxErrorEx;} + void ResetLastError(); + + Link<ConvertData&,bool> GetFilterCallback() const; + static GraphicFilter& GetGraphicFilter(); + static ErrCode LoadGraphic( const OUString& rPath, const OUString& rFilter, + Graphic& rGraphic, + GraphicFilter* pFilter = nullptr, + sal_uInt16* pDeterminedFormat = nullptr ); + + ErrCode compressAsPNG(const Graphic& rGraphic, SvStream& rOutputStream); + + static ErrCode readGIF(SvStream& rStream, Graphic& rGraphic, GfxLinkType& rLinkType); + static ErrCode readPNG(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType, + std::unique_ptr<sal_uInt8[]> & rpGraphicContent, sal_Int32& rGraphicContentSize); + static ErrCode readJPEG(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType, + GraphicFilterImportFlags nImportFlags); + static ErrCode readSVG(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType, + std::unique_ptr<sal_uInt8[]> & rpGraphicContent, sal_Int32& rGraphicContentSize); + static ErrCode readXBM(SvStream & rStream, Graphic & rGraphic); + static ErrCode readXPM(SvStream & rStream, Graphic & rGraphic); + + static ErrCode readWMF_EMF(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType, VectorGraphicDataType eType); + static ErrCode readWMF(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType); + static ErrCode readEMF(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType); + + static ErrCode readPDF(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType); + static ErrCode readTIFF(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType); + static ErrCode readWithTypeSerializer(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType, std::u16string_view aFilterName); + static ErrCode readBMP(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType); + static ErrCode readTGA(SvStream & rStream, Graphic & rGraphic); + static ErrCode readPICT(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType); + static ErrCode readMET(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType); + static ErrCode readRAS(SvStream & rStream, Graphic & rGraphic); + static ErrCode readPCX(SvStream & rStream, Graphic & rGraphic); + static ErrCode readEPS(SvStream & rStream, Graphic & rGraphic); + static ErrCode readPSD(SvStream & rStream, Graphic & rGraphic); + static ErrCode readPCD(SvStream & rStream, Graphic & rGraphic); + static ErrCode readPBM(SvStream & rStream, Graphic & rGraphic); + static ErrCode readDXF(SvStream & rStream, Graphic & rGraphic); + static ErrCode readWEBP(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType); + +private: + OUString aFilterPath; + FilterConfigCache* pConfig; + + void ImplInit(); + ErrCode ImplSetError( ErrCode nError, const SvStream* pStm = nullptr ); + ErrCode ImpTestOrFindFormat( std::u16string_view rPath, SvStream& rStream, sal_uInt16& rFormat ); + + DECL_DLLPRIVATE_LINK( FilterCallback, ConvertData&, bool ); + + /** Information about errors during the GraphicFilter operation. */ + std::optional<ErrCode> mxErrorEx; + bool bUseConfig; +}; + +#endif // INCLUDED_VCL_GRAPHICFILTER_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/graphictools.hxx b/include/vcl/graphictools.hxx new file mode 100644 index 000000000..932df413c --- /dev/null +++ b/include/vcl/graphictools.hxx @@ -0,0 +1,369 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_GRAPHICTOOLS_HXX +#define INCLUDED_VCL_GRAPHICTOOLS_HXX + +#include <vcl/dllapi.h> +#include <sal/types.h> +#include <tools/color.hxx> +#include <tools/poly.hxx> +#include <vcl/graph.hxx> + +#include <vector> + +class SvStream; + +/** Encapsulates geometry and associated attributes of a graphical 'pen stroke' + + @attention Widespread use is deprecated. See declarations above + for the way to go. Especially the copied enums from svx/xenum.hxx + are troublesome. + + Use this class to store geometry and attributes of a graphical + 'pen stroke', such as pen width, dashing etc. The geometry is the + so-called 'path' along which the stroke is traced, with the given + pen width. The cap type determines how the open ends of the path + should be drawn. If the geometry consists of more than one + segment, the join type determines in which way the segments are + joined. + */ +class VCL_DLLPUBLIC SvtGraphicStroke +{ +public: + /// Style for open stroke ends + enum CapType + { + /// No additional cap + capButt=0, + /// Half-round cap at the line end, the center lying at the end point + capRound, + /// Half-square cap at the line end, the center lying at the end point + capSquare + }; + /// Style for joins of individual stroke segments + enum JoinType + { + /// Extend segment edges, until they cross + joinMiter=0, + /// Connect segments by a filled round arc + joinRound, + /// Connect segments by a direct straight line + joinBevel, + /// Perform no join, leads to visible gaps between thick line segments + joinNone + }; + typedef ::std::vector< double > DashArray; + + SvtGraphicStroke(); + /** All in one constructor + + See accessor method descriptions for argument description + */ + SvtGraphicStroke( const tools::Polygon& rPath, + const tools::PolyPolygon& rStartArrow, + const tools::PolyPolygon& rEndArrow, + double fTransparency, + double fStrokeWidth, + CapType aCap, + JoinType aJoin, + double fMiterLimit, + DashArray&& rDashArray ); // TODO: Dash array offset (position where to start, see PS) + + // accessors + /// Query path to stroke + void getPath ( tools::Polygon& ) const; + /** Get the polygon that is put at the start of the line + + The polygon is in a special normalized position: the center of + the stroked path will meet the given polygon at (0,0) from + negative y values. Thus, an arrow would have its baseline on + the x axis, going upwards to positive y values. Furthermore, + the polygon is also scaled in a special way: the width of the + joining stroke is defined to be + SvtGraphicStroke::normalizedArrowWidth (0x10000), i.e. ranging + from x=-0x8000 to x=0x8000. So, if the arrow does have this + width, it has to fit every stroke with every stroke width + exactly. + */ + void getStartArrow ( tools::PolyPolygon& ) const; + /** Get the polygon that is put at the end of the line + + The polygon is in a special normalized position, and already + scaled to the desired size: the center of the stroked path + will meet the given polygon at (0,0) from negative y + values. Thus, an arrow would have its baseline on the x axis, + going upwards to positive y values. Furthermore, the polygon + is also scaled in a special way: the width of the joining + stroke is defined to be SvtGraphicStroke::normalizedArrowWidth + (0x10000), i.e. ranging from x=-0x8000 to x=0x8000. So, if the + arrow does have this width, it has to fit every stroke with + every stroke width exactly. + */ + void getEndArrow ( tools::PolyPolygon& ) const; + /** Get stroke transparency + + @return the transparency, ranging from 0.0 (opaque) to 1.0 (fully translucent) + */ + double getTransparency () const { return mfTransparency;} + /// Get width of the stroke + double getStrokeWidth () const { return mfStrokeWidth;} + /// Get the style in which open stroke ends are drawn + CapType getCapType () const { return maCapType;} + /// Get the style in which the stroke segments are joined + JoinType getJoinType () const { return maJoinType;} + /// Get the maximum length of mitered joins + double getMiterLimit () const { return mfMiterLimit;} + /// Get an array of "on" and "off" lengths for stroke dashing + void getDashArray ( DashArray& ) const; + + // mutators + /// Set path to stroke + void setPath ( const tools::Polygon& ); + /** Set the polygon that is put at the start of the line + + The polygon has to be in a special normalized position, and + already scaled to the desired size: the center of the stroked + path will meet the given polygon at (0,0) from negative y + values. Thus, an arrow would have its baseline on the x axis, + going upwards to positive y values. Furthermore, the polygon + also has to be scaled appropriately: the width of the joining + stroke is defined to be SvtGraphicStroke::normalizedArrowWidth + (0x10000), i.e. ranging from x=-0x8000 to x=0x8000. If your + arrow does have this width, it will fit every stroke with + every stroke width exactly. + */ + void setStartArrow ( const tools::PolyPolygon& ); + /** Set the polygon that is put at the end of the line + + The polygon has to be in a special normalized position, and + already scaled to the desired size: the center of the stroked + path will meet the given polygon at (0,0) from negative y + values. Thus, an arrow would have its baseline on the x axis, + going upwards to positive y values. Furthermore, the polygon + also has to be scaled appropriately: the width of the joining + stroke is defined to be SvtGraphicStroke::normalizedArrowWidth + (0x10000), i.e. ranging from x=-0x8000 to x=0x8000. If your + arrow does have this width, it will fit every stroke with + every stroke width exactly. + */ + void setEndArrow ( const tools::PolyPolygon& ); + /// Affine scaling in both X and Y dimensions + void scale ( double fScaleX, double fScaleY ); + +private: + // friends + VCL_DLLPUBLIC friend SvStream& WriteSvtGraphicStroke( SvStream& rOStm, const SvtGraphicStroke& rClass ); + VCL_DLLPUBLIC friend SvStream& ReadSvtGraphicStroke( SvStream& rIStm, SvtGraphicStroke& rClass ); + + tools::Polygon maPath; + tools::PolyPolygon maStartArrow; + tools::PolyPolygon maEndArrow; + double mfTransparency; + double mfStrokeWidth; + CapType maCapType; + JoinType maJoinType; + double mfMiterLimit; + DashArray maDashArray; +}; + +/** Encapsulates geometry and associated attributes of a filled area + + @attention Widespread use is deprecated. See declarations above + for the way to go. Especially the copied enums from svx/xenum.hxx + is troublesome. + + Use this class to store geometry and attributes of a filled area, + such as fill color, transparency, texture or hatch. The geometry + is the so-called 'path', whose inner area will get filled + according to the attributes set. If the path is intersecting, or + one part of the path is lying fully within another part, then the + fill rule determines which parts are filled and which are not. + */ +class VCL_DLLPUBLIC SvtGraphicFill +{ +public: + /// Type of fill algorithm used + enum FillRule + { + /** Non-zero winding rule + + Fill shape scanline-wise. Starting at the left, determine + the winding number as follows: every segment crossed that + runs counter-clockwise adds one to the winding number, + every segment crossed that runs clockwise subtracts + one. The part of the scanline where the winding number is + non-zero gets filled. + */ + fillNonZero=0, + /** Even-odd fill rule + + Fill shape scanline-wise. Starting at the left, count the + number of segments crossed. If this number is odd, the + part of the scanline is filled, otherwise not. + */ + fillEvenOdd + }; + /// Type of filling used + enum FillType + { + /// Fill with a specified solid color + fillSolid=0, + /// Fill with the specified gradient + fillGradient, + /// Fill with the specified hatch + fillHatch, + /// Fill with the specified texture (a Graphic object) + fillTexture + }; + /// Type of hatching used + enum HatchType + { + /// horizontal parallel lines, one unit apart + hatchSingle=0, + /// horizontal and vertical orthogonally crossing lines, one unit apart + hatchDouble, + /// three crossing lines, like HatchType::hatchDouble, but + /// with an additional diagonal line, rising to the upper + /// right corner. The first diagonal line goes through the + /// upper left corner, the other are each spaced a unit apart. + hatchTriple + }; + /// Type of gradient used + enum class GradientType {Linear, Radial, Rectangular}; + /// Special values for gradient step count + enum { gradientStepsInfinite=0 }; + /** Homogeneous 2D transformation matrix + + This is a 2x3 matrix representing an affine transformation on + the R^2, in the usual C/C++ row major form. It is structured as follows: + <pre> + a b t_x + c d t_y + 0 0 1 + </pre> + where the lowest line is not stored in the matrix, since it is + constant. Variables t_x and t_y contain translational + components, a to d rotation, scale and shear (for details, + look up your favorite linear algebra/computer graphics book). + */ + struct VCL_DLLPUBLIC Transform + { + enum { MatrixSize=6 }; + Transform(); + double matrix[MatrixSize]; + }; + + SvtGraphicFill(); + /** All in one constructor + + See accessor method descriptions for argument description + */ + SvtGraphicFill( const tools::PolyPolygon& rPath, + Color aFillColor, + double fTransparency, + FillRule aFillRule, + FillType aFillType, // TODO: Multitexturing + const Transform& aFillTransform, + bool bTiling, + HatchType aHatchType, // TODO: vector of directions and start points + Color aHatchColor, + GradientType aGradientType, // TODO: Transparent gradients (orthogonal to normal ones) + Color aGradient1stColor, // TODO: vector of colors and offsets + Color aGradient2ndColor, + sal_Int32 aGradientStepCount, // numbers of steps to render the gradient. gradientStepsInfinite means infinitely many. + const Graphic& aFillGraphic ); + + // accessors + /// Query path to fill + void getPath ( tools::PolyPolygon& ) const; + /// Get color used for solid fills + const Color& getFillColor () const { return maFillColor;} + /** Get stroke transparency + + @return the transparency, ranging from 0.0 (opaque) to 1.0 (fully translucent) + */ + double getTransparency () const { return mfTransparency;} + /// Get fill rule used + FillRule getFillRule () const { return maFillRule;} + /** Get fill type used + + Currently, only one of the fill types can be used + simultaneously. If you specify e.g. FillRule::fillGradient, + hatching, texture and solid fill color are ignored. + */ + FillType getFillType () const { return maFillType;} + /** Get transformation applied to hatch, gradient or texture during fill + + A fill operation generally starts at the top left position of + the object's bounding box. At that position (if tiling is on, + also all successive positions), the specified fill graphic is + rendered, after applying the fill transformation to it. For + example, if the fill transformation contains a translation, + the fill graphic is rendered at the object's bounding box's + top left corner plus the translation components. + + */ + void getTransform ( Transform& ) const; + + /** Query state of texture tiling + + @return true, if texture is tiled, false, if output only once. + */ + bool isTiling () const { return mbTiling;} + /// Get type of gradient used + GradientType getGradientType () const { return maGradientType;} + + /** Get the texture graphic used + + The Graphic object returned is used to fill the geometry, if + the FillType is fillTexture. The Graphic object is always + assumed to be of size 1x1, the transformation is used to scale + it to the appropriate size. + */ + void getGraphic ( Graphic& ) const; + + // mutators + /// Set path to fill + void setPath ( const tools::PolyPolygon& rPath ); + +private: + // friends + VCL_DLLPUBLIC friend SvStream& WriteSvtGraphicFill( SvStream& rOStm, const SvtGraphicFill& rClass ); + VCL_DLLPUBLIC friend SvStream& ReadSvtGraphicFill( SvStream& rIStm, SvtGraphicFill& rClass ); + + tools::PolyPolygon maPath; + Color maFillColor; + double mfTransparency; + FillRule maFillRule; + FillType maFillType; + Transform maFillTransform; + bool mbTiling; + HatchType maHatchType; + Color maHatchColor; + GradientType maGradientType; + Color maGradient1stColor; + Color maGradient2ndColor; + sal_Int32 maGradientStepCount; + Graphic maFillGraphic; +}; + +#endif // INCLUDED_VCL_GRAPHICTOOLS_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/hatch.hxx b/include/vcl/hatch.hxx new file mode 100644 index 000000000..713f22b95 --- /dev/null +++ b/include/vcl/hatch.hxx @@ -0,0 +1,79 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_HATCH_HXX +#define INCLUDED_VCL_HATCH_HXX + +#include <tools/color.hxx> +#include <tools/long.hxx> +#include <tools/degree.hxx> +#include <vcl/dllapi.h> + +#include <vcl/vclenum.hxx> +#include <o3tl/cow_wrapper.hxx> + + +class SvStream; + +struct ImplHatch +{ + Color maColor; + HatchStyle meStyle; + tools::Long mnDistance; + Degree10 mnAngle; + + ImplHatch(); + + bool operator==( const ImplHatch& rImplHatch ) const; +}; + +class VCL_DLLPUBLIC Hatch +{ +public: + + Hatch(); + Hatch( const Hatch& rHatch ); + Hatch( HatchStyle eStyle, const Color& rHatchColor, tools::Long nDistance, Degree10 nAngle10 ); + ~Hatch(); + + Hatch& operator=( const Hatch& rHatch ); + bool operator==( const Hatch& rHatch ) const; + bool operator!=( const Hatch& rHatch ) const { return !(Hatch::operator==( rHatch ) ); } + + HatchStyle GetStyle() const { return mpImplHatch->meStyle; } + + void SetColor( const Color& rColor ); + const Color& GetColor() const { return mpImplHatch->maColor; } + + void SetDistance( tools::Long nDistance ); + tools::Long GetDistance() const { return mpImplHatch->mnDistance; } + + void SetAngle( Degree10 nAngle10 ); + Degree10 GetAngle() const { return mpImplHatch->mnAngle; } + + friend SvStream& ReadHatch( SvStream& rIStm, Hatch& rHatch ); + friend SvStream& WriteHatch( SvStream& rOStm, const Hatch& rHatch ); + +private: + o3tl::cow_wrapper< ImplHatch > mpImplHatch; +}; + +#endif // INCLUDED_VCL_HATCH_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/headbar.hxx b/include/vcl/headbar.hxx new file mode 100644 index 000000000..1f9fc429a --- /dev/null +++ b/include/vcl/headbar.hxx @@ -0,0 +1,319 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_HEADBAR_HXX +#define INCLUDED_VCL_HEADBAR_HXX + +#include <vcl/dllapi.h> +#include <tools/link.hxx> +#include <vcl/window.hxx> +#include <o3tl/typed_flags_set.hxx> +#include <memory> + +/************************************************************************* + +Description +============ + +class HeaderBar + +This class serves for displaying a header bar. A header bar can display +texts, images or both of them. The items can be changed in size, dragged or +clicked at. In many cases, it makes, for example, sense to use this control +in combination with a SvTabListBox. + +-------------------------------------------------------------------------- + +WinBits + +WB_BORDER a border is drawn in the top and in the bottom +WB_BOTTOMBORDER a border is drawn in the bottom +WB_BUTTONSTYLE The items look like buttons, otherwise they are flat. +WB_3DLOOK 3D look +WB_DRAG items can be dragged +WB_STDHEADERBAR WB_BUTTONSTYLE | WB_BOTTOMBORDER + +-------------------------------------------------------------------------- + +ItemBits + +HeaderBarItemBits::LEFT content is displayed in the item left-justified +HeaderBarItemBits::CENTER content is displayed in the item centred +HeaderBarItemBits::RIGHT content is displayed in the item right-justified +HeaderBarItemBits::TOP content is displayed in the item at the upper border +HeaderBarItemBits::VCENTER content is displayed in the item vertically centred +HeaderBarItemBits::BOTTOM content is displayed in the item at the bottom border +HeaderBarItemBits::LEFTIMAGE in case of text and image, the image is displayed left of the text +HeaderBarItemBits::RIGHTIMAGE in case of text and image, the image is displayed right of the text +HeaderBarItemBits::FIXED item cannot be changed in size +HeaderBarItemBits::FIXEDPOS item cannot be moved +HeaderBarItemBits::CLICKABLE item is clickable + (select handler is only called on MouseButtonUp) +HeaderBarItemBits::FLAT item is displayed in a flat way, even if WB_BUTTONSTYLE is set +HeaderBarItemBits::DOWNARROW An arrow pointing downwards is displayed behind the text, + which should, for example, be shown, when after this item, + a corresponding list is sorted in descending order. + The status of the arrow can be set/reset with SetItemBits(). +HeaderBarItemBits::UPARROW An arrow pointing upwards is displayed behind the text, + which should, for example, be shown, when after this item, + a corresponding list is sorted in ascending order. + The status of the arrow can be set/reset with SetItemBits(). +HeaderBarItemBits::USERDRAW For this item, the UserDraw handler is called as well. +HeaderBarItemBits::STDSTYLE (HeaderBarItemBits::LEFT | HeaderBarItemBits::LEFTIMAGE | HeaderBarItemBits::CLICKABLE) + +-------------------------------------------------------------------------- + +Handler + +Select() Is called, when the item is clicked. If HeaderBarItemBits::CLICKABLE + is set in the item and not HeaderBarItemBits::FLAT, the handler is only + called in the MouseButtonUp handler, when the mouse has been + released over the item. In this case, the Select handler + behaves like it does with a ToolBox button. +DoubleClick() This handler is called, when an item is double-clicked. + Whether the item or the separator has been clicked, can + be determined by IsItemMode(). Normally, when a separator + is double-clicked, the optimal column width should be + calculated and should be set. +StartDrag() This handler is called, when dragging is started resp. + an item has been clicked. At the latest in this handler, + the size of the size-line should be set with + SetDragSize(), if IsItemMode() returns false. +Drag() This handler is called, when dragging is taking place. + If no size is set with SetDragSize(), this handler can + be used to draw the line in the neighbouring window by + oneself. The current dragging position can be requested + with GetDragPos(). In every case, IsItemMode() + should be checked to find out whether a separator is + dragged as well. +EndDrag() This handler is called, when a dragging process has been + stopped. If GetCurItemId() returns 0 in the EndDrag handler, + the drag process was aborted. If this is not the case and + IsItemMode() returns false, the new size of the dragged + item should be requested using GetItemSize() and it + should be taken over in the corresponding control. + If IsItemMode() returns true, GetCurItemId() + returns an Id and IsItemDrag() returns true, this + item has been dragged. In this case, the new position + should be requested using GetItemPos() and the data + in the corresponding control should be adapted. + Otherwise, the position to which the item has been dragged + could also be requested with GetItemDragPos(). + +Further methods that are important for the handler. + +GetCurItemId() Returns the id of the item, for which the handler has + currently been called. Only returns a valid id in the + handlers Select(), DoubleClick(), StartDrag(), + Drag() and EndDrag(). In the EndDrag handler, + this method returns the id of the dragged item or 0, + if the drag process has been aborted. +GetItemDragPos() Returns the position, at which an item has been moved. + HEADERBAR_ITEM_NOTFOUND is returned, if the process + has been aborted or no ItemDrag is active. +IsItemMode() This method can be used to determine whether the + handler has been called for an item or a separator. + true - handler was called for the item + false - handler was called for the separator +IsItemDrag() This method can be used to determine whether an item + has been dragged or selected. + true - item is dragged + false - item is selected +SetDragSize() This method is used to set the size of the separating + line that is drawn by the control. It should be + equivalent to the height of the neighbouring window. + The height of the HeaderBar is added automatically. + +-------------------------------------------------------------------------- + +Further methods + +SetOffset() This method sets the offset, from which on the + items are shown. This is needed when the + corresponding window is scrolled. +CalcWindowSizePixel() This method can be used to calculate the height + of the window, so that the content of the item + can be displayed. + +-------------------------------------------------------------------------- + +Tips and tricks: + +1) ContextMenu +If a context sensitive PopupMenu should be shown, the command +handler must be overlaid. Using GetItemId() and when passing the +mouse position, it can be determined whether the mouse click has been +carried out over an item resp. over which item the mouse click has been +carried out. + +2) last item +If ButtonStyle has been set, it looks better, if an empty item is +set at the end which takes up the remaining space. +In order to do that, you can insert an item with an empty string and +pass HEADERBAR_FULLSIZE as size. For such an item, you should not set +HeaderBarItemBits::CLICKABLE, but HeaderBarItemBits::FIXEDPOS. + +*************************************************************************/ + +class ImplHeadItem; + +#define WB_BOTTOMBORDER (WinBits(0x0400)) +#define WB_BUTTONSTYLE (WinBits(0x0800)) +#define WB_STDHEADERBAR (WB_BUTTONSTYLE | WB_BOTTOMBORDER) + +enum class HeaderBarItemBits +{ + NONE = 0x0000, + LEFT = 0x0001, + CENTER = 0x0002, + RIGHT = 0x0004, + LEFTIMAGE = 0x0010, + RIGHTIMAGE = 0x0020, + CLICKABLE = 0x0400, + FLAT = 0x0800, + DOWNARROW = 0x1000, + UPARROW = 0x2000, + STDSTYLE = LEFT | LEFTIMAGE | CLICKABLE, +}; + +namespace o3tl +{ + template<> struct typed_flags<HeaderBarItemBits> : is_typed_flags<HeaderBarItemBits, 0x3c37> {}; +} + +#define HEADERBAR_APPEND (sal_uInt16(0xFFFF)) +#define HEADERBAR_ITEM_NOTFOUND (sal_uInt16(0xFFFF)) +#define HEADERBAR_FULLSIZE (tools::Long(1000000000)) + +class VCL_DLLPUBLIC HeaderBar : public vcl::Window +{ +private: + std::vector<std::unique_ptr<ImplHeadItem>> mvItemList; + tools::Long mnBorderOff1; + tools::Long mnBorderOff2; + tools::Long mnOffset; + tools::Long mnDX; + tools::Long mnDY; + tools::Long mnDragSize; + tools::Long mnStartPos; + tools::Long mnDragPos; + tools::Long mnMouseOff; + sal_uInt16 mnCurItemId; + sal_uInt16 mnItemDragPos; + bool mbDragable; + bool mbDrag; + bool mbItemDrag; + bool mbOutDrag; + bool mbButtonStyle; + bool mbItemMode; + Link<HeaderBar*,void> maStartDragHdl; + Link<HeaderBar*,void> maEndDragHdl; + Link<HeaderBar*,void> maSelectHdl; + Link<HeaderBar*,void> maCreateAccessibleHdl; + + css::uno::Reference< css::accessibility::XAccessible > + mxAccessible; + + using Window::ImplInit; + VCL_DLLPRIVATE void ImplInit( WinBits nWinStyle ); + VCL_DLLPRIVATE void ImplInitSettings( bool bFont, bool bForeground, bool bBackground ); + VCL_DLLPRIVATE tools::Long ImplGetItemPos( sal_uInt16 nPos ) const; + VCL_DLLPRIVATE tools::Rectangle ImplGetItemRect( sal_uInt16 nPos ) const; + VCL_DLLPRIVATE sal_uInt16 ImplDoHitTest( const Point& rPos, tools::Long& nMouseOff, sal_uInt16& nPos ) const; + VCL_DLLPRIVATE void ImplInvertDrag( sal_uInt16 nStartPos, sal_uInt16 nEndPos ); + VCL_DLLPRIVATE void ImplDrawItem(vcl::RenderContext& rRenderContext, sal_uInt16 nPos, bool bHigh, + const tools::Rectangle& rItemRect, const tools::Rectangle* pRect); + VCL_DLLPRIVATE void ImplDrawItem(vcl::RenderContext& rRenderContext, sal_uInt16 nPos, bool bHigh, + const tools::Rectangle* pRect); + VCL_DLLPRIVATE void ImplUpdate( sal_uInt16 nPos, + bool bEnd = false ); + VCL_DLLPRIVATE void ImplStartDrag( const Point& rPos, bool bCommand ); + VCL_DLLPRIVATE void ImplDrag( const Point& rPos ); + VCL_DLLPRIVATE void ImplEndDrag( bool bCancel ); + + virtual void ApplySettings(vcl::RenderContext& rRenderContext) override; + +public: + HeaderBar( vcl::Window* pParent, WinBits nWinBits ); + virtual ~HeaderBar() override; + + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void MouseMove( const MouseEvent& rMEvt ) override; + virtual void Tracking( const TrackingEvent& rTEvt ) override; + virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override; + virtual void Draw( OutputDevice* pDev, const Point& rPos,SystemTextColorFlags nFlags ) override; + virtual void Resize() override; + virtual void Command( const CommandEvent& rCEvt ) override; + virtual void RequestHelp( const HelpEvent& rHEvt ) override; + virtual void StateChanged( StateChangedType nStateChange ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + virtual Size GetOptimalSize() const override; + + virtual void EndDrag(); + virtual void Select(); + virtual void DoubleClick(); + + void InsertItem( sal_uInt16 nItemId, const OUString& rText, + tools::Long nSize, HeaderBarItemBits nBits = HeaderBarItemBits::STDSTYLE, + sal_uInt16 nPos = HEADERBAR_APPEND ); + void RemoveItem( sal_uInt16 nItemId ); + void MoveItem( sal_uInt16 nItemId, sal_uInt16 nNewPos ); + void Clear(); + + void SetOffset( tools::Long nNewOffset ); + void SetDragSize( tools::Long nNewSize ) { mnDragSize = nNewSize; } + + sal_uInt16 GetItemCount() const; + sal_uInt16 GetItemPos( sal_uInt16 nItemId ) const; + sal_uInt16 GetItemId( sal_uInt16 nPos ) const; + sal_uInt16 GetItemId( const Point& rPos ) const; + tools::Rectangle GetItemRect( sal_uInt16 nItemId ) const; + sal_uInt16 GetCurItemId() const { return mnCurItemId; } + bool IsItemMode() const { return mbItemMode; } + + void SetItemSize( sal_uInt16 nItemId, tools::Long nNewSize ); + tools::Long GetItemSize( sal_uInt16 nItemId ) const; + void SetItemBits( sal_uInt16 nItemId, HeaderBarItemBits nNewBits ); + HeaderBarItemBits GetItemBits( sal_uInt16 nItemId ) const; + + void SetItemText( sal_uInt16 nItemId, const OUString& rText ); + OUString GetItemText( sal_uInt16 nItemId ) const; + + OUString GetHelpText( sal_uInt16 nItemId ) const; + + Size CalcWindowSizePixel() const; + + using Window::SetHelpId; + + void SetStartDragHdl( const Link<HeaderBar*,void>& rLink ) { maStartDragHdl = rLink; } + void SetEndDragHdl( const Link<HeaderBar*,void>& rLink ) { maEndDragHdl = rLink; } + void SetSelectHdl( const Link<HeaderBar*,void>& rLink ) { maSelectHdl = rLink; } + void SetCreateAccessibleHdl( const Link<HeaderBar*,void>& rLink ) { maCreateAccessibleHdl = rLink; } + + bool IsDragable() const { return mbDragable; } + + /** Creates and returns the accessible object of the header bar. */ + virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessible() override; + void SetAccessible( const css::uno::Reference< css::accessibility::XAccessible >& ); +}; + +#endif // INCLUDED_VCL_HEADBAR_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/help.hxx b/include/vcl/help.hxx new file mode 100644 index 000000000..7dc848a42 --- /dev/null +++ b/include/vcl/help.hxx @@ -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 . + */ + +#ifndef INCLUDED_VCL_HELP_HXX +#define INCLUDED_VCL_HELP_HXX + +#include <rtl/ustring.hxx> +#include <vcl/dllapi.h> +#include <o3tl/typed_flags_set.hxx> + +class Point; +namespace tools { class Rectangle; } +namespace vcl { class Window; } + + +enum class QuickHelpFlags +{ + NONE = 0x0000, + Left = 0x0001, + Center = 0x0002, + Right = 0x0004, + Top = 0x0008, + VCenter = 0x0010, + Bottom = 0x0020, + NoAutoPos = Left | Center | Right | Top | VCenter | Bottom, + CtrlText = 0x0040, +/// force balloon-style in ShowPopover and ShowQuickHelp + TipStyleBalloon = 0x0100, + NoEvadePointer = 0x0200, + BiDiRtl = 0x0400, +}; +namespace o3tl +{ + template<> struct typed_flags<QuickHelpFlags> : is_typed_flags<QuickHelpFlags, 0x77f> {}; +} + +#define OOO_HELP_INDEX ".help:index" + +namespace weld +{ + class Widget; +} + +class VCL_DLLPUBLIC Help +{ +public: + Help(); + virtual ~Help(); + + virtual bool Start(const OUString& rHelpId, weld::Widget* pWidget = nullptr); + virtual void SearchKeyword( const OUString& rKeyWord ); + virtual OUString GetHelpText(const OUString& aHelpURL, const weld::Widget* pWidget); + + virtual bool Start(const OUString& rHelpId, const vcl::Window* pWindow); + virtual OUString GetHelpText(const OUString& aHelpURL, const vcl::Window* pWindow); + + static void EnableContextHelp(); + static void DisableContextHelp(); + static bool IsContextHelpEnabled(); + + static void EnableExtHelp(); + static void DisableExtHelp(); + static bool IsExtHelpEnabled(); + static bool StartExtHelp(); + static bool EndExtHelp(); + + static void EnableBalloonHelp(); + static void DisableBalloonHelp(); + static bool IsBalloonHelpEnabled(); + static void ShowBalloon( vcl::Window* pParent, + const Point& rScreenPos, + const tools::Rectangle&, + const OUString& rHelpText ); + + static void EnableQuickHelp(); + static void DisableQuickHelp(); + static bool IsQuickHelpEnabled(); + static void ShowQuickHelp( vcl::Window* pParent, + const tools::Rectangle& rScreenRect, + const OUString& rHelpText, + QuickHelpFlags nStyle = QuickHelpFlags::NONE ); + + static void HideBalloonAndQuickHelp(); + + static void* ShowPopover(vcl::Window* pParent, + const tools::Rectangle& rScreenRect, + const OUString& rText, + QuickHelpFlags nStyle); + static void UpdatePopover(void* nId, + vcl::Window* pParent, + const tools::Rectangle& rScreenRect, + const OUString& rText); + static void HidePopover(vcl::Window const * pParent, void* nId); +}; + +#endif // INCLUDED_VCL_HELP_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/i18nhelp.hxx b/include/vcl/i18nhelp.hxx new file mode 100644 index 000000000..e5368da08 --- /dev/null +++ b/include/vcl/i18nhelp.hxx @@ -0,0 +1,77 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_I18NHELP_HXX +#define INCLUDED_VCL_I18NHELP_HXX + +#include <com/sun/star/uno/Reference.h> +#include <i18nlangtag/languagetag.hxx> +#include <mutex> +#include <rtl/ustring.hxx> +#include <tools/long.hxx> +#include <vcl/dllapi.h> +#include <memory> + +namespace com::sun::star::uno { + class XComponentContext; +} +namespace utl { + class TransliterationWrapper; +} +class LocaleDataWrapper; + +namespace vcl +{ + +class VCL_DLLPUBLIC I18nHelper +{ + mutable std::mutex maMutex; + LanguageTag maLanguageTag; + css::uno::Reference< css::uno::XComponentContext > m_xContext; + + std::unique_ptr<LocaleDataWrapper> mpLocaleDataWrapper; + std::unique_ptr<utl::TransliterationWrapper> mpTransliterationWrapper; + + bool mbTransliterateIgnoreCase; + + SAL_DLLPRIVATE void ImplDestroyWrappers(); + + SAL_DLLPRIVATE utl::TransliterationWrapper& ImplGetTransliterationWrapper() const; + SAL_DLLPRIVATE LocaleDataWrapper& ImplGetLocaleDataWrapper() const; + +public: + + I18nHelper( const css::uno::Reference< css::uno::XComponentContext >& rxContext, const LanguageTag& rLanguageTag ); + ~I18nHelper(); + + sal_Int32 CompareString( const OUString& rStr1, const OUString& rStr2 ) const; + + bool MatchString( const OUString& rStr1, const OUString& rStr2 ) const; + bool MatchMnemonic( std::u16string_view rString, sal_Unicode cMnemonicChar ) const; + + OUString GetNum( tools::Long nNumber, sal_uInt16 nDecimals, bool bUseThousandSep = true, bool bTrailingZeros = true ) const; + + static OUString filterFormattingChars( const OUString& ); +}; + +} // namespace vcl + +#endif // INCLUDED_VCL_I18NHELP_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/idle.hxx b/include/vcl/idle.hxx new file mode 100644 index 000000000..d5162efcb --- /dev/null +++ b/include/vcl/idle.hxx @@ -0,0 +1,70 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_IDLE_HXX +#define INCLUDED_VCL_IDLE_HXX + +#include <vcl/timer.hxx> + +/** + * An idle is a timer to be scheduled immediately. + * + * It's - more or less - just a convenience class. + * + * Note: Despite the name, the timer is not necessarily invoked when idle. + * Use an idle priority such as TaskPriority::DEFAULT_IDLE to actually + * invoke the timer only when idle. + */ +class VCL_DLLPUBLIC Idle : public Timer +{ +private: + // Delete all timeout specific functions, we don't want in an Idle + void SetTimeout( sal_uInt64 nTimeoutMs ) = delete; + sal_uInt64 GetTimeout() const = delete; + +protected: + virtual sal_uInt64 UpdateMinPeriod( sal_uInt64 nTimeNow ) const override; + + Idle( bool bAuto, const char *pDebugName ); + +public: + Idle( const char *pDebugName ); + + virtual void Start(bool bStartTimer = true) override; +}; + +/** + * An auto-idle is long running task processing small chunks of data, which + * is re-scheduled multiple times. + * + * Remember to stop the Idle when finished, as it would otherwise busy loop the CPU! + * + * It probably makes sense to re-implement ReadyForSchedule and UpdateMinPeriod, + * in case there is a quick check and it can otherwise sleep. + */ +class VCL_DLLPUBLIC AutoIdle : public Idle +{ +public: + AutoIdle( const char *pDebugName ); +}; + + +#endif // INCLUDED_VCL_IDLE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/image.hxx b/include/vcl/image.hxx new file mode 100644 index 000000000..6c130bf4c --- /dev/null +++ b/include/vcl/image.hxx @@ -0,0 +1,75 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_IMAGE_HXX +#define INCLUDED_VCL_IMAGE_HXX + +#include <vcl/dllapi.h> +#include <tools/gen.hxx> +#include <vcl/bitmapex.hxx> +#include <vcl/outdev.hxx> + +#include <memory> + +class ImplImage; + +namespace com::sun::star::graphic { class XGraphic; } +namespace com::sun::star::uno { template <class interface_type> class Reference; } + +#define IMAGELIST_IMAGE_NOTFOUND (sal_uInt16(0xFFFF)) + +enum class StockImage { Yes }; + +class SAL_WARN_UNUSED VCL_DLLPUBLIC Image +{ + friend class ::OutputDevice; +public: + Image(); + explicit Image(BitmapEx const & rBitmapEx); + explicit Image(css::uno::Reference<css::graphic::XGraphic> const & rxGraphic); + explicit Image(OUString const & rPNGFileUrl); + explicit Image(StockImage, OUString const & rPNGFilePath); + + Size GetSizePixel() const; + BitmapEx GetBitmapEx() const; + + bool operator!() const + { + return !mpImplData; + } + bool operator==(const Image& rImage) const; + bool operator!=(const Image& rImage) const + { + return !(Image::operator==(rImage)); + } + + OUString GetStock() const; + + void Draw(OutputDevice* pOutDev, const Point& rPos, DrawImageFlags nStyle, const Size* pSize = nullptr); + +private: + + std::shared_ptr<ImplImage> mpImplData; + + SAL_DLLPRIVATE void ImplInit(BitmapEx const & rBmpEx); +}; + +#endif // INCLUDED_VCL_IMAGE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/imap.hxx b/include/vcl/imap.hxx new file mode 100644 index 000000000..062392003 --- /dev/null +++ b/include/vcl/imap.hxx @@ -0,0 +1,138 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_IMAP_HXX +#define INCLUDED_VCL_IMAP_HXX + +#include <vcl/imapobj.hxx> +#include <vcl/dllapi.h> +#include <tools/stream.hxx> +#include <tools/solar.h> +#include <memory> +#include <vector> + +class Point; +class Size; +class Fraction; +class IMapObject; + +class VCL_DLLPUBLIC ImageMap final +{ +private: + + std::vector<std::unique_ptr<IMapObject>> maList; + OUString aName; + + // binary saving/loading + void ImpWriteImageMap( SvStream& rOStm ) const ; + void ImpReadImageMap( SvStream& rIStm, size_t nCount ); + + // Import/Export + void ImpWriteCERN( SvStream& rOStm ) const; + void ImpWriteNCSA( SvStream& rOStm ) const; + void ImpReadCERN( SvStream& rOStm ); + void ImpReadNCSA( SvStream& rOStm ); + + void ImpReadCERNLine( std::string_view rLine ); + static Point ImpReadCERNCoords( const char** ppStr ); + static tools::Long ImpReadCERNRadius( const char** ppStr ); + static OUString ImpReadCERNURL( const char** ppStr ); + + void ImpReadNCSALine( std::string_view rLine ); + static OUString ImpReadNCSAURL( const char** ppStr ); + static Point ImpReadNCSACoords( const char** ppStr ); + + static IMapFormat ImpDetectFormat( SvStream& rIStm ); + +public: + + ImageMap() {}; + ImageMap( const OUString& rName ); + ImageMap( const ImageMap& rImageMap ); + + // all IMapObjects are destroyed in the destructor + ~ImageMap(); + + ImageMap& operator=( const ImageMap& rImageMap ); + + // comparison (everything is checked for equality) + bool operator==( const ImageMap& rImageMap ); + bool operator!=( const ImageMap& rImageMap ); + + // a new IMap object is inserted at the end of the Map + void InsertIMapObject( const IMapObject& rIMapObject ); + void InsertIMapObject( std::unique_ptr<IMapObject> rIMapObject ); + + // access to the single ImapObjects; the objects may + // not be destroyed from outside + IMapObject* GetIMapObject( size_t nPos ) const + { + return ( nPos < maList.size() ) ? maList[ nPos ].get() : nullptr; + } + + // returns the object which was hit first or NULL; + // size and position values are in 1/100mm; + // rTotalSize is the original size of the image + // rDisplaySize is the current size; + // rRelPoint relates to the display size and the upper left + // corner of the image + IMapObject* GetHitIMapObject( const Size& rOriginalSize, + const Size& rDisplaySize, + const Point& rRelHitPoint, + sal_uLong nFlags = 0 ); + + // returns the total amount of IMap objects + size_t GetIMapObjectCount() const { return maList.size(); } + + // deletes all internal objects + void ClearImageMap(); + + const OUString& GetName() const { return aName; } + void SetName( const OUString& rName ) { aName = rName; } + + // scales all objects of the ImageMap according to the given factor + void Scale( const Fraction& rFractX, const Fraction& rFracY ); + + // Import/Export + void Write ( SvStream& rOStm ) const; + void Read( SvStream& rIStm ); + + void Write( SvStream& rOStm, IMapFormat nFormat ) const; + sal_uLong Read( SvStream& rIStm, IMapFormat nFormat ); +}; + +class IMapCompat +{ + SvStream* pRWStm; + sal_uInt64 nCompatPos; + sal_uInt64 nTotalSize; + StreamMode nStmMode; + + IMapCompat( const IMapCompat& ) = delete; + IMapCompat& operator=( const IMapCompat& ) { return *this; } + +public: + + IMapCompat( SvStream& rStm, const StreamMode nStreamMode ); + ~IMapCompat(); +}; + +#endif // INCLUDED_VCL_IMAP_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/imapcirc.hxx b/include/vcl/imapcirc.hxx new file mode 100644 index 000000000..4fc5808af --- /dev/null +++ b/include/vcl/imapcirc.hxx @@ -0,0 +1,69 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_VCL_IMAPCIRC_HXX +#define INCLUDED_VCL_IMAPCIRC_HXX + +#include <vcl/dllapi.h> +#include <tools/gen.hxx> +#include <vcl/imapobj.hxx> + +class Fraction; + +class VCL_DLLPUBLIC IMapCircleObject final : public IMapObject +{ + Point aCenter; + sal_Int32 nRadius; + + void ImpConstruct( const Point& rCenter, sal_Int32 nRad, bool bPixel ); + + // binary import/export + virtual void WriteIMapObject( SvStream& rOStm ) const override; + virtual void ReadIMapObject( SvStream& rIStm ) override; + +public: + + IMapCircleObject() : nRadius(0) {} + IMapCircleObject( const Point& rCenter, sal_Int32 nRad, + const OUString& rURL, + const OUString& rAltText, + const OUString& rDesc, + const OUString& rTarget, + const OUString& rName, + bool bActive = true, + bool bPixelCoords = true ); + + virtual IMapObjectType GetType() const override; + virtual bool IsHit( const Point& rPoint ) const override; + + Point GetCenter( bool bPixelCoords = true ) const; + sal_Int32 GetRadius( bool bPixelCoords = true ) const; + + void Scale( const Fraction& rFractX, const Fraction& rFracY ); + + using IMapObject::IsEqual; + bool IsEqual( const IMapCircleObject& rEqObj ) const; + + // import/export + void WriteCERN( SvStream& rOStm ) const; + void WriteNCSA( SvStream& rOStm ) const; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/imapobj.hxx b/include/vcl/imapobj.hxx new file mode 100644 index 000000000..54498a65c --- /dev/null +++ b/include/vcl/imapobj.hxx @@ -0,0 +1,129 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_IMAPOBJ_HXX +#define INCLUDED_VCL_IMAPOBJ_HXX + +#include <svl/macitem.hxx> +#include <rtl/strbuf.hxx> + +class Point; +class SvStream; + +enum class IMapObjectType +{ + Rectangle = 1, + Circle = 2, + Polygon = 3 +}; + +#define IMAP_OBJ_VERSION (sal_uInt16(0x0005)) +#define IMAGE_MAP_VERSION (sal_uInt16(0x0001)) + +#define IMAPMAGIC "SDIMAP" + +#define IMAP_MIRROR_HORZ 0x00000001L +#define IMAP_MIRROR_VERT 0x00000002L + +enum class IMapFormat +{ + Binary = 1, + CERN = 2, + NCSA = 3, + Detect = 15, +}; + +#define IMAP_ERR_OK 0x00000000L +#define IMAP_ERR_FORMAT 0x00000001L + +class IMapObject +{ + friend class ImageMap; + + OUString aURL; + OUString aAltText; + OUString aDesc; + OUString aTarget; + OUString aName; + SvxMacroTableDtor aEventList; + bool bActive; + +protected: + sal_uInt16 nReadVersion; + + // binary import/export + virtual void WriteIMapObject( SvStream& rOStm ) const = 0; + virtual void ReadIMapObject( SvStream& rIStm ) = 0; + + // helper methods + static void AppendCERNCoords(OStringBuffer& rBuf, const Point& rPoint100); + void AppendCERNURL(OStringBuffer& rBuf) const; + static void AppendNCSACoords(OStringBuffer& rBuf, const Point& rPoint100); + void AppendNCSAURL(OStringBuffer&rBuf) const; + +public: + + IMapObject(); + IMapObject( const OUString& rURL, + const OUString& rAltText, + const OUString& rDesc, + const OUString& rTarget, + const OUString& rName, + bool bActive ); + virtual ~IMapObject() {}; + + IMapObject(IMapObject const &) = default; + IMapObject(IMapObject &&) = default; + IMapObject & operator =(IMapObject const &) = default; + IMapObject & operator =(IMapObject &&) = default; + + virtual IMapObjectType GetType() const = 0; + virtual bool IsHit( const Point& rPoint ) const = 0; + + void Write ( SvStream& rOStm ) const; + void Read( SvStream& rIStm ); + + const OUString& GetURL() const { return aURL; } + void SetURL( const OUString& rURL ) { aURL = rURL; } + + const OUString& GetAltText() const { return aAltText; } + void SetAltText( const OUString& rAltText) { aAltText = rAltText; } + + const OUString& GetDesc() const { return aDesc; } + void SetDesc( const OUString& rDesc ) { aDesc = rDesc; } + + const OUString& GetTarget() const { return aTarget; } + void SetTarget( const OUString& rTarget ) { aTarget = rTarget; } + + const OUString& GetName() const { return aName; } + void SetName( const OUString& rName ) { aName = rName; } + + bool IsActive() const { return bActive; } + void SetActive( bool bSetActive ) { bActive = bSetActive; } + + bool IsEqual( const IMapObject& rEqObj ) const; + + // IMap-Events + const SvxMacroTableDtor& GetMacroTable() const { return aEventList;} + void SetMacroTable( const SvxMacroTableDtor& rTbl ) { aEventList = rTbl; } +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/imappoly.hxx b/include/vcl/imappoly.hxx new file mode 100644 index 000000000..5a9e80c27 --- /dev/null +++ b/include/vcl/imappoly.hxx @@ -0,0 +1,73 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_IMAPPOLY_HXX +#define INCLUDED_VCL_IMAPPOLY_HXX + +#include <vcl/dllapi.h> +#include <vcl/imapobj.hxx> +#include <tools/poly.hxx> + +class Fraction; + +class VCL_DLLPUBLIC IMapPolygonObject final : public IMapObject +{ + tools::Polygon aPoly; + tools::Rectangle aEllipse; + bool bEllipse; + + VCL_DLLPRIVATE void ImpConstruct( const tools::Polygon& rPoly, bool bPixel ); + + // binary import/export + virtual void WriteIMapObject( SvStream& rOStm ) const override; + virtual void ReadIMapObject( SvStream& rIStm ) override; + +public: + IMapPolygonObject() : bEllipse(false) {} + IMapPolygonObject( const tools::Polygon& rPoly, + const OUString& rURL, + const OUString& rAltText, + const OUString& rDesc, + const OUString& rTarget, + const OUString& rName, + bool bActive = true, + bool bPixelCoords = true ); + + virtual IMapObjectType GetType() const override; + virtual bool IsHit( const Point& rPoint ) const override; + + tools::Polygon GetPolygon( bool bPixelCoords = true ) const; + + bool HasExtraEllipse() const { return bEllipse; } + const tools::Rectangle& GetExtraEllipse() const { return aEllipse; } + void SetExtraEllipse( const tools::Rectangle& rEllipse ); + + void Scale( const Fraction& rFractX, const Fraction& rFracY ); + + using IMapObject::IsEqual; + bool IsEqual( const IMapPolygonObject& rEqObj ); + + // import/export + void WriteCERN( SvStream& rOStm ) const; + void WriteNCSA( SvStream& rOStm ) const; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/imaprect.hxx b/include/vcl/imaprect.hxx new file mode 100644 index 000000000..6637bb771 --- /dev/null +++ b/include/vcl/imaprect.hxx @@ -0,0 +1,67 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_VCL_IMAPRECT_HXX +#define INCLUDED_VCL_IMAPRECT_HXX + +#include <vcl/dllapi.h> +#include <vcl/imapobj.hxx> +#include <tools/gen.hxx> + +class Fraction; + +class VCL_DLLPUBLIC IMapRectangleObject final : public IMapObject +{ + tools::Rectangle aRect; + + VCL_DLLPRIVATE void ImpConstruct( const tools::Rectangle& rRect, bool bPixel ); + + // binary import/export + virtual void WriteIMapObject( SvStream& rOStm ) const override; + virtual void ReadIMapObject( SvStream& rIStm ) override; + +public: + + IMapRectangleObject() {}; + IMapRectangleObject( const tools::Rectangle& rRect, + const OUString& rURL, + const OUString& rAltText, + const OUString& rDesc, + const OUString& rTarget, + const OUString& rName, + bool bActive = true, + bool bPixelCoords = true ); + + virtual IMapObjectType GetType() const override; + virtual bool IsHit( const Point& rPoint ) const override; + + tools::Rectangle GetRectangle( bool bPixelCoords = true ) const; + + void Scale( const Fraction& rFractX, const Fraction& rFracY ); + + using IMapObject::IsEqual; + bool IsEqual( const IMapRectangleObject& rEqObj ) const; + + // import/export + void WriteCERN( SvStream& rOStm ) const; + void WriteNCSA( SvStream& rOStm ) const; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/inetimg.hxx b/include/vcl/inetimg.hxx new file mode 100644 index 000000000..64d64c122 --- /dev/null +++ b/include/vcl/inetimg.hxx @@ -0,0 +1,58 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_VCL_INETIMG_HXX +#define INCLUDED_VCL_INETIMG_HXX + +#include <rtl/ustring.hxx> +#include <tools/gen.hxx> +#include <sot/formats.hxx> + + +class INetImage +{ + OUString aImageURL; + OUString aTargetURL; + OUString aTargetFrame; + Size aSizePixel; + +public: + INetImage( + const OUString& rImageURL, + const OUString& rTargetURL, + const OUString& rTargetFrame ) + : aImageURL( rImageURL ), + aTargetURL( rTargetURL ), + aTargetFrame( rTargetFrame ) + {} + INetImage() + {} + + const OUString& GetImageURL() const { return aImageURL; } + const OUString& GetTargetURL() const { return aTargetURL; } + const OUString& GetTargetFrame() const { return aTargetFrame; } + + // import/export + void Write( SvStream& rOStm, SotClipboardFormatId nFormat ) const; + bool Read( SvStream& rIStm, SotClipboardFormatId nFormat ); +}; + +#endif // INCLUDED_VCL_INETIMG_HXX + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/inputctx.hxx b/include/vcl/inputctx.hxx new file mode 100644 index 000000000..25d057b91 --- /dev/null +++ b/include/vcl/inputctx.hxx @@ -0,0 +1,81 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_INPUTCTX_HXX +#define INCLUDED_VCL_INPUTCTX_HXX + +#include <vcl/dllapi.h> +#include <vcl/font.hxx> +#include <o3tl/typed_flags_set.hxx> + + +enum class InputContextFlags +{ + NONE = 0x0000, + Text = 0x0001, + ExtText = 0x0002 +}; +namespace o3tl +{ + template<> struct typed_flags<InputContextFlags> : is_typed_flags<InputContextFlags, 0x0003> {}; +} + + +class VCL_DLLPUBLIC InputContext +{ +private: + vcl::Font maFont; + InputContextFlags mnOptions; + +public: + InputContext() { mnOptions = InputContextFlags::NONE; } + InputContext( const InputContext& rInputContext ) : + maFont( rInputContext.maFont ) + { mnOptions = rInputContext.mnOptions; } + InputContext( const vcl::Font& rFont, InputContextFlags nOptions = InputContextFlags::NONE ) : + maFont( rFont ) + { mnOptions = nOptions; } + + const vcl::Font& GetFont() const { return maFont; } + + void SetOptions( InputContextFlags nOptions ) { mnOptions = nOptions; } + InputContextFlags GetOptions() const { return mnOptions; } + + InputContext& operator=( const InputContext& rInputContext ); + bool operator==( const InputContext& rInputContext ) const; + bool operator!=( const InputContext& rInputContext ) const + { return !(InputContext::operator==( rInputContext )); } +}; + +inline InputContext& InputContext::operator=( const InputContext& rInputContext ) +{ + maFont = rInputContext.maFont; + mnOptions = rInputContext.mnOptions; + return *this; +} + +inline bool InputContext::operator==( const InputContext& rInputContext ) const +{ + return ((mnOptions == rInputContext.mnOptions) && + (maFont == rInputContext.maFont)); +} + +#endif // INCLUDED_VCL_INPUTCTX_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/inputtypes.hxx b/include/vcl/inputtypes.hxx new file mode 100644 index 000000000..c5805084b --- /dev/null +++ b/include/vcl/inputtypes.hxx @@ -0,0 +1,43 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_INPUTTYPES_HXX +#define INCLUDED_VCL_INPUTTYPES_HXX + +#include <o3tl/typed_flags_set.hxx> + +enum class VclInputFlags { + NONE = 0x0000, + MOUSE = 0x0001, + KEYBOARD = 0x0002, + PAINT = 0x0004, + TIMER = 0x0008, + OTHER = 0x0010, + APPEVENT = 0x0020, +}; +namespace o3tl +{ + template<> struct typed_flags<VclInputFlags> : is_typed_flags<VclInputFlags, 0x003f> {}; +} + +#define VCL_INPUT_ANY (VclInputFlags::MOUSE | VclInputFlags::KEYBOARD | VclInputFlags::PAINT | VclInputFlags::TIMER | VclInputFlags::OTHER | VclInputFlags::APPEVENT) + +#endif // INCLUDED_VCL_INPUTTYPES_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/introwin.hxx b/include/vcl/introwin.hxx new file mode 100644 index 000000000..8d7d709e4 --- /dev/null +++ b/include/vcl/introwin.hxx @@ -0,0 +1,40 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_INTROWIN_HXX +#define INCLUDED_VCL_INTROWIN_HXX + +#include <config_options.h> +#include <vcl/dllapi.h> +#include <vcl/wrkwin.hxx> + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) IntroWindow : public WorkWindow +{ +private: + SAL_DLLPRIVATE void ImplInitIntroWindowData(); + +public: + IntroWindow(); + virtual ~IntroWindow() override; + virtual void dispose() override; +}; + +#endif // INCLUDED_VCL_INTROWIN_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/jobset.hxx b/include/vcl/jobset.hxx new file mode 100644 index 000000000..ff7b5dfb6 --- /dev/null +++ b/include/vcl/jobset.hxx @@ -0,0 +1,63 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_JOBSET_HXX +#define INCLUDED_VCL_JOBSET_HXX + +#include <rtl/ustring.hxx> +#include <vcl/dllapi.h> +#include <o3tl/cow_wrapper.hxx> + +class SvStream; +class ImplJobSetup; + +class VCL_DLLPUBLIC JobSetup +{ + friend class Printer; + +public: + JobSetup(); + JobSetup( const JobSetup& rJob ); + ~JobSetup(); + + JobSetup& operator=( const JobSetup& rJob ); + JobSetup& operator=( JobSetup&& rJob ); + + bool operator==( const JobSetup& rJobSetup ) const; + bool operator!=( const JobSetup& rJobSetup ) const + { return !(JobSetup::operator==( rJobSetup )); } + + SAL_DLLPRIVATE ImplJobSetup& ImplGetData(); + SAL_DLLPRIVATE const ImplJobSetup& ImplGetConstData() const; + + OUString const & GetPrinterName() const; + bool IsDefault() const; + + friend VCL_DLLPUBLIC SvStream& ReadJobSetup( SvStream& rIStream, JobSetup& rJobSetup ); + friend VCL_DLLPUBLIC SvStream& WriteJobSetup( SvStream& rOStream, const JobSetup& rJobSetup ); + + typedef o3tl::cow_wrapper< ImplJobSetup > ImplType; + +private: + ImplType mpData; +}; + +#endif // INCLUDED_VCL_JOBSET_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/jsdialog/executor.hxx b/include/vcl/jsdialog/executor.hxx new file mode 100644 index 000000000..6e388a6a3 --- /dev/null +++ b/include/vcl/jsdialog/executor.hxx @@ -0,0 +1,93 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#pragma once + +#include <vcl/dllapi.h> +#include <vcl/uitest/uiobject.hxx> +#include <vcl/weld.hxx> +#include <unordered_map> + +class LOKTrigger +{ +public: + static void trigger_changed(weld::TextView& rView) { rView.signal_changed(); } + + static void trigger_changed(weld::Entry& rEdit) { rEdit.signal_changed(); } + + static void trigger_changed(weld::ComboBox& rComboBox) { rComboBox.signal_changed(); } + + static void trigger_changed(weld::TreeView& rTreeView) { rTreeView.signal_changed(); } + + static void trigger_changed(weld::IconView& rIconView) { rIconView.signal_selection_changed(); } + + static void trigger_toggled(weld::Toggleable& rButton) { rButton.signal_toggled(); } + + static void trigger_row_activated(weld::TreeView& rTreeView) + { + rTreeView.signal_row_activated(); + } + + static void trigger_item_activated(weld::IconView& rIconView) + { + rIconView.signal_item_activated(); + } + + static void trigger_clicked(weld::Toolbar& rToolbar, const OString& rIdent) + { + rToolbar.signal_clicked(rIdent); + } + + static void trigger_clicked(weld::Button& rButton) { rButton.signal_clicked(); } + + static void trigger_click(weld::DrawingArea& rDrawingArea, const Point& rPos) + { + rDrawingArea.click(rPos); + } + + static void trigger_value_changed(weld::SpinButton& rSpinButton) + { + rSpinButton.signal_value_changed(); + } + + static void trigger_closed(weld::Popover& rPopover) { rPopover.popdown(); } + + static void trigger_key_press(weld::Widget& rWidget, const KeyEvent& rEvent) + { + rWidget.m_aKeyPressHdl.Call(rEvent); + } + + static void trigger_key_release(weld::Widget& rWidget, const KeyEvent& rEvent) + { + rWidget.m_aKeyReleaseHdl.Call(rEvent); + } + + static void command(weld::DrawingArea& rArea, const CommandEvent& rCmd) + { + rArea.m_aCommandHdl.Call(rCmd); + } +}; + +namespace jsdialog +{ +// type used to store key-value pairs to put in the generated messages +typedef std::unordered_map<std::string, OUString> ActionDataMap; + +/// execute action on a widget +VCL_DLLPUBLIC bool ExecuteAction(const std::string& nWindowId, const OString& rWidget, + StringMap& rData); +/// send full update message to the client +VCL_DLLPUBLIC void SendFullUpdate(const std::string& nWindowId, const OString& rWidget); +/// send action message to the client +VCL_DLLPUBLIC void SendAction(const std::string& nWindowId, const OString& rWidget, + std::unique_ptr<ActionDataMap> pData); +VCL_DLLPUBLIC StringMap jsonToStringMap(const char* pJSON); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/keycod.hxx b/include/vcl/keycod.hxx new file mode 100644 index 000000000..68841ef85 --- /dev/null +++ b/include/vcl/keycod.hxx @@ -0,0 +1,116 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_KEYCOD_HXX +#define INCLUDED_VCL_KEYCOD_HXX + +#include <rtl/ustring.hxx> +#include <vcl/dllapi.h> +#include <vcl/keycodes.hxx> + +enum class KeyFuncType : sal_Int32 { DONTKNOW, + CUT, COPY, PASTE, UNDO, + REDO, DELETE }; + +namespace vcl +{ + +class VCL_DLLPUBLIC KeyCode +{ +private: + sal_uInt16 nKeyCodeAndModifiers; + KeyFuncType eFunc; + +public: + KeyCode() { nKeyCodeAndModifiers = 0; eFunc = KeyFuncType::DONTKNOW; } + KeyCode( sal_uInt16 nKey, sal_uInt16 nModifier = 0 ); + KeyCode( sal_uInt16 nKey, bool bShift, bool bMod1, bool bMod2, bool bMod3 ); + KeyCode( KeyFuncType eFunction ); + + sal_uInt16 GetFullCode() const { return nKeyCodeAndModifiers; } + KeyFuncType GetFullFunction() const { return eFunc; } + + sal_uInt16 GetCode() const + { return (nKeyCodeAndModifiers & KEY_CODE_MASK); } + + sal_uInt16 GetModifier() const + { return (nKeyCodeAndModifiers & KEY_MODIFIERS_MASK); } + bool IsShift() const + { return ((nKeyCodeAndModifiers & KEY_SHIFT) != 0); } + bool IsMod1() const + { return ((nKeyCodeAndModifiers & KEY_MOD1) != 0); } + bool IsMod2() const + { return ((nKeyCodeAndModifiers & KEY_MOD2) != 0); } + bool IsMod3() const + { return ((nKeyCodeAndModifiers & KEY_MOD3) != 0); } + sal_uInt16 GetGroup() const + { return (nKeyCodeAndModifiers & KEYGROUP_TYPE); } + + OUString GetName() const; + + bool IsFunction() const + { return (eFunc != KeyFuncType::DONTKNOW); } + + KeyFuncType GetFunction() const; + + bool operator ==( const KeyCode& rKeyCode ) const; + bool operator !=( const KeyCode& rKeyCode ) const; +}; + +} // namespace vcl + +inline vcl::KeyCode::KeyCode( sal_uInt16 nKey, sal_uInt16 nModifier ) +{ + nKeyCodeAndModifiers = nKey | nModifier; + eFunc = KeyFuncType::DONTKNOW; +} + +inline vcl::KeyCode::KeyCode( sal_uInt16 nKey, bool bShift, bool bMod1, bool bMod2, bool bMod3 ) +{ + nKeyCodeAndModifiers = nKey; + if( bShift ) + nKeyCodeAndModifiers |= KEY_SHIFT; + if( bMod1 ) + nKeyCodeAndModifiers |= KEY_MOD1; + if( bMod2 ) + nKeyCodeAndModifiers |= KEY_MOD2; + if( bMod3 ) + nKeyCodeAndModifiers |= KEY_MOD3; + eFunc = KeyFuncType::DONTKNOW; +} + +inline bool vcl::KeyCode::operator ==( const vcl::KeyCode& rKeyCode ) const +{ + if ( (eFunc == KeyFuncType::DONTKNOW) && (rKeyCode.eFunc == KeyFuncType::DONTKNOW) ) + return (nKeyCodeAndModifiers == rKeyCode.nKeyCodeAndModifiers); + else + return (GetFunction() == rKeyCode.GetFunction()); +} + +inline bool vcl::KeyCode::operator !=( const vcl::KeyCode& rKeyCode ) const +{ + if ( (eFunc == KeyFuncType::DONTKNOW) && (rKeyCode.eFunc == KeyFuncType::DONTKNOW) ) + return (nKeyCodeAndModifiers != rKeyCode.nKeyCodeAndModifiers); + else + return (GetFunction() != rKeyCode.GetFunction()); +} + +#endif // INCLUDED_VCL_KEYCOD_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/keycodes.hxx b/include/vcl/keycodes.hxx new file mode 100644 index 000000000..e68f176ff --- /dev/null +++ b/include/vcl/keycodes.hxx @@ -0,0 +1,200 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_KEYCODES_HXX +#define INCLUDED_VCL_KEYCODES_HXX + +#include <com/sun/star/awt/Key.hpp> +#include <com/sun/star/awt/KeyGroup.hpp> +#include <o3tl/typed_flags_set.hxx> + +constexpr sal_uInt16 KEY_CODE_MASK = 0x0FFF; + +// Modifier keys +constexpr sal_uInt16 KEY_SHIFT = 0x1000; +constexpr sal_uInt16 KEY_MOD1 = 0x2000; +constexpr sal_uInt16 KEY_MOD2 = 0x4000; +constexpr sal_uInt16 KEY_MOD3 = 0x8000; +constexpr sal_uInt16 KEY_MODIFIERS_MASK = 0xF000; + +// Key groups +constexpr sal_uInt16 KEYGROUP_NUM = css::awt::KeyGroup::NUM; +constexpr sal_uInt16 KEYGROUP_ALPHA = css::awt::KeyGroup::ALPHA; +constexpr sal_uInt16 KEYGROUP_FKEYS = css::awt::KeyGroup::FKEYS; +constexpr sal_uInt16 KEYGROUP_CURSOR = css::awt::KeyGroup::CURSOR; +constexpr sal_uInt16 KEYGROUP_MISC = css::awt::KeyGroup::MISC; +constexpr sal_uInt16 KEYGROUP_TYPE = css::awt::KeyGroup::TYPE; + +// Key codes +constexpr sal_uInt16 KEY_0 = css::awt::Key::NUM0; +constexpr sal_uInt16 KEY_1 = css::awt::Key::NUM1; +constexpr sal_uInt16 KEY_2 = css::awt::Key::NUM2; +constexpr sal_uInt16 KEY_3 = css::awt::Key::NUM3; +constexpr sal_uInt16 KEY_4 = css::awt::Key::NUM4; +constexpr sal_uInt16 KEY_5 = css::awt::Key::NUM5; +constexpr sal_uInt16 KEY_6 = css::awt::Key::NUM6; +constexpr sal_uInt16 KEY_7 = css::awt::Key::NUM7; +constexpr sal_uInt16 KEY_8 = css::awt::Key::NUM8; +constexpr sal_uInt16 KEY_9 = css::awt::Key::NUM9; + +constexpr sal_uInt16 KEY_A = css::awt::Key::A; +constexpr sal_uInt16 KEY_B = css::awt::Key::B; +constexpr sal_uInt16 KEY_C = css::awt::Key::C; +constexpr sal_uInt16 KEY_D = css::awt::Key::D; +constexpr sal_uInt16 KEY_E = css::awt::Key::E; +constexpr sal_uInt16 KEY_F = css::awt::Key::F; +constexpr sal_uInt16 KEY_G = css::awt::Key::G; +constexpr sal_uInt16 KEY_H = css::awt::Key::H; +constexpr sal_uInt16 KEY_I = css::awt::Key::I; +constexpr sal_uInt16 KEY_J = css::awt::Key::J; +constexpr sal_uInt16 KEY_K = css::awt::Key::K; +constexpr sal_uInt16 KEY_L = css::awt::Key::L; +constexpr sal_uInt16 KEY_M = css::awt::Key::M; +constexpr sal_uInt16 KEY_N = css::awt::Key::N; +constexpr sal_uInt16 KEY_O = css::awt::Key::O; +constexpr sal_uInt16 KEY_P = css::awt::Key::P; +constexpr sal_uInt16 KEY_Q = css::awt::Key::Q; +constexpr sal_uInt16 KEY_R = css::awt::Key::R; +constexpr sal_uInt16 KEY_S = css::awt::Key::S; +constexpr sal_uInt16 KEY_T = css::awt::Key::T; +constexpr sal_uInt16 KEY_U = css::awt::Key::U; +constexpr sal_uInt16 KEY_V = css::awt::Key::V; +constexpr sal_uInt16 KEY_W = css::awt::Key::W; +constexpr sal_uInt16 KEY_X = css::awt::Key::X; +constexpr sal_uInt16 KEY_Y = css::awt::Key::Y; +constexpr sal_uInt16 KEY_Z = css::awt::Key::Z; + +constexpr sal_uInt16 KEY_F1 = css::awt::Key::F1; +constexpr sal_uInt16 KEY_F2 = css::awt::Key::F2; +constexpr sal_uInt16 KEY_F3 = css::awt::Key::F3; +constexpr sal_uInt16 KEY_F4 = css::awt::Key::F4; +constexpr sal_uInt16 KEY_F5 = css::awt::Key::F5; +constexpr sal_uInt16 KEY_F6 = css::awt::Key::F6; +constexpr sal_uInt16 KEY_F7 = css::awt::Key::F7; +constexpr sal_uInt16 KEY_F8 = css::awt::Key::F8; +constexpr sal_uInt16 KEY_F9 = css::awt::Key::F9; +constexpr sal_uInt16 KEY_F10 = css::awt::Key::F10; +constexpr sal_uInt16 KEY_F11 = css::awt::Key::F11; +constexpr sal_uInt16 KEY_F12 = css::awt::Key::F12; +constexpr sal_uInt16 KEY_F13 = css::awt::Key::F13; +constexpr sal_uInt16 KEY_F14 = css::awt::Key::F14; +constexpr sal_uInt16 KEY_F15 = css::awt::Key::F15; +constexpr sal_uInt16 KEY_F16 = css::awt::Key::F16; +constexpr sal_uInt16 KEY_F17 = css::awt::Key::F17; +constexpr sal_uInt16 KEY_F18 = css::awt::Key::F18; +constexpr sal_uInt16 KEY_F19 = css::awt::Key::F19; +constexpr sal_uInt16 KEY_F20 = css::awt::Key::F20; +constexpr sal_uInt16 KEY_F21 = css::awt::Key::F21; +constexpr sal_uInt16 KEY_F22 = css::awt::Key::F22; +constexpr sal_uInt16 KEY_F23 = css::awt::Key::F23; +constexpr sal_uInt16 KEY_F24 = css::awt::Key::F24; +constexpr sal_uInt16 KEY_F25 = css::awt::Key::F25; +constexpr sal_uInt16 KEY_F26 = css::awt::Key::F26; + +constexpr sal_uInt16 KEY_DOWN = css::awt::Key::DOWN; +constexpr sal_uInt16 KEY_UP = css::awt::Key::UP; +constexpr sal_uInt16 KEY_LEFT = css::awt::Key::LEFT; +constexpr sal_uInt16 KEY_RIGHT = css::awt::Key::RIGHT; +constexpr sal_uInt16 KEY_HOME = css::awt::Key::HOME; +constexpr sal_uInt16 KEY_END = css::awt::Key::END; +constexpr sal_uInt16 KEY_PAGEUP = css::awt::Key::PAGEUP; +constexpr sal_uInt16 KEY_PAGEDOWN = css::awt::Key::PAGEDOWN; + +constexpr sal_uInt16 KEY_RETURN = css::awt::Key::RETURN; +constexpr sal_uInt16 KEY_ESCAPE = css::awt::Key::ESCAPE; +constexpr sal_uInt16 KEY_TAB = css::awt::Key::TAB; +constexpr sal_uInt16 KEY_BACKSPACE = css::awt::Key::BACKSPACE; +constexpr sal_uInt16 KEY_SPACE = css::awt::Key::SPACE; +constexpr sal_uInt16 KEY_INSERT = css::awt::Key::INSERT; +constexpr sal_uInt16 KEY_DELETE = css::awt::Key::DELETE; + +constexpr sal_uInt16 KEY_ADD = css::awt::Key::ADD; +constexpr sal_uInt16 KEY_SUBTRACT = css::awt::Key::SUBTRACT; +constexpr sal_uInt16 KEY_MULTIPLY = css::awt::Key::MULTIPLY; +constexpr sal_uInt16 KEY_DIVIDE = css::awt::Key::DIVIDE; +constexpr sal_uInt16 KEY_POINT = css::awt::Key::POINT; +constexpr sal_uInt16 KEY_COMMA = css::awt::Key::COMMA; +constexpr sal_uInt16 KEY_LESS = css::awt::Key::LESS; +constexpr sal_uInt16 KEY_GREATER = css::awt::Key::GREATER; +constexpr sal_uInt16 KEY_EQUAL = css::awt::Key::EQUAL; + +constexpr sal_uInt16 KEY_OPEN = css::awt::Key::OPEN; +constexpr sal_uInt16 KEY_CUT = css::awt::Key::CUT; +constexpr sal_uInt16 KEY_COPY = css::awt::Key::COPY; +constexpr sal_uInt16 KEY_PASTE = css::awt::Key::PASTE; +constexpr sal_uInt16 KEY_UNDO = css::awt::Key::UNDO; +constexpr sal_uInt16 KEY_REPEAT = css::awt::Key::REPEAT; +constexpr sal_uInt16 KEY_FIND = css::awt::Key::FIND; +constexpr sal_uInt16 KEY_PROPERTIES = css::awt::Key::PROPERTIES; +constexpr sal_uInt16 KEY_FRONT = css::awt::Key::FRONT; +constexpr sal_uInt16 KEY_CONTEXTMENU = css::awt::Key::CONTEXTMENU; +constexpr sal_uInt16 KEY_MENU = css::awt::Key::MENU; +constexpr sal_uInt16 KEY_HELP = css::awt::Key::HELP; +constexpr sal_uInt16 KEY_HANGUL_HANJA = css::awt::Key::HANGUL_HANJA; +constexpr sal_uInt16 KEY_DECIMAL = css::awt::Key::DECIMAL; +constexpr sal_uInt16 KEY_TILDE = css::awt::Key::TILDE; +constexpr sal_uInt16 KEY_QUOTELEFT = css::awt::Key::QUOTELEFT; +constexpr sal_uInt16 KEY_BRACKETLEFT = css::awt::Key::BRACKETLEFT; +constexpr sal_uInt16 KEY_BRACKETRIGHT = css::awt::Key::BRACKETRIGHT; +constexpr sal_uInt16 KEY_SEMICOLON = css::awt::Key::SEMICOLON; +constexpr sal_uInt16 KEY_QUOTERIGHT = css::awt::Key::QUOTERIGHT; + +constexpr sal_uInt16 KEY_CAPSLOCK = css::awt::Key::CAPSLOCK; +constexpr sal_uInt16 KEY_NUMLOCK = css::awt::Key::NUMLOCK; +constexpr sal_uInt16 KEY_SCROLLLOCK = css::awt::Key::SCROLLLOCK; + +// extended Modifier-Keys (only used for modkey events) +enum class ModKeyFlags +{ + NONE = 0x0000, + LeftShift = 0x0001, + RightShift = 0x0002, + LeftMod1 = 0x0004, + RightMod1 = 0x0008, + LeftMod2 = 0x0010, + RightMod2 = 0x0020, + LeftMod3 = 0x0040, + RightMod3 = 0x0080, + Mod1Msk = LeftMod1 | RightMod1, // should be Mod1Mask, but that conflicts with a X.h macro grrrr + Mod2Msk = LeftMod2 | RightMod2, +}; +namespace o3tl +{ +template <> struct typed_flags<ModKeyFlags> : is_typed_flags<ModKeyFlags, 0x00ff> +{ +}; +} + +enum class KeyIndicatorState +{ + NONE = 0x0000, + CAPSLOCK = 0x0001, + NUMLOCK = 0x0002, + SCROLLLOCK = 0x0004 +}; +namespace o3tl +{ +template <> struct typed_flags<KeyIndicatorState> : is_typed_flags<KeyIndicatorState, 0x0007> +{ +}; +} + +#endif // INCLUDED_VCL_KEYCODES_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/layout.hxx b/include/vcl/layout.hxx new file mode 100644 index 000000000..2296f8097 --- /dev/null +++ b/include/vcl/layout.hxx @@ -0,0 +1,842 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_LAYOUT_HXX +#define INCLUDED_VCL_LAYOUT_HXX + +#include <config_options.h> +#include <vcl/dllapi.h> +#include <vcl/ctrl.hxx> +#include <vcl/svapp.hxx> +#include <vcl/window.hxx> +#include <vcl/settings.hxx> +#include <vcl/event.hxx> +#include <vcl/transfer.hxx> +#include <vcl/vclptr.hxx> +#include <vcl/IContext.hxx> +#include <vcl/commandevent.hxx> +#include <set> + +class HelpEvent; +class ScrollBar; +class ScrollBarBox; +class Splitter; + +class VCL_DLLPUBLIC VclContainer : public vcl::Window, + public vcl::IContext +{ +public: + VclContainer(vcl::Window *pParent, WinBits nStyle = WB_HIDE | WB_CLIPCHILDREN); + + //These take into account the external margins of the rWindow widget + //while GetOptimalSize/get_preferred_size and SetPosSizePixel are + //oblivious to them + static Size getLayoutRequisition(const vcl::Window &rWindow); + static void setLayoutPosSize(vcl::Window &rWindow, const Point &rPos, const Size &rSize); + + //applies the allocation pos and size onto rWindow via setLayoutPosSize taking into account + //the rWindows alignment desires within that allocation + static void setLayoutAllocation(vcl::Window &rWindow, const Point &rPos, const Size &rSize); + + virtual void queue_resize(StateChangedType eReason = StateChangedType::Layout) override; +protected: + //these are the two that need to be implemented by + //containers, figure out how much space you want... + virtual Size calculateRequisition() const = 0; + //..and decide what to do when set to this size + virtual void setAllocation(const Size &rAllocation) = 0; + + virtual sal_uInt16 getDefaultAccessibleRole() const override; + + // support for screenshot context menu + virtual void Command(const CommandEvent& rCEvt) override; + +public: + //you don't want to override these + virtual Size GetOptimalSize() const override; + virtual void SetPosSizePixel(const Point& rNewPos, const Size& rNewSize) override; + virtual void SetPosPixel(const Point& rAllocPos) override; + virtual void SetSizePixel(const Size& rAllocation) override; +private: + bool m_bLayoutDirty; +}; + +class VCL_DLLPUBLIC VclBox : public VclContainer +{ +protected: + bool m_bHomogeneous; + bool m_bVerticalContainer; + int m_nSpacing; +public: + VclBox(vcl::Window *pParent, bool bHomogeneous, int nSpacing) + : VclContainer(pParent) + , m_bHomogeneous(bHomogeneous) + , m_bVerticalContainer(false) + , m_nSpacing(nSpacing) + { + } + void set_spacing(int nSpacing) + { + m_nSpacing = nSpacing; + } + int get_spacing() const + { + return m_nSpacing; + } + void set_homogeneous(bool bHomogeneous) + { + m_bHomogeneous = bHomogeneous; + } + bool get_orientation() const + { + return m_bVerticalContainer; + } + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + virtual void DumpAsPropertyTree(tools::JsonWriter&) override; +protected: + virtual sal_uInt16 getDefaultAccessibleRole() const override; + void accumulateMaxes(const Size &rChildSize, Size &rSize) const; + Size finalizeMaxes(const Size &rSize, sal_uInt16 nVisibleChildren) const; + + virtual Size calculateRequisition() const override; + virtual void setAllocation(const Size &rAllocation) override; + + virtual tools::Long getPrimaryDimension(const Size &rSize) const = 0; + virtual void setPrimaryDimension(Size &rSize, tools::Long) const = 0; + virtual tools::Long getPrimaryCoordinate(const Point &rPos) const = 0; + virtual void setPrimaryCoordinate(Point &rPos, tools::Long) const = 0; + virtual tools::Long getSecondaryDimension(const Size &rSize) const = 0; + virtual void setSecondaryDimension(Size &rSize, tools::Long) const = 0; + + virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const = 0; +}; + +class VCL_DLLPUBLIC VclVBox : public VclBox +{ +public: + VclVBox(vcl::Window *pParent, bool bHomogeneous = false, int nSpacing = 0) + : VclBox(pParent, bHomogeneous, nSpacing) + { + m_bVerticalContainer = true; + } +protected: + virtual tools::Long getPrimaryDimension(const Size &rSize) const override + { + return rSize.getHeight(); + } + virtual void setPrimaryDimension(Size &rSize, tools::Long nHeight) const override + { + rSize.setHeight(nHeight); + } + virtual tools::Long getPrimaryCoordinate(const Point &rPos) const override + { + return rPos.getY(); + } + virtual void setPrimaryCoordinate(Point &rPos, tools::Long nPos) const override + { + rPos.setY(nPos); + } + virtual tools::Long getSecondaryDimension(const Size &rSize) const override + { + return rSize.getWidth(); + } + virtual void setSecondaryDimension(Size &rSize, tools::Long nWidth) const override + { + rSize.setWidth(nWidth); + } + virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const override + { + return rWindow.get_expand() || rWindow.get_vexpand(); + } +}; + +class VCL_DLLPUBLIC VclHBox : public VclBox +{ +public: + VclHBox(vcl::Window *pParent, bool bHomogeneous = false, int nSpacing = 0) + : VclBox(pParent, bHomogeneous, nSpacing) + { + m_bVerticalContainer = false; + } +protected: + virtual tools::Long getPrimaryDimension(const Size &rSize) const override + { + return rSize.getWidth(); + } + virtual void setPrimaryDimension(Size &rSize, tools::Long nWidth) const override + { + rSize.setWidth(nWidth); + } + virtual tools::Long getPrimaryCoordinate(const Point &rPos) const override + { + return rPos.getX(); + } + virtual void setPrimaryCoordinate(Point &rPos, tools::Long nPos) const override + { + rPos.setX(nPos); + } + virtual tools::Long getSecondaryDimension(const Size &rSize) const override + { + return rSize.getHeight(); + } + virtual void setSecondaryDimension(Size &rSize, tools::Long nHeight) const override + { + rSize.setHeight(nHeight); + } + virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const override + { + return rWindow.get_expand() || rWindow.get_hexpand(); + } +}; + +enum class VclButtonBoxStyle +{ + Default, + Spread, + Edge, + Start, + End, + Center +}; + +class VCL_DLLPUBLIC VclButtonBox : public VclBox +{ +public: + VclButtonBox(vcl::Window *pParent) + : VclBox(pParent, false, Application::GetSettings().GetStyleSettings().GetDialogStyle().button_spacing) + , m_eLayoutStyle(VclButtonBoxStyle::Default) + { + } + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + virtual void DumpAsPropertyTree(tools::JsonWriter&) override; +protected: + virtual Size calculateRequisition() const override; + virtual void setAllocation(const Size &rAllocation) override; + Size addSpacing(const Size &rSize, sal_uInt16 nVisibleChildren) const; +private: + VclButtonBoxStyle m_eLayoutStyle; + struct Requisition + { + std::vector<tools::Long> m_aMainGroupDimensions; + std::vector<tools::Long> m_aSubGroupDimensions; + Size m_aMainGroupSize; + Size m_aSubGroupSize; + }; + Requisition calculatePrimarySecondaryRequisitions() const; + Size addReqGroups(const VclButtonBox::Requisition &rReq) const; +}; + +class VCL_DLLPUBLIC VclVButtonBox : public VclButtonBox +{ +public: + VclVButtonBox(vcl::Window *pParent) + : VclButtonBox(pParent) + { + m_bVerticalContainer = true; + } +protected: + virtual tools::Long getPrimaryDimension(const Size &rSize) const override + { + return rSize.getHeight(); + } + virtual void setPrimaryDimension(Size &rSize, tools::Long nHeight) const override + { + rSize.setHeight(nHeight); + } + virtual tools::Long getPrimaryCoordinate(const Point &rPos) const override + { + return rPos.getY(); + } + virtual void setPrimaryCoordinate(Point &rPos, tools::Long nPos) const override + { + rPos.setY(nPos); + } + virtual tools::Long getSecondaryDimension(const Size &rSize) const override + { + return rSize.getWidth(); + } + virtual void setSecondaryDimension(Size &rSize, tools::Long nWidth) const override + { + rSize.setWidth(nWidth); + } + virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const override + { + return rWindow.get_expand() || rWindow.get_vexpand(); + } +}; + +class VCL_DLLPUBLIC VclHButtonBox final : public VclButtonBox +{ +public: + VclHButtonBox(vcl::Window *pParent) + : VclButtonBox(pParent) + { + m_bVerticalContainer = false; + } +private: + virtual tools::Long getPrimaryDimension(const Size &rSize) const override + { + return rSize.getWidth(); + } + virtual void setPrimaryDimension(Size &rSize, tools::Long nWidth) const override + { + rSize.setWidth(nWidth); + } + virtual tools::Long getPrimaryCoordinate(const Point &rPos) const override + { + return rPos.getX(); + } + virtual void setPrimaryCoordinate(Point &rPos, tools::Long nPos) const override + { + rPos.setX(nPos); + } + virtual tools::Long getSecondaryDimension(const Size &rSize) const override + { + return rSize.getHeight(); + } + virtual void setSecondaryDimension(Size &rSize, tools::Long nHeight) const override + { + rSize.setHeight(nHeight); + } + virtual bool getPrimaryDimensionChildExpand(const vcl::Window &rWindow) const override + { + return rWindow.get_expand() || rWindow.get_hexpand(); + } +}; + +class VCL_DLLPUBLIC VclGrid final : public VclContainer +{ +private: + bool m_bRowHomogeneous; + bool m_bColumnHomogeneous; + int m_nRowSpacing; + int m_nColumnSpacing; + +public: + struct Value + { + tools::Long m_nValue; + bool m_bExpand; + Value() : m_nValue(0), m_bExpand(false) {} + }; +private: + + Size calculateRequisitionForSpacings(sal_Int32 nRowSpacing, sal_Int32 nColSpacing) const; + virtual Size calculateRequisition() const override; + virtual void setAllocation(const Size &rAllocation) override; + virtual void DumpAsPropertyTree(tools::JsonWriter&) override; +public: + VclGrid(vcl::Window *pParent) + : VclContainer(pParent) + , m_bRowHomogeneous(false), m_bColumnHomogeneous(false) + , m_nRowSpacing(0), m_nColumnSpacing(0) + { + } + bool get_row_homogeneous() const + { + return m_bRowHomogeneous; + } + bool get_column_homogeneous() const + { + return m_bColumnHomogeneous; + } + void set_row_spacing(int nSpacing) + { + m_nRowSpacing = nSpacing; + } + void set_column_spacing(int nSpacing) + { + m_nColumnSpacing = nSpacing; + } + int get_row_spacing() const + { + return m_nRowSpacing; + } + int get_column_spacing() const + { + return m_nColumnSpacing; + } + virtual bool set_property(const OString &rKey, const OUString &rValue) override; +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) VclBin : public VclContainer +{ +public: + VclBin(vcl::Window *pParent, WinBits nStyle = WB_HIDE | WB_CLIPCHILDREN) + : VclContainer(pParent, nStyle) + { + } + virtual vcl::Window *get_child(); + virtual const vcl::Window *get_child() const; + virtual Size calculateRequisition() const override; + virtual void setAllocation(const Size &rAllocation) override; +}; + +class VclPaned : public VclContainer +{ +protected: + VclPtr<Splitter> m_pSplitter; + tools::Long m_nPosition; + + VclPaned(vcl::Window *pParent, bool bVertical); +public: + virtual ~VclPaned() override; + virtual void dispose() override; + tools::Long get_position() const { return m_nPosition; } + virtual void set_position(tools::Long nPosition) { m_nPosition = nPosition; } +}; + +class VclVPaned final : public VclPaned +{ +private: + DECL_LINK(SplitHdl, Splitter*, void); + void arrange(const Size& rAllocation, tools::Long nFirstHeight, tools::Long nSecondHeight); + +public: + VclVPaned(vcl::Window *pParent); + virtual ~VclVPaned() override; + virtual Size calculateRequisition() const override; + virtual void setAllocation(const Size &rAllocation) override; + virtual void set_position(tools::Long nPosition) override; +}; + +class VclHPaned final : public VclPaned +{ +private: + DECL_LINK(SplitHdl, Splitter*, void); + void arrange(const Size& rAllocation, tools::Long nFirstHeight, tools::Long nSecondHeight); + +public: + VclHPaned(vcl::Window *pParent); + virtual ~VclHPaned() override; + virtual Size calculateRequisition() const override; + virtual void setAllocation(const Size &rAllocation) override; + virtual void set_position(tools::Long nPosition) override; +}; + +class VclFrame final : public VclBin +{ +private: + VclPtr<vcl::Window> m_pLabel; +private: + friend class VclBuilder; + void designate_label(vcl::Window *pWindow); + DECL_LINK(WindowEventListener, VclWindowEvent&, void); +public: + VclFrame(vcl::Window *pParent) + : VclBin(pParent) + , m_pLabel(nullptr) + { + } + virtual ~VclFrame() override; + virtual void dispose() override; + void set_label(const OUString &rLabel); + OUString get_label() const; + virtual vcl::Window *get_child() override; + virtual const vcl::Window *get_child() const override; + vcl::Window *get_label_widget(); + const vcl::Window *get_label_widget() const; + virtual void DumpAsPropertyTree(tools::JsonWriter&) override; +private: + virtual Size calculateRequisition() const override; + virtual void setAllocation(const Size &rAllocation) override; + virtual OUString getDefaultAccessibleName() const override; +}; + +class DisclosureButton; +class CheckBox; + +class VclExpander final : public VclBin +{ +public: + VclExpander(vcl::Window *pParent); + virtual ~VclExpander() override; + virtual void dispose() override; + virtual vcl::Window *get_child() override; + virtual const vcl::Window *get_child() const override; + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + bool get_expanded() const; + void set_expanded(bool bExpanded); + void set_label(const OUString& rLabel); + OUString get_label() const; + vcl::Window *get_label_widget(); + const vcl::Window *get_label_widget() const; + virtual void StateChanged(StateChangedType nType) override; + void SetExpandedHdl( const Link<VclExpander&,void>& rLink ) { maExpandedHdl = rLink; } + virtual void DumpAsPropertyTree(tools::JsonWriter& rJsonWriter) override; + virtual FactoryFunction GetUITestFactory() const override; +private: + virtual Size calculateRequisition() const override; + virtual void setAllocation(const Size &rAllocation) override; + bool m_bResizeTopLevel; + VclPtr<DisclosureButton> m_pDisclosureButton; + Link<VclExpander&,void> maExpandedHdl; + DECL_LINK(ClickHdl, CheckBox&, void); +}; + +class VclScrolledWindow final : public VclBin +{ +public: + VclScrolledWindow(vcl::Window *pParent ); + virtual ~VclScrolledWindow() override; + virtual void dispose() override; + virtual vcl::Window *get_child() override; + virtual const vcl::Window *get_child() const override; + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override; + bool HasVisibleBorder() const { return m_eDrawFrameStyle != DrawFrameStyle::NONE; } + ScrollBar& getVertScrollBar() { return *m_pVScroll; } + ScrollBar& getHorzScrollBar() { return *m_pHScroll; } + Size getVisibleChildSize() const; + //set to true to disable the built-in scrolling callbacks to allow the user + //to override it + void setUserManagedScrolling(bool bUserManagedScrolling) { m_bUserManagedScrolling = bUserManagedScrolling;} + void doSetAllocation(const Size &rAllocation, bool bRetryOnFailure); +private: + virtual Size calculateRequisition() const override; + virtual void setAllocation(const Size &rAllocation) override; + int CalcBorderWidth() const; + DECL_LINK(ScrollBarHdl, ScrollBar*, void); + void InitScrollBars(const Size &rRequest); + virtual bool EventNotify(NotifyEvent& rNEvt) override; + bool m_bUserManagedScrolling; + tools::Long m_nBorderWidth; + DrawFrameStyle m_eDrawFrameStyle; + DrawFrameFlags m_eDrawFrameFlags; + VclPtr<ScrollBar> m_pVScroll; + VclPtr<ScrollBar> m_pHScroll; + VclPtr<ScrollBarBox> m_aScrollBarBox; +}; + +class VclViewport final : public VclBin +{ +public: + VclViewport(vcl::Window *pParent) + : VclBin(pParent, WB_HIDE | WB_CLIPCHILDREN) + , m_bInitialAllocation(true) + { + } +private: + virtual void setAllocation(const Size &rAllocation) override; + bool m_bInitialAllocation; +}; + +//Enforces that its children are always the same size as itself. +//Intercepts any Commands intended for its children. +// +//by default the Commands are discarded, inherit from this +//and implement "Command" to get them +class VclEventBox final : public VclBin +{ +private: + //Any Commands an EventBoxHelper receives are forwarded to its parent + //The VclEventBox ensures that m_aEventBoxHelper is the + //first child and is transparent, but covers the rest of the children + class EventBoxHelper final : public vcl::Window + { + public: + EventBoxHelper(vcl::Window* pParent) + : Window(pParent, 0) + { + SetSizePixel(pParent->GetSizePixel()); + EnableChildTransparentMode(); + SetPaintTransparent(true); + SetBackground(); + } + virtual void Command(const CommandEvent& rCEvt) override + { + GetParent()->Command(rCEvt); + } + }; + + VclPtr<EventBoxHelper> m_aEventBoxHelper; + virtual void dispose() override; + virtual ~VclEventBox() override; +public: + VclEventBox(vcl::Window* pParent) + : VclBin(pParent) + , m_aEventBoxHelper(VclPtr<EventBoxHelper>::Create(this)) + { + m_aEventBoxHelper->Show(); + } + virtual vcl::Window *get_child() override; + virtual const vcl::Window *get_child() const override; + virtual Size calculateRequisition() const override; + virtual void setAllocation(const Size &rAllocation) override; + + virtual void Command(const CommandEvent& rCEvt) override; +}; + +class VclSizeGroup +{ +private: + std::set< VclPtr<vcl::Window> > m_aWindows; + bool m_bIgnoreHidden; + VclSizeGroupMode m_eMode; + + void trigger_queue_resize(); +public: + VclSizeGroup() + : m_bIgnoreHidden(false) + , m_eMode(VclSizeGroupMode::Horizontal) + { + } + void insert(vcl::Window *pWindow) + { + m_aWindows.insert(VclPtr<vcl::Window>(pWindow)); + } + void erase(vcl::Window *pWindow) + { + m_aWindows.erase(VclPtr<vcl::Window>(pWindow)); + } + const std::set< VclPtr<vcl::Window> >& get_widgets() const + { + return m_aWindows; + } + std::set< VclPtr<vcl::Window> >& get_widgets() + { + return m_aWindows; + } + void set_ignore_hidden(bool bIgnoreHidden); + bool get_ignore_hidden() const + { + return m_bIgnoreHidden; + } + void set_mode(VclSizeGroupMode eMode); + VclSizeGroupMode get_mode() const + { + return m_eMode; + } + void set_property(const OString &rKey, const OUString &rValue); +}; + +class VCL_DLLPUBLIC VclDrawingArea final : public Control + , public DragSourceHelper +{ +private: + FactoryFunction m_pFactoryFunction; + void* m_pUserData; + rtl::Reference<TransferDataContainer> m_xTransferHelper; + sal_Int8 m_nDragAction; + Link<std::pair<vcl::RenderContext&, const tools::Rectangle&>, void> m_aPaintHdl; + Link<const Size&, void> m_aResizeHdl; + Link<const MouseEvent&, bool> m_aMousePressHdl; + Link<const MouseEvent&, bool> m_aMouseMotionHdl; + Link<const MouseEvent&, bool> m_aMouseReleaseHdl; + Link<const KeyEvent&, bool> m_aKeyPressHdl; + Link<const KeyEvent&, bool> m_aKeyReleaseHdl; + Link<VclDrawingArea&, void> m_aStyleUpdatedHdl; + Link<const CommandEvent&, bool> m_aCommandHdl; + Link<tools::Rectangle&, OUString> m_aQueryTooltipHdl; + Link<OUString&, int> m_aGetSurroundingHdl; + Link<const Selection&, bool> m_aDeleteSurroundingHdl; + Link<VclDrawingArea*, bool> m_aStartDragHdl; + + virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override + { + m_aPaintHdl.Call(std::pair<vcl::RenderContext&, const tools::Rectangle&>(rRenderContext, rRect)); + } + virtual void Resize() override + { + m_aResizeHdl.Call(GetOutputSizePixel()); + } + virtual void MouseMove(const MouseEvent& rMEvt) override + { + if (!m_aMouseMotionHdl.Call(rMEvt)) + Control::MouseMove(rMEvt); + } + virtual void KeyInput(const KeyEvent& rKEvt) override + { + if (!m_aKeyPressHdl.Call(rKEvt)) + Control::KeyInput(rKEvt); + + } + virtual void KeyUp(const KeyEvent& rKEvt) override + { + if (!m_aKeyReleaseHdl.Call(rKEvt)) + Control::KeyUp(rKEvt); + } + virtual void StateChanged(StateChangedType nType) override + { + Control::StateChanged(nType); + if (nType == StateChangedType::ControlForeground || nType == StateChangedType::ControlBackground) + { + m_aStyleUpdatedHdl.Call(*this); + Invalidate(); + } + } + virtual void DataChanged(const DataChangedEvent& rDCEvt) override + { + Control::DataChanged(rDCEvt); + if ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) && (rDCEvt.GetFlags() & AllSettingsFlags::STYLE)) + { + m_aStyleUpdatedHdl.Call(*this); + Invalidate(); + } + } + virtual void Command(const CommandEvent& rEvent) override + { + if (m_aCommandHdl.Call(rEvent)) + return; + Control::Command(rEvent); + } + virtual void RequestHelp(const HelpEvent& rHelpEvent) override; + virtual void StartDrag(sal_Int8 nAction, const Point& rPosPixel) override; + virtual FactoryFunction GetUITestFactory() const override; + +public: + VclDrawingArea(vcl::Window *pParent, WinBits nStyle) + : Control(pParent, nStyle) + , DragSourceHelper(this) + , m_pFactoryFunction(nullptr) + , m_pUserData(nullptr) + , m_nDragAction(0) + { + SetBackground(); + } + virtual void MouseButtonDown(const MouseEvent& rMEvt) override + { + if (!m_aMousePressHdl.Call(rMEvt)) + Control::MouseButtonDown(rMEvt); + } + virtual void MouseButtonUp(const MouseEvent& rMEvt) override + { + if (!m_aMouseReleaseHdl.Call(rMEvt)) + Control::MouseButtonUp(rMEvt); + } + virtual OUString GetSurroundingText() const override; + virtual Selection GetSurroundingTextSelection() const override; + virtual bool DeleteSurroundingText(const Selection& rSelection) override; + void SetUITestFactory(FactoryFunction pFactoryFunction, void* pUserData) + { + m_pFactoryFunction = pFactoryFunction; + m_pUserData = pUserData; + } + void* GetUserData() const + { + return m_pUserData; + } + void SetPaintHdl(const Link<std::pair<vcl::RenderContext&, const tools::Rectangle&>, void>& rLink) + { + m_aPaintHdl = rLink; + } + void SetResizeHdl(const Link<const Size&, void>& rLink) + { + m_aResizeHdl = rLink; + } + void SetMousePressHdl(const Link<const MouseEvent&, bool>& rLink) + { + m_aMousePressHdl = rLink; + } + void SetMouseMoveHdl(const Link<const MouseEvent&, bool>& rLink) + { + m_aMouseMotionHdl = rLink; + } + void SetMouseReleaseHdl(const Link<const MouseEvent&, bool>& rLink) + { + m_aMouseReleaseHdl = rLink; + } + void SetKeyPressHdl(const Link<const KeyEvent&, bool>& rLink) + { + m_aKeyPressHdl = rLink; + } + void SetKeyReleaseHdl(const Link<const KeyEvent&, bool>& rLink) + { + m_aKeyReleaseHdl = rLink; + } + void SetStyleUpdatedHdl(const Link<VclDrawingArea&, void>& rLink) + { + m_aStyleUpdatedHdl = rLink; + } + void SetCommandHdl(const Link<const CommandEvent&, bool>& rLink) + { + m_aCommandHdl = rLink; + } + void SetQueryTooltipHdl(const Link<tools::Rectangle&, OUString>& rLink) + { + m_aQueryTooltipHdl = rLink; + } + void SetGetSurroundingHdl(const Link<OUString&, int>& rLink) + { + m_aGetSurroundingHdl = rLink; + } + void SetDeleteSurroundingHdl(const Link<const Selection&, bool>& rLink) + { + m_aDeleteSurroundingHdl = rLink; + } + void SetStartDragHdl(const Link<VclDrawingArea*, bool>& rLink) + { + m_aStartDragHdl = rLink; + } + void SetDragHelper(const rtl::Reference<TransferDataContainer>& rHelper, sal_uInt8 eDNDConstants) + { + m_xTransferHelper = rHelper; + m_nDragAction = eDNDConstants; + } + virtual void DumpAsPropertyTree(tools::JsonWriter&) override; +}; + +//Get first window of a pTopLevel window as +//if any intermediate layout widgets didn't exist +//i.e. acts like pChild = pChild->GetWindow(GetWindowType::FirstChild); +//in a flat hierarchy where dialogs only have one layer +//of children +vcl::Window* firstLogicalChildOfParent(const vcl::Window *pTopLevel); + +//Get last window of a pTopLevel window as +//if any intermediate layout widgets didn't exist +//i.e. acts like pChild = pChild->GetWindow(GetWindowType::LastChild); +//in a flat hierarchy where dialogs only have one layer +//of children +vcl::Window* lastLogicalChildOfParent(const vcl::Window *pTopLevel); + +//Get next window after pChild of a pTopLevel window as +//if any intermediate layout widgets didn't exist +//i.e. acts like pChild = pChild->GetWindow(GetWindowType::Next); +//in a flat hierarchy where dialogs only have one layer +//of children +vcl::Window* nextLogicalChildOfParent(const vcl::Window *pTopLevel, const vcl::Window *pChild); + +//Get previous window before pChild of a pTopLevel window as +//if any intermediate layout widgets didn't exist +//i.e. acts like pChild = pChild->GetWindow(GetWindowType::Prev); +//in a flat hierarchy where dialogs only have one layer +//of children +vcl::Window* prevLogicalChildOfParent(const vcl::Window *pTopLevel, const vcl::Window *pChild); + +//Returns true is the Window has a single child which is a container +VCL_DLLPUBLIC bool isLayoutEnabled(const vcl::Window *pWindow); + +inline bool isContainerWindow(const vcl::Window &rWindow) +{ + WindowType eType = rWindow.GetType(); + return eType == WindowType::CONTAINER || eType == WindowType::SCROLLWINDOW || + (eType == WindowType::DOCKINGWINDOW && ::isLayoutEnabled(&rWindow)); +} + +inline bool isContainerWindow(const vcl::Window *pWindow) +{ + return pWindow && isContainerWindow(*pWindow); +} + +// retro-fitting utilities + +//Get a Size which is large enough to contain all children with +//an equal amount of space at top left and bottom right +Size getLegacyBestSizeForChildren(const vcl::Window &rWindow); + +//Get first parent which is not a layout widget +vcl::Window* getNonLayoutParent(vcl::Window *pParent); + +//Sort ok/cancel etc buttons in platform order +void sort_native_button_order(const VclBox& rContainer); + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/lazydelete.hxx b/include/vcl/lazydelete.hxx new file mode 100644 index 000000000..397bde883 --- /dev/null +++ b/include/vcl/lazydelete.hxx @@ -0,0 +1,138 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_LAZYDELETE_HXX +#define INCLUDED_VCL_LAZYDELETE_HXX + +#include <vcl/dllapi.h> + +#include <com/sun/star/lang/XComponent.hpp> + +#include <optional> + +namespace vcl +{ + /* + You may not access vcl objects after DeInitVCL has been called this includes their destruction + therefore disallowing the existence of static vcl object like e.g. a static BitmapEx + To work around this use DeleteOnDeinit<BitmapEx> which will allow you to have a static object container, + that will have its contents destroyed on DeinitVCL. The single drawback is that you need to check on the + container object whether it still contains content before actually accessing it. + + caveat: when constructing a vcl object, you certainly want to ensure that InitVCL has run already. + However this is not necessarily the case when using a class static member or a file level static variable. + In these cases make judicious use of the set() method of DeleteOnDeinit, but beware of the changing + ownership. + + example use case: use a lazy initialized on call BitmapEx in a paint method. Of course a paint method + would not normally be called after DeInitVCL anyway, so the check might not be necessary in a + Window::Paint implementation, but always checking is a good idea. + + SomeWindow::Paint() + { + static vcl::DeleteOnDeinit< BitmapEx > aBmp( new BitmapEx( ... ) ); + + if( aBmp.get() ) // check whether DeInitVCL has been called already + DrawBitmapEx( Point( 10, 10 ), *aBmp ); + } + */ + + class VCL_DLLPUBLIC DeleteOnDeinitBase + { + public: + static void SAL_DLLPRIVATE ImplDeleteOnDeInit(); + virtual ~DeleteOnDeinitBase(); + protected: + static void addDeinitContainer( DeleteOnDeinitBase* i_pContainer ); + + virtual void doCleanup() = 0; + }; + + enum class DeleteOnDeinitFlag { Empty }; + + template < typename T > + class DeleteOnDeinit final : public DeleteOnDeinitBase + { + std::optional<T> m_pT; + virtual void doCleanup() override { m_pT.reset(); } + public: + template <class... Args > + DeleteOnDeinit(Args&&... args ) + { + m_pT.emplace(args...); + addDeinitContainer( this ); + } + DeleteOnDeinit(DeleteOnDeinitFlag) + { + addDeinitContainer( this ); + } + + // get contents + T* get() { return m_pT ? &*m_pT : nullptr; } + + // set contents, returning old contents + // ownership is transferred ! + template <class... Args > + std::optional<T> set(Args&&... args) + { + auto pOld = std::move(m_pT); + m_pT.emplace(args...); + return pOld; + } + }; + + /** Similar to DeleteOnDeinit, the DeleteUnoReferenceOnDeinit + template class makes sure that a static UNO object is disposed + and released at the right time. + + Use like + static DeleteUnoReferenceOnDeinit<lang::XMultiServiceFactory> + xStaticFactory (\<create factory object>); + Reference<lang::XMultiServiceFactory> xFactory (xStaticFactory.get()); + if (xFactory.is()) + \<do something with xFactory> + */ + template <typename I> + class DeleteUnoReferenceOnDeinit final : public vcl::DeleteOnDeinitBase + { + css::uno::Reference<I> m_xI; + virtual void doCleanup() override { set(nullptr); } + public: + DeleteUnoReferenceOnDeinit(const css::uno::Reference<I>& r_xI ) : m_xI( r_xI ) { + addDeinitContainer( this ); } + + css::uno::Reference<I> get() { return m_xI; } + + void set (const css::uno::Reference<I>& r_xNew ) + { + css::uno::Reference< css::lang::XComponent> xComponent (m_xI, css::uno::UNO_QUERY); + m_xI = r_xNew; + if (xComponent.is()) try + { + xComponent->dispose(); + } + catch( css::uno::Exception& ) + { + } + } + }; +} + +#endif +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/lineinfo.hxx b/include/vcl/lineinfo.hxx new file mode 100644 index 000000000..064435995 --- /dev/null +++ b/include/vcl/lineinfo.hxx @@ -0,0 +1,119 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_LINEINFO_HXX +#define INCLUDED_VCL_LINEINFO_HXX + +#include <sal/types.h> +#include <vcl/dllapi.h> +#include <vcl/vclenum.hxx> +#include <basegfx/vector/b2enums.hxx> +#include <com/sun/star/drawing/LineCap.hpp> +#include <o3tl/cow_wrapper.hxx> + +#include <vector> + +class SvStream; +namespace basegfx { class B2DPolyPolygon; } + +struct ImplLineInfo +{ + double mnWidth; + double mnDashLen; + double mnDotLen; + double mnDistance; + + basegfx::B2DLineJoin meLineJoin; + css::drawing::LineCap meLineCap; + LineStyle meStyle; + + sal_uInt16 mnDashCount; + sal_uInt16 mnDotCount; + + ImplLineInfo(); + + bool operator==( const ImplLineInfo& ) const; +}; + + +class VCL_DLLPUBLIC LineInfo +{ +public: + LineInfo( LineStyle eLineStyle = LineStyle::Solid, double nWidth = 0 ); + LineInfo( const LineInfo& rLineInfo ); + LineInfo( LineInfo&& rLineInfo ); + ~LineInfo(); + + LineInfo& operator=( const LineInfo& rLineInfo ); + LineInfo& operator=( LineInfo&& rLineInfo ); + bool operator==( const LineInfo& rLineInfo ) const; + bool operator!=( const LineInfo& rLineInfo ) const { return !(LineInfo::operator==( rLineInfo ) ); } + + void SetStyle( LineStyle eStyle ); + LineStyle GetStyle() const { return mpImplLineInfo->meStyle; } + + void SetWidth( double nWidth ); + double GetWidth() const { return mpImplLineInfo->mnWidth; } + + void SetDashCount( sal_uInt16 nDashCount ); + sal_uInt16 GetDashCount() const { return mpImplLineInfo->mnDashCount; } + + void SetDashLen( double nDashLen ); + double GetDashLen() const { return mpImplLineInfo->mnDashLen; } + + void SetDotCount( sal_uInt16 nDotCount ); + sal_uInt16 GetDotCount() const { return mpImplLineInfo->mnDotCount; } + + void SetDotLen( double nDotLen ); + double GetDotLen() const { return mpImplLineInfo->mnDotLen; } + + void SetDistance( double nDistance ); + double GetDistance() const { return mpImplLineInfo->mnDistance; } + + /// Get an array of "on" and "off" lengths for stroke dashing + std::vector< double > GetDotDashArray() const; + + void SetLineJoin(basegfx::B2DLineJoin eLineJoin); + basegfx::B2DLineJoin GetLineJoin() const { return mpImplLineInfo->meLineJoin; } + + void SetLineCap(css::drawing::LineCap eLineCap); + css::drawing::LineCap GetLineCap() const { return mpImplLineInfo->meLineCap; } + + bool IsDefault() const; + + friend SvStream& ReadLineInfo( SvStream& rIStm, LineInfo& rLineInfo ); + friend SvStream& WriteLineInfo( SvStream& rOStm, const LineInfo& rLineInfo ); + + // helper to get decomposed polygon data with the LineInfo applied. The source + // hairline polygon is given in io_rLinePolyPolygon. Both given polygons may + // contain results; e.g. when no fat line but DashDot is defined, the result will + // be in io_rLinePolyPolygon while o_rFillPolyPolygon will be empty. When fat line + // is defined, it will be vice-versa. If none is defined, io_rLinePolyPolygon will + // not be changed (but o_rFillPolyPolygon will be freed) + void applyToB2DPolyPolygon( + basegfx::B2DPolyPolygon& io_rLinePolyPolygon, + basegfx::B2DPolyPolygon& o_rFillPolyPolygon) const; + +private: + o3tl::cow_wrapper< ImplLineInfo > mpImplLineInfo; +}; + +#endif // INCLUDED_VCL_LINEINFO_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/locktoplevels.hxx b/include/vcl/locktoplevels.hxx new file mode 100644 index 000000000..9d0bf5f39 --- /dev/null +++ b/include/vcl/locktoplevels.hxx @@ -0,0 +1,38 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#pragma once + +#include <vcl/dllapi.h> +#include <memory> + +namespace weld +{ +class Widget; +} + +struct TopLevelWindowLockerImpl; + +class VCL_DLLPUBLIC TopLevelWindowLocker +{ +private: + std::unique_ptr<TopLevelWindowLockerImpl> m_xImpl; + +public: + TopLevelWindowLocker(); + ~TopLevelWindowLocker(); + + // lock all toplevels, except the argument + void incBusy(const weld::Widget* pIgnore); + // unlock previous lock + void decBusy(); + bool isBusy() const; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/lok.hxx b/include/vcl/lok.hxx new file mode 100644 index 000000000..108f46def --- /dev/null +++ b/include/vcl/lok.hxx @@ -0,0 +1,31 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#ifndef INCLUDED_VCL_LOK_HXX +#define INCLUDED_VCL_LOK_HXX + +#include <sal/config.h> +#include <vcl/dllapi.h> +#include <LibreOfficeKit/LibreOfficeKitTypes.h> + +namespace vcl::lok +{ +bool VCL_DLLPUBLIC isUnipoll(); +void VCL_DLLPUBLIC registerPollCallbacks(LibreOfficeKitPollCallback pPollCallback, + LibreOfficeKitWakeCallback pWakeCallback, void* pData); +void VCL_DLLPUBLIC unregisterPollCallbacks(); + +// Called to tell VCL that the number of document views has changed, so that VCL +// can adjust e.g. sizes of bitmap caches to scale well with larger number of users. +void VCL_DLLPUBLIC numberOfViewsChanged(int count); +} + +#endif // INCLUDE_VCL_LOK_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/mapmod.hxx b/include/vcl/mapmod.hxx new file mode 100644 index 000000000..f3c937a5f --- /dev/null +++ b/include/vcl/mapmod.hxx @@ -0,0 +1,93 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_MAPMOD_HXX +#define INCLUDED_VCL_MAPMOD_HXX + +#include <vcl/dllapi.h> +#include <tools/mapunit.hxx> +#include <o3tl/cow_wrapper.hxx> + +#include <ostream> + +class Point; +class Fraction; +class SvStream; + +class SAL_WARN_UNUSED VCL_DLLPUBLIC MapMode +{ + friend class OutputDevice; + +public: + struct SAL_DLLPRIVATE ImplMapMode; + + MapMode(); + MapMode( const MapMode& rMapMode ); + explicit MapMode( MapUnit eUnit ); + MapMode( MapUnit eUnit, const Point& rLogicOrg, + const Fraction& rScaleX, const Fraction& rScaleY ); + ~MapMode(); + + void SetMapUnit( MapUnit eUnit ); + MapUnit GetMapUnit() const; + + void SetOrigin( const Point& rOrigin ); + const Point& GetOrigin() const; + + void SetScaleX( const Fraction& rScaleX ); + const Fraction& GetScaleX() const; + void SetScaleY( const Fraction& rScaleY ); + const Fraction& GetScaleY() const; + + MapMode& operator=( const MapMode& rMapMode ); + MapMode& operator=( MapMode&& rMapMode ); + bool operator==( const MapMode& rMapMode ) const; + bool operator!=( const MapMode& rMapMode ) const + { + return !(MapMode::operator==( rMapMode )); + } + bool IsDefault() const; + + // Compute value usable as hash. + size_t GetHashValue() const; + + // tdf#117984 needs to be thread-safe due to being used e.g. in Bitmaps + // vcl::ScopedBitmapAccess in parallelized 3D renderer + typedef o3tl::cow_wrapper< ImplMapMode, o3tl::ThreadSafeRefCountingPolicy > ImplType; + + // If only the map unit is set. + bool IsSimple() const; + +private: + ImplType mpImplMapMode; +}; + +template<typename charT, typename traits> +inline std::basic_ostream<charT, traits> & operator <<( + std::basic_ostream<charT, traits> & rStream, const MapMode& rMode) +{ + rStream << "MapMode(" << static_cast<unsigned>(rMode.GetMapUnit()) << ",(" << rMode.GetScaleX() << "," << rMode.GetScaleY() << ")@(" << rMode.GetOrigin() << "))"; + return rStream; +} + +bool TooLargeScaleForMapMode(const Fraction& rScale, int nDPI); + +#endif // INCLUDED_VCL_MAPMOD_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/menu.hxx b/include/vcl/menu.hxx new file mode 100644 index 000000000..54df7ee66 --- /dev/null +++ b/include/vcl/menu.hxx @@ -0,0 +1,539 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_MENU_HXX +#define INCLUDED_VCL_MENU_HXX + +#include <memory> +#include <string_view> + +#include <vcl/vclenum.hxx> +#include <tools/link.hxx> +#include <tools/long.hxx> +#include <vcl/dllapi.h> +#include <vcl/keycod.hxx> +#include <vcl/vclptr.hxx> +#include <vcl/vclreferencebase.hxx> +#include <com/sun/star/uno/Reference.hxx> +#include <o3tl/typed_flags_set.hxx> +#include <list> + +class OutputDevice; +struct ImplSVEvent; +struct MenuItemData; +class Point; +class Size; +namespace tools { class Rectangle; } +class Menu; +class MenuItemList; +class Image; +class PopupMenu; +class KeyEvent; +class MenuFloatingWindow; +class SalMenu; +class MenuBarWindow; +class VclMenuEvent; +struct SystemMenuData; +enum class FloatWinPopupFlags; +enum class VclEventId; + +namespace com::sun::star::awt { class XPopupMenu; } +namespace com::sun::star::accessibility { class XAccessible; } + +namespace vcl +{ +class Window; +struct MenuLayoutData; +typedef OutputDevice RenderContext; // same as in include/vcl/outdev.hxx +class ILibreOfficeKitNotifier; +} + +constexpr sal_uInt16 MENU_APPEND = 0xFFFF; +constexpr sal_uInt16 MENU_ITEM_NOTFOUND = 0xFFFF; + +// Must match the definitions in css::awt::PopupMenuDirection.idl +enum class PopupMenuFlags +{ + NONE = 0x0000, + ExecuteDown = 0x0001, + ExecuteUp = 0x0002, + ExecuteRight = 0x0008, + NoMouseUpClose = 0x0010, +}; + +namespace o3tl +{ + template<> struct typed_flags<PopupMenuFlags> : is_typed_flags<PopupMenuFlags, 0x001b> {}; +} + +enum class MenuFlags +{ + NONE = 0x0000, + NoAutoMnemonics = 0x0001, + HideDisabledEntries = 0x0002, + // overrides default hiding of disabled entries in popup menus + AlwaysShowDisabledEntries = 0x0004, +}; + +namespace o3tl +{ + template<> struct typed_flags<MenuFlags> : is_typed_flags<MenuFlags, 0x0007> {}; +} + +/// Invalid menu item id +constexpr auto ITEMPOS_INVALID = 0xFFFF; + +struct ImplMenuDelData +{ + ImplMenuDelData* mpNext; + VclPtr<const Menu> mpMenu; + + explicit ImplMenuDelData( const Menu* ); + ~ImplMenuDelData(); + + bool isDeleted() const { return mpMenu == nullptr; } +}; + +typedef void (*MenuUserDataReleaseFunction)(void*); + +class VCL_DLLPUBLIC Menu : public VclReferenceBase +{ + friend class MenuBar; + friend class MenuBarWindow; + friend class MenuButton; + friend class MenuFloatingWindow; + friend class PopupMenu; + friend class SystemWindow; + friend struct ImplMenuDelData; +private: + ImplMenuDelData* mpFirstDel; + std::unique_ptr<MenuItemList> pItemList; // list with MenuItems + VclPtr<Menu> pStartedFrom; + VclPtr<vcl::Window> pWindow; + + Link<Menu*, bool> aActivateHdl; // Active-Handler + Link<Menu*, bool> aDeactivateHdl; // Deactivate-Handler + Link<Menu*, bool> aSelectHdl; // Select-Handler + + std::list<Link<VclMenuEvent&,void> > maEventListeners; + + OUString maID; + + OUString aTitleText; // PopupMenu text + sal_uInt16 nTitleHeight; + + ImplSVEvent* nEventId; + sal_uInt16 mnHighlightedItemPos; // for native menus: keeps track of the highlighted item + MenuFlags nMenuFlags; + sal_uInt16 nSelectedId; + OString sSelectedIdent; + + // for output: + sal_uInt16 nImgOrChkPos; + sal_uInt16 nTextPos; + + bool bCanceled : 1; ///< Terminated during a callback + bool bInCallback : 1; ///< In Activate/Deactivate + bool bKilled : 1; ///< Killed + + css::uno::Reference<css::accessibility::XAccessible > mxAccessible; + mutable std::unique_ptr<vcl::MenuLayoutData> mpLayoutData; + std::unique_ptr<SalMenu> mpSalMenu; + +protected: + SAL_DLLPRIVATE Menu* ImplGetStartMenu(); + SAL_DLLPRIVATE Menu* ImplFindSelectMenu(); + SAL_DLLPRIVATE Menu* ImplFindMenu( sal_uInt16 nId ); + SAL_DLLPRIVATE Size ImplCalcSize( vcl::Window* pWin ); + SAL_DLLPRIVATE bool ImplIsVisible( sal_uInt16 nPos ) const; + SAL_DLLPRIVATE bool ImplCurrentlyHiddenOnGUI(sal_uInt16 nPos) const; + SAL_DLLPRIVATE bool ImplIsSelectable( sal_uInt16 nPos ) const; + SAL_DLLPRIVATE sal_uInt16 ImplGetVisibleItemCount() const; + SAL_DLLPRIVATE sal_uInt16 ImplGetFirstVisible() const; + SAL_DLLPRIVATE sal_uInt16 ImplGetPrevVisible( sal_uInt16 nPos ) const; + SAL_DLLPRIVATE sal_uInt16 ImplGetNextVisible( sal_uInt16 nPos ) const; + SAL_DLLPRIVATE void ImplPaint(vcl::RenderContext& rRenderContext, Size const & rSize, + sal_uInt16 nBorder, tools::Long nOffY = 0, MenuItemData const * pThisDataOnly = nullptr, + bool bHighlighted = false, bool bLayout = false, bool bRollover = false ) const; + SAL_DLLPRIVATE void ImplPaintMenuTitle(vcl::RenderContext&, const tools::Rectangle& rRect) const; + SAL_DLLPRIVATE void ImplSelect(); + SAL_DLLPRIVATE void ImplCallHighlight( sal_uInt16 nHighlightItem ); + SAL_DLLPRIVATE void ImplCallEventListeners( VclEventId nEvent, sal_uInt16 nPos ); + DECL_DLLPRIVATE_LINK(ImplCallSelect, void*, void ); + + SAL_DLLPRIVATE void ImplFillLayoutData() const; + SAL_DLLPRIVATE SalMenu* ImplGetSalMenu() { return mpSalMenu.get(); } + SAL_DLLPRIVATE OUString ImplGetHelpText( sal_uInt16 nItemId ) const; + + // returns native check and option menu symbol height in rCheckHeight and rRadioHeight + // return value is maximum width and height of checkboxes and radiobuttons + SAL_DLLPRIVATE Size ImplGetNativeCheckAndRadioSize(vcl::RenderContext const & rRenderContext, tools::Long& rCheckHeight, tools::Long& rRadioHeight) const; + + // returns native submenu arrow size and spacing from right border + // return value is whether it's supported natively + SAL_DLLPRIVATE static bool ImplGetNativeSubmenuArrowSize(vcl::RenderContext const & rRenderContext, Size& rArrowSize, tools::Long& rArrowSpacing); + + SAL_DLLPRIVATE void ImplAddDel( ImplMenuDelData &rDel ); + SAL_DLLPRIVATE void ImplRemoveDel( ImplMenuDelData &rDel ); + + SAL_DLLPRIVATE MenuItemData* NbcInsertItem(sal_uInt16 nId, MenuItemBits nBits, + const OUString& rStr, Menu* pMenu, + size_t nPos, const OString &rIdent); + + /// Close the 'pStartedFrom' menu window. + virtual void ClosePopup(Menu* pMenu) = 0; + + /// Forward the KeyInput call to the MenuBar. + virtual void MenuBarKeyInput(const KeyEvent& rEvent); + +public: + SAL_DLLPRIVATE void ImplKillLayoutData() const; + + SAL_DLLPRIVATE vcl::Window* ImplGetWindow() const { return pWindow; } +#if defined(MACOSX) + void ImplSelectWithStart( Menu* pStartMenu = nullptr ); +#endif + +protected: + + /** The Menu constructor is protected. + + The callers are supposed to instantiate either PopupMenu or MenuBar, but + not a Menu directly. + */ + Menu(); + +public: + virtual ~Menu() override; + virtual void dispose() override; + + void Activate(); + void Deactivate(); + void Select(); + + void InsertItem(sal_uInt16 nItemId, const OUString& rStr, + MenuItemBits nItemBits = MenuItemBits::NONE, + const OString &rIdent = OString(), + sal_uInt16 nPos = MENU_APPEND); + void InsertItem(sal_uInt16 nItemId, const Image& rImage, + MenuItemBits nItemBits = MenuItemBits::NONE, + const OString &rIdent = OString(), + sal_uInt16 nPos = MENU_APPEND); + void InsertItem(sal_uInt16 nItemId, + const OUString& rString, const Image& rImage, + MenuItemBits nItemBits = MenuItemBits::NONE, + const OString &rIdent = OString(), + sal_uInt16 nPos = MENU_APPEND); + void InsertSeparator(const OString &rIdent = OString(), sal_uInt16 nPos = MENU_APPEND); + void RemoveItem( sal_uInt16 nPos ); + void Clear(); + + void CreateAutoMnemonics(); + + void SetMenuFlags( MenuFlags nFlags ) { nMenuFlags = nFlags; } + MenuFlags GetMenuFlags() const { return nMenuFlags; } + + sal_uInt16 GetItemCount() const; + sal_uInt16 GetItemId(sal_uInt16 nPos) const; + sal_uInt16 GetItemId(std::string_view rIdent) const; + sal_uInt16 GetItemPos( sal_uInt16 nItemId ) const; + OString GetItemIdent(sal_uInt16 nItemId) const; + MenuItemType GetItemType( sal_uInt16 nPos ) const; + sal_uInt16 GetCurItemId() const { return nSelectedId;} + OString const & GetCurItemIdent() const { return sSelectedIdent; } + void SetItemBits( sal_uInt16 nItemId, MenuItemBits nBits ); + MenuItemBits GetItemBits( sal_uInt16 nItemId ) const; + + void SetUserValue(sal_uInt16 nItemId, void* nUserValue, MenuUserDataReleaseFunction aFunc=nullptr); + void* GetUserValue(sal_uInt16 nItemId) const; + + void SetPopupMenu( sal_uInt16 nItemId, PopupMenu* pMenu ); + PopupMenu* GetPopupMenu( sal_uInt16 nItemId ) const; + + void SetAccelKey( sal_uInt16 nItemId, const vcl::KeyCode& rKeyCode ); + vcl::KeyCode GetAccelKey( sal_uInt16 nItemId ) const; + + void CheckItem( sal_uInt16 nItemId, bool bCheck = true ); + void CheckItem( std::string_view rIdent, bool bCheck = true ); + bool IsItemChecked( sal_uInt16 nItemId ) const; + + virtual void SelectItem(sal_uInt16 nItemId) = 0; + + void EnableItem( sal_uInt16 nItemId, bool bEnable = true ); + void EnableItem(std::string_view rIdent, bool bEnable = true) + { + EnableItem(GetItemId(rIdent), bEnable); + } + bool IsItemEnabled( sal_uInt16 nItemId ) const; + + void ShowItem( sal_uInt16 nItemId, bool bVisible = true ); + void HideItem( sal_uInt16 nItemId ) { ShowItem( nItemId, false ); } + + bool IsItemPosVisible( sal_uInt16 nItemPos ) const; + bool IsMenuVisible() const; + virtual bool IsMenuBar() const = 0; + + void RemoveDisabledEntries( bool bRemoveEmptyPopups = false ); + + void UpdateNativeMenu(); + + void SetItemText( sal_uInt16 nItemId, const OUString& rStr ); + OUString GetItemText( sal_uInt16 nItemId ) const; + + void SetItemImage( sal_uInt16 nItemId, const Image& rImage ); + Image GetItemImage( sal_uInt16 nItemId ) const; + + void SetItemCommand( sal_uInt16 nItemId, const OUString& rCommand ); + OUString GetItemCommand( sal_uInt16 nItemId ) const; + + void SetHelpText( sal_uInt16 nItemId, const OUString& rString ); + OUString GetHelpText( sal_uInt16 nItemId ) const; + + void SetTipHelpText( sal_uInt16 nItemId, const OUString& rString ); + OUString GetTipHelpText( sal_uInt16 nItemId ) const; + + void SetHelpCommand( sal_uInt16 nItemId, const OUString& rString ); + OUString GetHelpCommand( sal_uInt16 nItemId ) const; + + void SetHelpId( sal_uInt16 nItemId, const OString& rHelpId ); + OString GetHelpId( sal_uInt16 nItemId ) const; + + void SetActivateHdl( const Link<Menu *, bool>& rLink ) + { + aActivateHdl = rLink; + } + + void SetDeactivateHdl( const Link<Menu *, bool>& rLink ) + { + aDeactivateHdl = rLink; + } + + void SetSelectHdl( const Link<Menu*,bool>& rLink ) + { + aSelectHdl = rLink; + } + + sal_uInt16 GetTitleHeight() const + { + return nTitleHeight; + } + + void AddEventListener( const Link<VclMenuEvent&,void>& rEventListener ); + void RemoveEventListener( const Link<VclMenuEvent&,void>& rEventListener ); + + Menu& operator =( const Menu& rMenu ); + + // for menu functions + MenuItemList* GetItemList() const + { + return pItemList.get(); + } + + // returns the system's menu handle if native menus are supported + // pData must point to a SystemMenuData structure + void GetSystemMenuData( SystemMenuData* pData ) const; + + // accessibility helpers + + // returns the bounding box for the character at index nIndex + // where nIndex is relative to the starting index of the item + // with id nItemId (in coordinates of the displaying window) + tools::Rectangle GetCharacterBounds( sal_uInt16 nItemId, tools::Long nIndex ) const; + // -1 is returned if no character is at that point + // if an index is found the corresponding item id is filled in (else 0) + tools::Long GetIndexForPoint( const Point& rPoint, sal_uInt16& rItemID ) const; + // returns the bounding rectangle for an item at pos nItemPos + tools::Rectangle GetBoundingRectangle( sal_uInt16 nItemPos ) const; + + css::uno::Reference<css::accessibility::XAccessible> GetAccessible(); + void SetAccessible(const css::uno::Reference<css::accessibility::XAccessible >& rxAccessible); + + // gets the activation key of the specified item + KeyEvent GetActivationKey( sal_uInt16 nItemId ) const; + + vcl::Window* GetWindow() const { return pWindow; } + + void SetAccessibleName( sal_uInt16 nItemId, const OUString& rStr ); + OUString GetAccessibleName( sal_uInt16 nItemId ) const; + + void SetAccessibleDescription( sal_uInt16 nItemId, const OUString& rStr ); + OUString GetAccessibleDescription( sal_uInt16 nItemId ) const; + + // returns whether the item a position nItemPos is highlighted or not. + bool IsHighlighted( sal_uInt16 nItemPos ) const; + + void HighlightItem( sal_uInt16 nItemPos ); + void DeHighlight() { HighlightItem( 0xFFFF ); } // MENUITEMPOS_INVALID + + bool HandleMenuCommandEvent(Menu *pMenu, sal_uInt16 nEventId) const; + bool HandleMenuActivateEvent(Menu *pMenu) const; + bool HandleMenuDeActivateEvent(Menu *pMenu) const; + + /** + * Sets an ID. + */ + void set_id(const OUString& rID) { maID = rID; } + + /** + * Get the ID of the window. + */ + const OUString& get_id() const { return maID; } +}; + +struct MenuBarButtonCallbackArg +{ + sal_uInt16 nId; // Id of the button + bool bHighlight; // highlight on/off +}; + +class VCL_DLLPUBLIC MenuBar final : public Menu +{ + Link<void*,void> maCloseHdl; + bool mbCloseBtnVisible : 1; + bool mbFloatBtnVisible : 1; + bool mbHideBtnVisible : 1; + bool mbDisplayable : 1; + + friend class Application; + friend class Menu; + friend class MenuBarWindow; + friend class MenuFloatingWindow; + friend class SystemWindow; + + SAL_DLLPRIVATE static VclPtr<vcl::Window> ImplCreate(vcl::Window* pParent, vcl::Window* pWindow, MenuBar* pMenu); + SAL_DLLPRIVATE static void ImplDestroy(MenuBar* pMenu, bool bDelete); + SAL_DLLPRIVATE bool ImplHandleKeyEvent(const KeyEvent& rKEvent); + + /// Return the MenuBarWindow. + MenuBarWindow* getMenuBarWindow(); + +public: + MenuBar(); + MenuBar( const MenuBar& rMenu ); + virtual ~MenuBar() override; + virtual void dispose() override; + + MenuBar& operator =( const MenuBar& rMenu ); + + virtual bool IsMenuBar() const override { return true; } + + /// Close the 'pStartedFrom' menu window. + virtual void ClosePopup(Menu* pMenu) override; + + /// Forward the KeyInput call to the MenuBar. + virtual void MenuBarKeyInput(const KeyEvent& rEvent) override; + + void ShowCloseButton( bool bShow ); + bool HasCloseButton() const { return mbCloseBtnVisible; } + bool HasFloatButton() const { return mbFloatBtnVisible; } + bool HasHideButton() const { return mbHideBtnVisible; } + void ShowButtons( bool bClose, bool bFloat, bool bHide ); + + virtual void SelectItem(sal_uInt16 nId) override; + bool HandleMenuHighlightEvent(Menu *pMenu, sal_uInt16 nEventId) const; + bool HandleMenuButtonEvent(sal_uInt16 nEventId); + + void SetCloseButtonClickHdl( const Link<void*,void>& rLink ) { maCloseHdl = rLink; } + const Link<void*,void>& GetCloseButtonClickHdl() const { return maCloseHdl; } + + // - by default a menubar is displayable + // - if a menubar is not displayable, its MenuBarWindow will never be shown + // and it will be hidden if it was visible before + // - note: if a menubar is displayable, this does not necessarily mean that it is currently visible + void SetDisplayable( bool bDisplayable ); + bool IsDisplayable() const { return mbDisplayable; } + + // add an arbitrary button to the menubar (will appear next to closer) + // passed link will be call with a MenuBarButtonCallbackArg on press + // passed string will be set as tooltip + sal_uInt16 AddMenuBarButton( const Image&, const Link<MenuBarButtonCallbackArg&,bool>&, const OUString& ); + // set the highlight link for additional button with ID nId + // highlight link will be called with a MenuBarButtonHighlightArg + // the bHighlight member of that struct shall contain the new state + void SetMenuBarButtonHighlightHdl( sal_uInt16 nId, const Link<MenuBarButtonCallbackArg&,bool>& ); + // returns the rectangle occupied by the additional button named nId + // coordinates are relative to the systemwindow the menubar is attached to + // if the menubar is unattached an empty rectangle is returned + tools::Rectangle GetMenuBarButtonRectPixel( sal_uInt16 nId ); + void RemoveMenuBarButton( sal_uInt16 nId ); + void LayoutChanged(); + // get the height of the menubar, return the native menubar height if that is active or the vcl + // one if not + int GetMenuBarHeight() const; +}; + +inline MenuBar& MenuBar::operator=( const MenuBar& rMenu ) +{ + Menu::operator=(rMenu); + return *this; +} + +class VCL_DLLPUBLIC PopupMenu final : public Menu +{ + friend class Menu; + friend class MenuFloatingWindow; + friend class MenuBarWindow; + friend struct MenuItemData; + +private: + SAL_DLLPRIVATE MenuFloatingWindow * ImplGetFloatingWindow() const; + SAL_DLLPRIVATE sal_uInt16 ImplExecute( const VclPtr<vcl::Window>& pW, const tools::Rectangle& rRect, FloatWinPopupFlags nPopupModeFlags, Menu* pSFrom, bool bPreSelectFirst ); + SAL_DLLPRIVATE void ImplFlushPendingSelect(); + SAL_DLLPRIVATE tools::Long ImplCalcHeight( sal_uInt16 nEntries ) const; + SAL_DLLPRIVATE sal_uInt16 ImplCalcVisEntries( tools::Long nMaxHeight, sal_uInt16 nStartEntry, sal_uInt16* pLastVisible = nullptr ) const; + +public: + PopupMenu(); + PopupMenu( const PopupMenu& rMenu ); + virtual ~PopupMenu() override; + + virtual bool IsMenuBar() const override { return false; } + + /// Close the 'pStartedFrom' menu window. + virtual void ClosePopup(Menu* pMenu) override; + + void SetText( const OUString& rTitle ) + { + aTitleText = rTitle; + } + + sal_uInt16 Execute( vcl::Window* pWindow, const Point& rPopupPos ); + sal_uInt16 Execute( vcl::Window* pWindow, const tools::Rectangle& rRect, PopupMenuFlags nFlags = PopupMenuFlags::NONE ); + + // for the TestTool + void EndExecute(); + virtual void SelectItem(sal_uInt16 nId) override; + void SetSelectedEntry( sal_uInt16 nId ); // for use by native submenu only + + css::uno::Reference<css::awt::XPopupMenu> CreateMenuInterface(); + + static PopupMenu* GetActivePopupMenu(); + + PopupMenu& operator=( const PopupMenu& rMenu ); +}; + +inline PopupMenu& PopupMenu::operator=( const PopupMenu& rMenu ) +{ + Menu::operator=( rMenu ); + return *this; +} + +#endif // INCLUDED_VCL_MENU_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/menubarupdateicon.hxx b/include/vcl/menubarupdateicon.hxx new file mode 100644 index 000000000..f9b2932aa --- /dev/null +++ b/include/vcl/menubarupdateicon.hxx @@ -0,0 +1,89 @@ +/* -*- 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 . + */ + +#pragma once + +#include <tools/link.hxx> +#include <vcl/idle.hxx> +#include <vcl/image.hxx> + +class BubbleWindow; +class MenuBar; +class SystemWindow; +class VclSimpleEvent; +class VclWindowEvent; +struct MenuBarButtonCallbackArg; + +class VCL_DLLPUBLIC MenuBarUpdateIconManager +{ +private: + OUString maBubbleTitle; + OUString maBubbleText; + Image maBubbleImage; + VclPtr<BubbleWindow> mpBubbleWin; + VclPtr<SystemWindow> mpIconSysWin; + VclPtr<MenuBar> mpIconMBar; + + Link<VclWindowEvent&, void> maWindowEventHdl; + Link<VclSimpleEvent&, void> maApplicationEventHdl; + Link<LinkParamNone*, void> maClickHdl; + + Timer maTimeoutTimer; + Idle maWaitIdle; + + sal_uInt16 mnIconID; + + bool mbShowMenuIcon; + bool mbShowBubble; + bool mbBubbleChanged; + + DECL_DLLPRIVATE_LINK(UserEventHdl, void*, void); + DECL_DLLPRIVATE_LINK(TimeOutHdl, Timer*, void); + DECL_DLLPRIVATE_LINK(WindowEventHdl, VclWindowEvent&, void); + DECL_DLLPRIVATE_LINK(ApplicationEventHdl, VclSimpleEvent&, void); + DECL_DLLPRIVATE_LINK(WaitTimeOutHdl, Timer*, void); + DECL_DLLPRIVATE_LINK(ClickHdl, MenuBarButtonCallbackArg&, bool); + DECL_DLLPRIVATE_LINK(HighlightHdl, MenuBarButtonCallbackArg&, bool); + + VclPtr<BubbleWindow> GetBubbleWindow(); + void SetBubbleChanged(); + +public: + MenuBarUpdateIconManager(); + ~MenuBarUpdateIconManager(); + + void SetShowMenuIcon(bool bShowMenuIcon); + void SetShowBubble(bool bShowBubble); + void SetBubbleImage(const Image& rImage); + void SetBubbleTitle(const OUString& rTitle); + void SetBubbleText(const OUString& rText); + + void SetClickHdl(const Link<LinkParamNone*, void>& rHdl) { maClickHdl = rHdl; } + + bool GetShowMenuIcon() const { return mbShowMenuIcon; } + bool GetShowBubble() const { return mbShowBubble; } + const OUString& GetBubbleTitle() const { return maBubbleTitle; } + const OUString& GetBubbleText() const { return maBubbleText; } + + void RemoveBubbleWindow(bool bRemoveIcon); + + void AddMenuBarIcon(SystemWindow* pSysWin, bool bAddEventHdl); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/metaact.hxx b/include/vcl/metaact.hxx new file mode 100644 index 000000000..3ac267aae --- /dev/null +++ b/include/vcl/metaact.hxx @@ -0,0 +1,1752 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_METAACT_HXX +#define INCLUDED_VCL_METAACT_HXX + +#include <sal/config.h> + +#include <config_options.h> + +#include <o3tl/span.hxx> +#include <rtl/ref.hxx> +#include <salhelper/simplereferenceobject.hxx> +#include <tools/poly.hxx> + +#include <vcl/dllapi.h> +#include <vcl/rendercontext/State.hxx> +#include <vcl/bitmapex.hxx> +#include <vcl/font.hxx> +#include <vcl/gdimtf.hxx> +#include <vcl/gfxlink.hxx> +#include <vcl/gradient.hxx> +#include <vcl/hatch.hxx> +#include <vcl/lineinfo.hxx> +#include <vcl/metaactiontypes.hxx> +#include <vcl/region.hxx> +#include <vcl/rendercontext/RasterOp.hxx> +#include <vcl/wall.hxx> + +#include <memory> + +class OutputDevice; +class SvStream; +enum class DrawTextFlags; + +struct ImplMetaReadData +{ + rtl_TextEncoding meActualCharSet; + int mnParseDepth; + + ImplMetaReadData() + : meActualCharSet(RTL_TEXTENCODING_ASCII_US) + , mnParseDepth(0) + {} +}; + +struct ImplMetaWriteData +{ + rtl_TextEncoding meActualCharSet; + + ImplMetaWriteData() : + meActualCharSet( RTL_TEXTENCODING_ASCII_US ) + {} +}; + +class VCL_DLLPUBLIC MetaAction : public salhelper::SimpleReferenceObject +{ +private: + MetaActionType mnType; + +protected: + virtual ~MetaAction() override; + +public: + MetaAction(); + explicit MetaAction( MetaActionType nType ); + MetaAction( MetaAction const & ); + + virtual void Execute( OutputDevice* pOut ); + + oslInterlockedCount GetRefCount() const { return m_nCount; } + + virtual rtl::Reference<MetaAction> Clone() const; + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ); + virtual void Scale( double fScaleX, double fScaleY ); + + MetaActionType GetType() const { return mnType; } + /** \#i10613# Extracted from Printer::GetPreparedMetaFile. Returns true + if given action requires special transparency handling + */ + virtual bool IsTransparent() const { return false; } +}; + +class VCL_DLLPUBLIC MetaPixelAction final : public MetaAction +{ +private: + Point maPt; + Color maColor; + +public: + MetaPixelAction(); + MetaPixelAction(MetaPixelAction const &) = default; + MetaPixelAction(MetaPixelAction &&) = default; + MetaPixelAction & operator =(MetaPixelAction const &) = delete; // due to MetaAction + MetaPixelAction & operator =(MetaPixelAction &&) = delete; // due to MetaAction +private: + virtual ~MetaPixelAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaPixelAction( const Point& rPt, const Color& rColor ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const Point& GetPoint() const { return maPt; } + const Color& GetColor() const { return maColor; } + void SetPoint(const Point& rPt) { maPt = rPt; } + void SetColor(Color rColor) { maColor = rColor; } +}; + +class VCL_DLLPUBLIC MetaPointAction final : public MetaAction +{ +private: + Point maPt; + +public: + MetaPointAction(); + MetaPointAction(MetaPointAction const &) = default; + MetaPointAction(MetaPointAction &&) = default; + MetaPointAction & operator =(MetaPointAction const &) = delete; // due to MetaAction + MetaPointAction & operator =(MetaPointAction &&) = delete; // due to MetaAction +private: + virtual ~MetaPointAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + explicit MetaPointAction( const Point& ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const Point& GetPoint() const { return maPt; } + void SetPoint(const Point& rPt) { maPt = rPt; } +}; + +class VCL_DLLPUBLIC MetaLineAction final : public MetaAction +{ +private: + + LineInfo maLineInfo; + Point maStartPt; + Point maEndPt; + +public: + MetaLineAction(); + MetaLineAction(MetaLineAction const &) = default; + MetaLineAction(MetaLineAction &&) = default; + MetaLineAction & operator =(MetaLineAction const &) = delete; // due to MetaAction + MetaLineAction & operator =(MetaLineAction &&) = delete; // due to MetaAction +private: + virtual ~MetaLineAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaLineAction( const Point& rStart, const Point& rEnd ); + MetaLineAction( const Point& rStart, const Point& rEnd, + const LineInfo& rLineInfo ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const Point& GetStartPoint() const { return maStartPt; } + const Point& GetEndPoint() const { return maEndPt; } + const LineInfo& GetLineInfo() const { return maLineInfo; } + void SetStartPoint(const Point& rPoint) { maStartPt = rPoint; } + void SetEndPoint(const Point& rPoint) { maEndPt = rPoint; } + void SetLineInfo(const LineInfo& rLineInfo) { maLineInfo = rLineInfo; } +}; + +class VCL_DLLPUBLIC MetaRectAction final : public MetaAction +{ +private: + + tools::Rectangle maRect; + +public: + MetaRectAction(); + MetaRectAction(MetaRectAction const &) = default; + MetaRectAction(MetaRectAction &&) = default; + MetaRectAction & operator =(MetaRectAction const &) = delete; // due to MetaAction + MetaRectAction & operator =(MetaRectAction &&) = delete; // due to MetaAction +private: + virtual ~MetaRectAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + explicit MetaRectAction( const tools::Rectangle& ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const tools::Rectangle& GetRect() const { return maRect; } + void SetRect(const tools::Rectangle& rRect) { maRect = rRect; } +}; + +class VCL_DLLPUBLIC MetaRoundRectAction final : public MetaAction +{ +private: + + tools::Rectangle maRect; + sal_uInt32 mnHorzRound; + sal_uInt32 mnVertRound; + +public: + MetaRoundRectAction(); + MetaRoundRectAction(MetaRoundRectAction const &) = default; + MetaRoundRectAction(MetaRoundRectAction &&) = default; + MetaRoundRectAction & operator =(MetaRoundRectAction const &) = delete; // due to MetaAction + MetaRoundRectAction & operator =(MetaRoundRectAction &&) = delete; // due to MetaAction +private: + virtual ~MetaRoundRectAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaRoundRectAction( const tools::Rectangle& rRect, + sal_uInt32 nHorzRound, sal_uInt32 nVertRound ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const tools::Rectangle& GetRect() const { return maRect; } + sal_uInt32 GetHorzRound() const { return mnHorzRound; } + sal_uInt32 GetVertRound() const { return mnVertRound; } + void SetRect(const tools::Rectangle& rRect) { maRect = rRect; } + void SetHorzRound(sal_uInt32 rHorzRound) { mnHorzRound = rHorzRound; } + void SetVertRound(sal_uInt32 rVertRound) { mnVertRound = rVertRound; } +}; + +class VCL_DLLPUBLIC MetaEllipseAction final : public MetaAction +{ +private: + + tools::Rectangle maRect; + +public: + MetaEllipseAction(); + MetaEllipseAction(MetaEllipseAction const &) = default; + MetaEllipseAction(MetaEllipseAction &&) = default; + MetaEllipseAction & operator =(MetaEllipseAction const &) = delete; // due to MetaAction + MetaEllipseAction & operator =(MetaEllipseAction &&) = delete; // due to MetaAction +private: + virtual ~MetaEllipseAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + explicit MetaEllipseAction( const tools::Rectangle& ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const tools::Rectangle& GetRect() const { return maRect; } + void SetRect(const tools::Rectangle& rRect) { maRect = rRect; } +}; + +class VCL_DLLPUBLIC MetaArcAction final : public MetaAction +{ +private: + + tools::Rectangle maRect; + Point maStartPt; + Point maEndPt; + +public: + MetaArcAction(); + MetaArcAction(MetaArcAction const &) = default; + MetaArcAction(MetaArcAction &&) = default; + MetaArcAction & operator =(MetaArcAction const &) = delete; // due to MetaAction + MetaArcAction & operator =(MetaArcAction &&) = delete; // due to MetaAction +private: + virtual ~MetaArcAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaArcAction( const tools::Rectangle& rRect, + const Point& rStart, const Point& rEnd ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const tools::Rectangle& GetRect() const { return maRect; } + const Point& GetStartPoint() const { return maStartPt; } + const Point& GetEndPoint() const { return maEndPt; } + void SetRect(const tools::Rectangle& rRect) { maRect = rRect; } + void SetStartPoint(const Point& rPoint) { maStartPt = rPoint; } + void SetEndPoint(const Point& rPoint) { maEndPt = rPoint; } +}; + +class VCL_DLLPUBLIC MetaPieAction final : public MetaAction +{ +private: + + tools::Rectangle maRect; + Point maStartPt; + Point maEndPt; + +public: + MetaPieAction(); + MetaPieAction(MetaPieAction const &) = default; + MetaPieAction(MetaPieAction &&) = default; + MetaPieAction & operator =(MetaPieAction const &) = delete; // due to MetaAction + MetaPieAction & operator =(MetaPieAction &&) = delete; // due to MetaAction +private: + virtual ~MetaPieAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaPieAction( const tools::Rectangle& rRect, + const Point& rStart, const Point& rEnd ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const tools::Rectangle& GetRect() const { return maRect; } + const Point& GetStartPoint() const { return maStartPt; } + const Point& GetEndPoint() const { return maEndPt; } + void SetRect(const tools::Rectangle& rRect) { maRect = rRect; } + void SetStartPoint(const Point& rPoint) { maStartPt = rPoint; } + void SetEndPoint(const Point& rPoint) { maEndPt = rPoint; } +}; + +class VCL_DLLPUBLIC MetaChordAction final : public MetaAction +{ +private: + + tools::Rectangle maRect; + Point maStartPt; + Point maEndPt; + +public: + MetaChordAction(); + MetaChordAction(MetaChordAction const &) = default; + MetaChordAction(MetaChordAction &&) = default; + MetaChordAction & operator =(MetaChordAction const &) = delete; // due to MetaAction + MetaChordAction & operator =(MetaChordAction &&) = delete; // due to MetaAction +private: + virtual ~MetaChordAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaChordAction( const tools::Rectangle& rRect, + const Point& rStart, const Point& rEnd ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const tools::Rectangle& GetRect() const { return maRect; } + const Point& GetStartPoint() const { return maStartPt; } + const Point& GetEndPoint() const { return maEndPt; } + void SetRect(const tools::Rectangle& rRect) { maRect = rRect; } + void SetStartPoint(const Point& rPoint) { maStartPt = rPoint; } + void SetEndPoint(const Point& rPoint) { maEndPt = rPoint; } +}; + +class VCL_DLLPUBLIC MetaPolyLineAction final : public MetaAction +{ +private: + + LineInfo maLineInfo; + tools::Polygon maPoly; + +public: + MetaPolyLineAction(); + MetaPolyLineAction(MetaPolyLineAction const &) = default; + MetaPolyLineAction(MetaPolyLineAction &&) = default; + MetaPolyLineAction & operator =(MetaPolyLineAction const &) = delete; // due to MetaAction + MetaPolyLineAction & operator =(MetaPolyLineAction &&) = delete; // due to MetaAction +private: + virtual ~MetaPolyLineAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + explicit MetaPolyLineAction( const tools::Polygon& ); + explicit MetaPolyLineAction( const tools::Polygon&, const LineInfo& ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const tools::Polygon& GetPolygon() const { return maPoly; } + const LineInfo& GetLineInfo() const { return maLineInfo; } + void SetLineInfo(const LineInfo& rLineInfo) { maLineInfo = rLineInfo; } + void SetPolygon(const tools::Polygon& rPoly) { maPoly = rPoly; } +}; + +class VCL_DLLPUBLIC MetaPolygonAction final : public MetaAction +{ +private: + + tools::Polygon maPoly; + +public: + MetaPolygonAction(); + MetaPolygonAction(MetaPolygonAction const &) = default; + MetaPolygonAction(MetaPolygonAction &&) = default; + MetaPolygonAction & operator =(MetaPolygonAction const &) = delete; // due to MetaAction + MetaPolygonAction & operator =(MetaPolygonAction &&) = delete; // due to MetaAction +private: + virtual ~MetaPolygonAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + explicit MetaPolygonAction( const tools::Polygon& ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const tools::Polygon& GetPolygon() const { return maPoly; } + void SetPolygon(const tools::Polygon& rPoly) { maPoly = rPoly; } +}; + +class VCL_DLLPUBLIC MetaPolyPolygonAction final : public MetaAction +{ +private: + + tools::PolyPolygon maPolyPoly; + +public: + MetaPolyPolygonAction(); + MetaPolyPolygonAction(MetaPolyPolygonAction const &) = default; + MetaPolyPolygonAction(MetaPolyPolygonAction &&) = default; + MetaPolyPolygonAction & operator =(MetaPolyPolygonAction const &) = delete; // due to MetaAction + MetaPolyPolygonAction & operator =(MetaPolyPolygonAction &&) = delete; // due to MetaAction +private: + virtual ~MetaPolyPolygonAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + explicit MetaPolyPolygonAction( const tools::PolyPolygon& ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const tools::PolyPolygon& GetPolyPolygon() const { return maPolyPoly; } + void SetPolyPolygon(const tools::PolyPolygon& rPolyPoly) { maPolyPoly = rPolyPoly; } +}; + +class SAL_DLLPUBLIC_RTTI MetaTextAction final : public MetaAction +{ +private: + + Point maPt; + OUString maStr; + sal_Int32 mnIndex; + sal_Int32 mnLen; + +public: + MetaTextAction(); + MetaTextAction(MetaTextAction const &) = default; + MetaTextAction(MetaTextAction &&) = default; + MetaTextAction & operator =(MetaTextAction const &) = delete; // due to MetaAction + MetaTextAction & operator =(MetaTextAction &&) = delete; // due to MetaAction +private: + virtual ~MetaTextAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaTextAction( const Point& rPt, const OUString& rStr, + sal_Int32 nIndex, sal_Int32 nLen ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const Point& GetPoint() const { return maPt; } + const OUString& GetText() const { return maStr; } + sal_Int32 GetIndex() const { return mnIndex; } + sal_Int32 GetLen() const { return mnLen; } + void SetPoint(const Point& rPt) { maPt = rPt; } + void SetText(const OUString& rStr) { maStr = rStr; } + void SetIndex(sal_Int32 rIndex) { mnIndex = rIndex; } + void SetLen(sal_Int32 rLen) { mnLen = rLen; } +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaTextArrayAction final : public MetaAction +{ +private: + + Point maStartPt; + OUString maStr; + std::vector<sal_Int32> maDXAry; + sal_Int32 mnIndex; + sal_Int32 mnLen; + + virtual ~MetaTextArrayAction() override; + +public: + MetaTextArrayAction(); + MetaTextArrayAction( const MetaTextArrayAction& rAction ); + MetaTextArrayAction( const Point& rStartPt, const OUString& rStr, + const std::vector<sal_Int32>& rDXAry, sal_Int32 nIndex, + sal_Int32 nLen ); + MetaTextArrayAction( const Point& rStartPt, const OUString& rStr, + o3tl::span<const sal_Int32> pDXAry, sal_Int32 nIndex, + sal_Int32 nLen ); + + virtual void Execute( OutputDevice* pOut ) override; + + virtual rtl::Reference<MetaAction> Clone() const override; + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const Point& GetPoint() const { return maStartPt; } + const OUString& GetText() const { return maStr; } + sal_Int32 GetIndex() const { return mnIndex; } + sal_Int32 GetLen() const { return mnLen; } + const std::vector<sal_Int32> & GetDXArray() const { return maDXAry; } + void SetPoint(const Point& rPt) { maStartPt = rPt; } + void SetText(const OUString& rStr) { maStr = rStr; } + void SetIndex(sal_Int32 rIndex) { mnIndex = rIndex; } + void SetLen(sal_Int32 rLen) { mnLen = rLen; } + void SetDXArray(std::vector<sal_Int32> aArray); +}; + +class SAL_DLLPUBLIC_RTTI MetaStretchTextAction final : public MetaAction +{ +private: + + Point maPt; + OUString maStr; + sal_uInt32 mnWidth; + sal_Int32 mnIndex; + sal_Int32 mnLen; + +public: + MetaStretchTextAction(); + MetaStretchTextAction(MetaStretchTextAction const &) = default; + MetaStretchTextAction(MetaStretchTextAction &&) = default; + MetaStretchTextAction & operator =(MetaStretchTextAction const &) = delete; // due to MetaAction + MetaStretchTextAction & operator =(MetaStretchTextAction &&) = delete; // due to MetaAction +private: + virtual ~MetaStretchTextAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaStretchTextAction( const Point& rPt, sal_uInt32 nWidth, + const OUString& rStr, + sal_Int32 nIndex, sal_Int32 nLen ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const Point& GetPoint() const { return maPt; } + const OUString& GetText() const { return maStr; } + sal_uInt32 GetWidth() const { return mnWidth; } + sal_Int32 GetIndex() const { return mnIndex; } + sal_Int32 GetLen() const { return mnLen; } + void SetPoint(const Point& rPt) { maPt = rPt; } + void SetText(const OUString& rStr) { maStr = rStr; } + void SetWidth(sal_uInt32 rWidth) { mnWidth = rWidth; } + void SetIndex(sal_uInt32 rIndex) { mnIndex = rIndex; } + void SetLen(sal_uInt32 rLen) { mnLen = rLen; } +}; + +class SAL_DLLPUBLIC_RTTI MetaTextRectAction final : public MetaAction +{ +private: + + tools::Rectangle maRect; + OUString maStr; + DrawTextFlags mnStyle; + +public: + MetaTextRectAction(); + MetaTextRectAction(MetaTextRectAction const &) = default; + MetaTextRectAction(MetaTextRectAction &&) = default; + MetaTextRectAction & operator =(MetaTextRectAction const &) = delete; // due to MetaAction + MetaTextRectAction & operator =(MetaTextRectAction &&) = delete; // due to MetaAction +private: + virtual ~MetaTextRectAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaTextRectAction( const tools::Rectangle& rRect, + const OUString& rStr, DrawTextFlags nStyle ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const tools::Rectangle& GetRect() const { return maRect; } + const OUString& GetText() const { return maStr; } + DrawTextFlags GetStyle() const { return mnStyle; } + void SetRect(const tools::Rectangle& rRect) { maRect = rRect; } + void SetText(const OUString& rStr) { maStr = rStr; } + void SetStyle(DrawTextFlags rStyle) { mnStyle = rStyle; } +}; + +class SAL_DLLPUBLIC_RTTI MetaTextLineAction final : public MetaAction +{ +private: + + Point maPos; + tools::Long mnWidth; + FontStrikeout meStrikeout; + FontLineStyle meUnderline; + FontLineStyle meOverline; + +public: + MetaTextLineAction(); + MetaTextLineAction(MetaTextLineAction const &) = default; + MetaTextLineAction(MetaTextLineAction &&) = default; + MetaTextLineAction & operator =(MetaTextLineAction const &) = delete; // due to MetaAction + MetaTextLineAction & operator =(MetaTextLineAction &&) = delete; // due to MetaAction +private: + virtual ~MetaTextLineAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaTextLineAction( const Point& rPos, tools::Long nWidth, + FontStrikeout eStrikeout, + FontLineStyle eUnderline, + FontLineStyle eOverline ); + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const Point& GetStartPoint() const { return maPos; } + tools::Long GetWidth() const { return mnWidth; } + FontStrikeout GetStrikeout() const { return meStrikeout; } + FontLineStyle GetUnderline() const { return meUnderline; } + FontLineStyle GetOverline() const { return meOverline; } + void SetStartPoint(const Point& rPos) { maPos = rPos; } + void SetWidth(tools::Long rWidth) { mnWidth = rWidth; } + void SetStrikeout(FontStrikeout eStrikeout) { meStrikeout = eStrikeout; } + void SetUnderline(FontLineStyle eUnderline) { meUnderline = eUnderline; } + void SetOverline(FontLineStyle eOverline) { meOverline = eOverline; } +}; + +class VCL_DLLPUBLIC MetaBmpAction final : public MetaAction +{ +private: + + Bitmap maBmp; + Point maPt; + +public: + MetaBmpAction(); + MetaBmpAction(MetaBmpAction const &) = default; + MetaBmpAction(MetaBmpAction &&) = default; + MetaBmpAction & operator =(MetaBmpAction const &) = delete; // due to MetaAction + MetaBmpAction & operator =(MetaBmpAction &&) = delete; // due to MetaAction +private: + virtual ~MetaBmpAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaBmpAction( const Point& rPt, const Bitmap& rBmp ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const Bitmap& GetBitmap() const { return maBmp; } + const Point& GetPoint() const { return maPt; } + void SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; } + void SetPoint(const Point& rPt) { maPt = rPt; } +}; + +class VCL_DLLPUBLIC MetaBmpScaleAction final : public MetaAction +{ +private: + + Bitmap maBmp; + Point maPt; + Size maSz; + +public: + MetaBmpScaleAction(); + MetaBmpScaleAction(MetaBmpScaleAction const &) = default; + MetaBmpScaleAction(MetaBmpScaleAction &&) = default; + MetaBmpScaleAction & operator =(MetaBmpScaleAction const &) = delete; // due to MetaAction + MetaBmpScaleAction & operator =(MetaBmpScaleAction &&) = delete; // due to MetaAction +private: + virtual ~MetaBmpScaleAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaBmpScaleAction( const Point& rPt, const Size& rSz, + const Bitmap& rBmp ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const Bitmap& GetBitmap() const { return maBmp; } + const Point& GetPoint() const { return maPt; } + const Size& GetSize() const { return maSz; } + void SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; } + void SetPoint(const Point& rPt) { maPt = rPt; } + void SetSize(const Size& rSz) { maSz = rSz; } +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaBmpScalePartAction final : public MetaAction +{ +private: + + Bitmap maBmp; + Point maDstPt; + Size maDstSz; + Point maSrcPt; + Size maSrcSz; + +public: + MetaBmpScalePartAction(); + MetaBmpScalePartAction(MetaBmpScalePartAction const &) = default; + MetaBmpScalePartAction(MetaBmpScalePartAction &&) = default; + MetaBmpScalePartAction & operator =(MetaBmpScalePartAction const &) = delete; // due to MetaAction + MetaBmpScalePartAction & operator =(MetaBmpScalePartAction &&) = delete; // due to MetaAction +private: + virtual ~MetaBmpScalePartAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaBmpScalePartAction( const Point& rDstPt, const Size& rDstSz, + const Point& rSrcPt, const Size& rSrcSz, + const Bitmap& rBmp ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const Bitmap& GetBitmap() const { return maBmp; } + const Point& GetDestPoint() const { return maDstPt; } + const Size& GetDestSize() const { return maDstSz; } + const Point& GetSrcPoint() const { return maSrcPt; } + const Size& GetSrcSize() const { return maSrcSz; } + void SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; } + void SetDestPoint(const Point& rPt) { maDstPt = rPt; } + void SetDestSize(const Size& rSz) { maDstSz = rSz; } + void SetSrcPoint(const Point& rPt) { maSrcPt = rPt; } + void SetSrcSize(const Size& rSz) { maSrcSz = rSz; } +}; + +class VCL_DLLPUBLIC MetaBmpExAction final : public MetaAction +{ +private: + + BitmapEx maBmpEx; + Point maPt; + +public: + MetaBmpExAction(); + MetaBmpExAction(MetaBmpExAction const &) = default; + MetaBmpExAction(MetaBmpExAction &&) = default; + MetaBmpExAction & operator =(MetaBmpExAction const &) = delete; // due to MetaAction + MetaBmpExAction & operator =(MetaBmpExAction &&) = delete; // due to MetaAction +private: + virtual ~MetaBmpExAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaBmpExAction( const Point& rPt, const BitmapEx& rBmpEx ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const BitmapEx& GetBitmapEx() const { return maBmpEx; } + const Point& GetPoint() const { return maPt; } + void SetBitmapEx(BitmapEx rBmpEx) { maBmpEx = rBmpEx; } + void SetPoint(const Point& rPt) { maPt = rPt; } + bool IsTransparent() const override { return GetBitmapEx().IsAlpha(); } +}; + +class VCL_DLLPUBLIC MetaBmpExScaleAction final : public MetaAction +{ +private: + + BitmapEx maBmpEx; + Point maPt; + Size maSz; + +public: + MetaBmpExScaleAction(); + MetaBmpExScaleAction(MetaBmpExScaleAction const &) = default; + MetaBmpExScaleAction(MetaBmpExScaleAction &&) = default; + MetaBmpExScaleAction & operator =(MetaBmpExScaleAction const &) = delete; // due to MetaAction + MetaBmpExScaleAction & operator =(MetaBmpExScaleAction &&) = delete; // due to MetaAction +private: + virtual ~MetaBmpExScaleAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaBmpExScaleAction( const Point& rPt, const Size& rSz, + const BitmapEx& rBmpEx ) ; + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const BitmapEx& GetBitmapEx() const { return maBmpEx; } + const Point& GetPoint() const { return maPt; } + const Size& GetSize() const { return maSz; } + void SetBitmapEx(const BitmapEx& rBmpEx) { maBmpEx = rBmpEx; } + void SetPoint(const Point& rPt) { maPt = rPt; } + void SetSize(const Size& rSz) { maSz = rSz; } + bool IsTransparent() const override { return GetBitmapEx().IsAlpha(); } +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaBmpExScalePartAction final : public MetaAction +{ +private: + + BitmapEx maBmpEx; + Point maDstPt; + Size maDstSz; + Point maSrcPt; + Size maSrcSz; + +public: + MetaBmpExScalePartAction(); + MetaBmpExScalePartAction(MetaBmpExScalePartAction const &) = default; + MetaBmpExScalePartAction(MetaBmpExScalePartAction &&) = default; + MetaBmpExScalePartAction & operator =(MetaBmpExScalePartAction const &) = delete; // due to MetaAction + MetaBmpExScalePartAction & operator =(MetaBmpExScalePartAction &&) = delete; // due to MetaAction +private: + virtual ~MetaBmpExScalePartAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaBmpExScalePartAction( const Point& rDstPt, const Size& rDstSz, + const Point& rSrcPt, const Size& rSrcSz, + const BitmapEx& rBmpEx ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const BitmapEx& GetBitmapEx() const { return maBmpEx; } + const Point& GetDestPoint() const { return maDstPt; } + const Size& GetDestSize() const { return maDstSz; } + const Point& GetSrcPoint() const { return maSrcPt; } + const Size& GetSrcSize() const { return maSrcSz; } + void SetBitmapEx(const BitmapEx& rBmpEx) { maBmpEx = rBmpEx; } + void SetDestPoint(const Point& rDstPt) { maDstPt = rDstPt; } + void SetDestSize(const Size& rDstSz) { maDstSz = rDstSz; } + void SetSrcPoint(const Point& rSrcPt) { maSrcPt = rSrcPt; } + void SetSrcSize(const Size& rSrcSz) { maSrcSz = rSrcSz; } + bool IsTransparent() const override { return GetBitmapEx().IsAlpha(); } +}; + +class SAL_DLLPUBLIC_RTTI MetaMaskAction final : public MetaAction +{ +private: + + Bitmap maBmp; + Color maColor; + Point maPt; + +public: + MetaMaskAction(); + MetaMaskAction(MetaMaskAction const &) = default; + MetaMaskAction(MetaMaskAction &&) = default; + MetaMaskAction & operator =(MetaMaskAction const &) = delete; // due to MetaAction + MetaMaskAction & operator =(MetaMaskAction &&) = delete; // due to MetaAction +private: + virtual ~MetaMaskAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaMaskAction( const Point& rPt, + const Bitmap& rBmp, + const Color& rColor ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const Bitmap& GetBitmap() const { return maBmp; } + const Color& GetColor() const { return maColor; } + const Point& GetPoint() const { return maPt; } + void SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; } + void SetPoint(const Point& rPt) { maPt = rPt; } +}; + +class SAL_DLLPUBLIC_RTTI MetaMaskScaleAction final : public MetaAction +{ +private: + + Bitmap maBmp; + Color maColor; + Point maPt; + Size maSz; + +public: + MetaMaskScaleAction(); + MetaMaskScaleAction(MetaMaskScaleAction const &) = default; + MetaMaskScaleAction(MetaMaskScaleAction &&) = default; + MetaMaskScaleAction & operator =(MetaMaskScaleAction const &) = delete; // due to MetaAction + MetaMaskScaleAction & operator =(MetaMaskScaleAction &&) = delete; // due to MetaAction +private: + virtual ~MetaMaskScaleAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaMaskScaleAction( const Point& rPt, const Size& rSz, + const Bitmap& rBmp, + const Color& rColor ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const Bitmap& GetBitmap() const { return maBmp; } + const Color& GetColor() const { return maColor; } + const Point& GetPoint() const { return maPt; } + const Size& GetSize() const { return maSz; } + void SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; } + void SetPoint(const Point& rPt) { maPt = rPt; } + void SetSize(const Size& rSz) { maSz = rSz; } +}; + +class SAL_DLLPUBLIC_RTTI MetaMaskScalePartAction final : public MetaAction +{ +private: + + Bitmap maBmp; + Color maColor; + Point maDstPt; + Size maDstSz; + Point maSrcPt; + Size maSrcSz; + +public: + MetaMaskScalePartAction(); + MetaMaskScalePartAction(MetaMaskScalePartAction const &) = default; + MetaMaskScalePartAction(MetaMaskScalePartAction &&) = default; + MetaMaskScalePartAction & operator =(MetaMaskScalePartAction const &) = delete; // due to MetaAction + MetaMaskScalePartAction & operator =(MetaMaskScalePartAction &&) = delete; // due to MetaAction +private: + virtual ~MetaMaskScalePartAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaMaskScalePartAction( const Point& rDstPt, const Size& rDstSz, + const Point& rSrcPt, const Size& rSrcSz, + const Bitmap& rBmp, + const Color& rColor ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const Bitmap& GetBitmap() const { return maBmp; } + const Color& GetColor() const { return maColor; } + const Point& GetDestPoint() const { return maDstPt; } + const Size& GetDestSize() const { return maDstSz; } + const Point& GetSrcPoint() const { return maSrcPt; } + const Size& GetSrcSize() const { return maSrcSz; } + void SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; } + void SetColor(Color rColor) { maColor = rColor; } + void SetDestPoint(const Point& rPt) { maDstPt = rPt; } + void SetDestSize(const Size& rSz) { maDstSz = rSz; } + void SetSrcPoint(const Point& rPt) { maSrcPt = rPt; } + void SetSrcSize(const Size& rSz) { maSrcSz = rSz; } +}; + +class SAL_DLLPUBLIC_RTTI MetaGradientAction final : public MetaAction +{ +private: + + tools::Rectangle maRect; + Gradient maGradient; + +public: + MetaGradientAction(); + MetaGradientAction(MetaGradientAction const &) = default; + MetaGradientAction(MetaGradientAction &&) = default; + MetaGradientAction & operator =(MetaGradientAction const &) = delete; // due to MetaAction + MetaGradientAction & operator =(MetaGradientAction &&) = delete; // due to MetaAction +private: + virtual ~MetaGradientAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaGradientAction( const tools::Rectangle& rRect, const Gradient& rGradient ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const tools::Rectangle& GetRect() const { return maRect; } + const Gradient& GetGradient() const { return maGradient; } + void SetGradient(const Gradient& rGradient) { maGradient = rGradient; } + void SetRect(const tools::Rectangle& rRect) { maRect = rRect; } +}; + +class VCL_DLLPUBLIC MetaGradientExAction final : public MetaAction +{ +private: + + tools::PolyPolygon maPolyPoly; + Gradient maGradient; + +public: + MetaGradientExAction(); + MetaGradientExAction(MetaGradientExAction const &) = default; + MetaGradientExAction(MetaGradientExAction &&) = default; + MetaGradientExAction & operator =(MetaGradientExAction const &) = delete; // due to MetaAction + MetaGradientExAction & operator =(MetaGradientExAction &&) = delete; // due to MetaAction +private: + virtual ~MetaGradientExAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaGradientExAction( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const tools::PolyPolygon& GetPolyPolygon() const { return maPolyPoly; } + const Gradient& GetGradient() const { return maGradient; } + void SetPolyPolygon(const tools::PolyPolygon& rPolyPoly) { maPolyPoly = rPolyPoly; } + void SetGradient(const Gradient& rGradient) { maGradient = rGradient; } +}; + +class SAL_DLLPUBLIC_RTTI MetaHatchAction final : public MetaAction +{ +private: + + tools::PolyPolygon maPolyPoly; + Hatch maHatch; + +public: + MetaHatchAction(); + MetaHatchAction(MetaHatchAction const &) = default; + MetaHatchAction(MetaHatchAction &&) = default; + MetaHatchAction & operator =(MetaHatchAction const &) = delete; // due to MetaAction + MetaHatchAction & operator =(MetaHatchAction &&) = delete; // due to MetaAction +private: + virtual ~MetaHatchAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaHatchAction( const tools::PolyPolygon& rPolyPoly, const Hatch& rHatch ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const tools::PolyPolygon& GetPolyPolygon() const { return maPolyPoly; } + const Hatch& GetHatch() const { return maHatch; } + void SetPolyPolygon(const tools::PolyPolygon& rPolyPoly) { maPolyPoly = rPolyPoly; } + void SetHatch(const Hatch& rHatch) { maHatch = rHatch; } +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaWallpaperAction final : public MetaAction +{ +private: + + tools::Rectangle maRect; + Wallpaper maWallpaper; + +public: + MetaWallpaperAction(); + MetaWallpaperAction(MetaWallpaperAction const &) = default; + MetaWallpaperAction(MetaWallpaperAction &&) = default; + MetaWallpaperAction & operator =(MetaWallpaperAction const &) = delete; // due to MetaAction + MetaWallpaperAction & operator =(MetaWallpaperAction &&) = delete; // due to MetaAction +private: + virtual ~MetaWallpaperAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaWallpaperAction( const tools::Rectangle& rRect, + const Wallpaper& rPaper ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const tools::Rectangle& GetRect() const { return maRect; } + const Wallpaper& GetWallpaper() const { return maWallpaper; } + void SetWallpaper(const Wallpaper& rWallpaper) { maWallpaper = rWallpaper; } +}; + +class VCL_DLLPUBLIC MetaClipRegionAction final : public MetaAction +{ +private: + + vcl::Region maRegion; + bool mbClip; + +public: + MetaClipRegionAction(); + MetaClipRegionAction(MetaClipRegionAction const &) = default; + MetaClipRegionAction(MetaClipRegionAction &&) = default; + MetaClipRegionAction & operator =(MetaClipRegionAction const &) = delete; // due to MetaAction + MetaClipRegionAction & operator =(MetaClipRegionAction &&) = delete; // due to MetaAction +private: + virtual ~MetaClipRegionAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaClipRegionAction( const vcl::Region& rRegion, bool bClip ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const vcl::Region& GetRegion() const { return maRegion; } + bool IsClipping() const { return mbClip; } + void SetRegion(const vcl::Region& rRegion) { maRegion = rRegion; } + void SetClipping(bool bClip) { mbClip = bClip; } +}; + +class VCL_DLLPUBLIC MetaISectRectClipRegionAction final : public MetaAction +{ +private: + + tools::Rectangle maRect; + +public: + MetaISectRectClipRegionAction(); + MetaISectRectClipRegionAction(MetaISectRectClipRegionAction const &) = default; + MetaISectRectClipRegionAction(MetaISectRectClipRegionAction &&) = default; + MetaISectRectClipRegionAction & operator =(MetaISectRectClipRegionAction const &) = delete; // due to MetaAction + MetaISectRectClipRegionAction & operator =(MetaISectRectClipRegionAction &&) = delete; // due to MetaAction +private: + virtual ~MetaISectRectClipRegionAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + explicit MetaISectRectClipRegionAction( const tools::Rectangle& ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const tools::Rectangle& GetRect() const { return maRect; } + void SetRect(const tools::Rectangle& rRect) { maRect = rRect; } +}; + +class VCL_DLLPUBLIC MetaISectRegionClipRegionAction final : public MetaAction +{ +private: + + vcl::Region maRegion; + +public: + MetaISectRegionClipRegionAction(); + MetaISectRegionClipRegionAction(MetaISectRegionClipRegionAction const &) = default; + MetaISectRegionClipRegionAction(MetaISectRegionClipRegionAction &&) = default; + MetaISectRegionClipRegionAction & operator =(MetaISectRegionClipRegionAction const &) = delete; // due to MetaAction + MetaISectRegionClipRegionAction & operator =(MetaISectRegionClipRegionAction &&) = delete; // due to MetaAction +private: + virtual ~MetaISectRegionClipRegionAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + explicit MetaISectRegionClipRegionAction( const vcl::Region& ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const vcl::Region& GetRegion() const { return maRegion; } + void SetRegion(const vcl::Region& rRegion) { maRegion = rRegion; } +}; + +class VCL_DLLPUBLIC MetaMoveClipRegionAction final : public MetaAction +{ +private: + + tools::Long mnHorzMove; + tools::Long mnVertMove; + +public: + MetaMoveClipRegionAction(); + MetaMoveClipRegionAction(MetaMoveClipRegionAction const &) = default; + MetaMoveClipRegionAction(MetaMoveClipRegionAction &&) = default; + MetaMoveClipRegionAction & operator =(MetaMoveClipRegionAction const &) = delete; // due to MetaAction + MetaMoveClipRegionAction & operator =(MetaMoveClipRegionAction &&) = delete; // due to MetaAction +private: + virtual ~MetaMoveClipRegionAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaMoveClipRegionAction( tools::Long nHorzMove, tools::Long nVertMove ); + + virtual void Scale( double fScaleX, double fScaleY ) override; + + tools::Long GetHorzMove() const { return mnHorzMove; } + tools::Long GetVertMove() const { return mnVertMove; } + void SetHorzMove(tools::Long nHorzMove) { mnHorzMove = nHorzMove; } + void SetVertMove(tools::Long nVertMove) { mnVertMove = nVertMove; } +}; + +class VCL_DLLPUBLIC MetaLineColorAction final : public MetaAction +{ +private: + + Color maColor; + bool mbSet; + +public: + MetaLineColorAction(); + MetaLineColorAction(MetaLineColorAction const &) = default; + MetaLineColorAction(MetaLineColorAction &&) = default; + MetaLineColorAction & operator =(MetaLineColorAction const &) = delete; // due to MetaAction + MetaLineColorAction & operator =(MetaLineColorAction &&) = delete; // due to MetaAction +private: + virtual ~MetaLineColorAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaLineColorAction( const Color& rColor, bool bSet ); + + const Color& GetColor() const { return maColor; } + bool IsSetting() const { return mbSet; } + void SetColor(const Color& rColor) { maColor = rColor; } + void SetSetting(bool rSet) { mbSet = rSet; } +}; + +class VCL_DLLPUBLIC MetaFillColorAction final : public MetaAction +{ +private: + + Color maColor; + bool mbSet; + +public: + MetaFillColorAction(); + MetaFillColorAction(MetaFillColorAction const &) = default; + MetaFillColorAction(MetaFillColorAction &&) = default; + MetaFillColorAction & operator =(MetaFillColorAction const &) = delete; // due to MetaAction + MetaFillColorAction & operator =(MetaFillColorAction &&) = delete; // due to MetaAction +private: + virtual ~MetaFillColorAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaFillColorAction( const Color& rColor, bool bSet ); + + const Color& GetColor() const { return maColor; } + bool IsSetting() const { return mbSet; } + void SetSetting(bool rSet) { mbSet = rSet; } + void SetColor(Color rColor) { maColor = rColor; } + +}; + +class VCL_DLLPUBLIC MetaTextColorAction final : public MetaAction +{ +private: + + Color maColor; + +public: + MetaTextColorAction(); + MetaTextColorAction(MetaTextColorAction const &) = default; + MetaTextColorAction(MetaTextColorAction &&) = default; + MetaTextColorAction & operator =(MetaTextColorAction const &) = delete; // due to MetaAction + MetaTextColorAction & operator =(MetaTextColorAction &&) = delete; // due to MetaAction +private: + virtual ~MetaTextColorAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + explicit MetaTextColorAction( const Color& ); + + const Color& GetColor() const { return maColor; } + void SetColor(Color rColor) { maColor = rColor; } +}; + +class VCL_DLLPUBLIC MetaTextFillColorAction final : public MetaAction +{ +private: + + Color maColor; + bool mbSet; + +public: + MetaTextFillColorAction(); + MetaTextFillColorAction(MetaTextFillColorAction const &) = default; + MetaTextFillColorAction(MetaTextFillColorAction &&) = default; + MetaTextFillColorAction & operator =(MetaTextFillColorAction const &) = delete; // due to MetaAction + MetaTextFillColorAction & operator =(MetaTextFillColorAction &&) = delete; // due to MetaAction +private: + virtual ~MetaTextFillColorAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaTextFillColorAction( const Color& rColor, bool bSet ); + + const Color& GetColor() const { return maColor; } + void SetColor(Color rColor) { maColor = rColor; } + void SetSetting(bool bSet) { mbSet = bSet; } + bool IsSetting() const { return mbSet; } + +}; + +class VCL_DLLPUBLIC MetaTextLineColorAction final : public MetaAction +{ +private: + + Color maColor; + bool mbSet; + +public: + MetaTextLineColorAction(); + MetaTextLineColorAction(MetaTextLineColorAction const &) = default; + MetaTextLineColorAction(MetaTextLineColorAction &&) = default; + MetaTextLineColorAction & operator =(MetaTextLineColorAction const &) = delete; // due to MetaAction + MetaTextLineColorAction & operator =(MetaTextLineColorAction &&) = delete; // due to MetaAction +private: + virtual ~MetaTextLineColorAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaTextLineColorAction( const Color& rColor, bool bSet ); + + const Color& GetColor() const { return maColor; } + void SetColor(const Color& rColor) { maColor = rColor; } + void SetSetting(bool bSet) { mbSet = bSet; } + bool IsSetting() const { return mbSet; } +}; + +class VCL_DLLPUBLIC MetaOverlineColorAction final : public MetaAction +{ +private: + + Color maColor; + bool mbSet; + +public: + MetaOverlineColorAction(); + MetaOverlineColorAction(MetaOverlineColorAction const &) = default; + MetaOverlineColorAction(MetaOverlineColorAction &&) = default; + MetaOverlineColorAction & operator =(MetaOverlineColorAction const &) = delete; // due to MetaAction + MetaOverlineColorAction & operator =(MetaOverlineColorAction &&) = delete; // due to MetaAction +private: + virtual ~MetaOverlineColorAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaOverlineColorAction( const Color& rColor, bool bSet ); + + const Color& GetColor() const { return maColor; } + void SetColor(const Color& rColor) { maColor = rColor; } + void SetSetting(bool bSet) { mbSet = bSet; } + bool IsSetting() const { return mbSet; } +}; + +class VCL_DLLPUBLIC MetaTextAlignAction final : public MetaAction +{ +private: + + TextAlign maAlign; + +public: + MetaTextAlignAction(); + MetaTextAlignAction(MetaTextAlignAction const &) = default; + MetaTextAlignAction(MetaTextAlignAction &&) = default; + MetaTextAlignAction & operator =(MetaTextAlignAction const &) = delete; // due to MetaAction + MetaTextAlignAction & operator =(MetaTextAlignAction &&) = delete; // due to MetaAction +private: + virtual ~MetaTextAlignAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + explicit MetaTextAlignAction( TextAlign eAlign ); + + TextAlign GetTextAlign() const { return maAlign; } + void SetTextAlign(TextAlign eAlign) { maAlign = eAlign; } +}; + +class VCL_DLLPUBLIC MetaMapModeAction final : public MetaAction +{ +private: + + MapMode maMapMode; + +public: + MetaMapModeAction(); + MetaMapModeAction(MetaMapModeAction const &) = default; + MetaMapModeAction(MetaMapModeAction &&) = default; + MetaMapModeAction & operator =(MetaMapModeAction const &) = delete; // due to MetaAction + MetaMapModeAction & operator =(MetaMapModeAction &&) = delete; // due to MetaAction +private: + virtual ~MetaMapModeAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + explicit MetaMapModeAction( const MapMode& ); + + virtual void Scale( double fScaleX, double fScaleY ) override; + + const MapMode& GetMapMode() const { return maMapMode; } + void SetMapMode(const MapMode& rMapMode) { maMapMode = rMapMode; } +}; + +// tdf#127471 decl for friend below +namespace emfio { class ScaledFontDetectCorrectHelper; } + +class VCL_DLLPUBLIC MetaFontAction final : public MetaAction +{ +private: + + vcl::Font maFont; + + // tdf#127471 for import correction of own wrong written EMF/WMF files allow correction + // of FontScale after import. Only from there, so use a friend here and keep the method private + friend class emfio::ScaledFontDetectCorrectHelper; + void correctFontScale(tools::Long nNewFontScale) { maFont.SetAverageFontWidth(nNewFontScale); } + +public: + MetaFontAction(); + MetaFontAction(MetaFontAction const &) = default; + MetaFontAction(MetaFontAction &&) = default; + MetaFontAction & operator =(MetaFontAction const &) = delete; // due to MetaAction + MetaFontAction & operator =(MetaFontAction &&) = delete; // due to MetaAction +private: + virtual ~MetaFontAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + explicit MetaFontAction( const vcl::Font& ); + + virtual void Scale( double fScaleX, double fScaleY ) override; + + const vcl::Font& GetFont() const { return maFont; } + void SetFont(const vcl::Font& rFont) { maFont = rFont; } + +}; + +class VCL_DLLPUBLIC MetaPushAction final : public MetaAction +{ +private: + + vcl::PushFlags mnFlags; + +public: + MetaPushAction(); + MetaPushAction(MetaPushAction const &) = default; + MetaPushAction(MetaPushAction &&) = default; + MetaPushAction & operator =(MetaPushAction const &) = delete; // due to MetaAction + MetaPushAction & operator =(MetaPushAction &&) = delete; // due to MetaAction +private: + virtual ~MetaPushAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + explicit MetaPushAction( vcl::PushFlags nFlags ); + + vcl::PushFlags GetFlags() const { return mnFlags; } + void SetPushFlags(const vcl::PushFlags nFlags) { mnFlags = nFlags; } +}; + +class VCL_DLLPUBLIC MetaPopAction final : public MetaAction +{ +public: + + MetaPopAction(); + MetaPopAction(MetaPopAction const &) = default; + MetaPopAction(MetaPopAction &&) = default; + MetaPopAction & operator =(MetaPopAction const &) = delete; // due to MetaAction + MetaPopAction & operator =(MetaPopAction &&) = delete; // due to MetaAction +private: + virtual ~MetaPopAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; +}; + +class VCL_DLLPUBLIC MetaRasterOpAction final : public MetaAction +{ +private: + + RasterOp meRasterOp; + +public: + MetaRasterOpAction(); + MetaRasterOpAction(MetaRasterOpAction const &) = default; + MetaRasterOpAction(MetaRasterOpAction &&) = default; + MetaRasterOpAction & operator =(MetaRasterOpAction const &) = delete; // due to MetaAction + MetaRasterOpAction & operator =(MetaRasterOpAction &&) = delete; // due to MetaAction +private: + virtual ~MetaRasterOpAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + explicit MetaRasterOpAction( RasterOp eRasterOp ); + + RasterOp GetRasterOp() const { return meRasterOp; } + void SetRasterOp(const RasterOp eRasterOp) { meRasterOp = eRasterOp; } +}; + +class SAL_DLLPUBLIC_RTTI MetaTransparentAction final : public MetaAction +{ +private: + + tools::PolyPolygon maPolyPoly; + sal_uInt16 mnTransPercent; + +public: + MetaTransparentAction(); + MetaTransparentAction(MetaTransparentAction const &) = default; + MetaTransparentAction(MetaTransparentAction &&) = default; + MetaTransparentAction & operator =(MetaTransparentAction const &) = delete; // due to MetaAction + MetaTransparentAction & operator =(MetaTransparentAction &&) = delete; // due to MetaAction +private: + virtual ~MetaTransparentAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaTransparentAction( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransPercent ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const tools::PolyPolygon& GetPolyPolygon() const { return maPolyPoly; } + sal_uInt16 GetTransparence() const { return mnTransPercent; } + void SetPolyPolygon(const tools::PolyPolygon& rPolyPoly) { maPolyPoly = rPolyPoly; } + void SetTransparence(const sal_uInt16 nTransPercent) { mnTransPercent = nTransPercent; } + + bool IsTransparent() const override { return true; } +}; + +class SAL_DLLPUBLIC_RTTI MetaFloatTransparentAction final : public MetaAction +{ +private: + + GDIMetaFile maMtf; + Point maPoint; + Size maSize; + Gradient maGradient; + +public: + MetaFloatTransparentAction(); + MetaFloatTransparentAction(MetaFloatTransparentAction const &) = default; + MetaFloatTransparentAction(MetaFloatTransparentAction &&) = default; + MetaFloatTransparentAction & operator =(MetaFloatTransparentAction const &) = delete; // due to MetaAction + MetaFloatTransparentAction & operator =(MetaFloatTransparentAction &&) = delete; // due to MetaAction +private: + virtual ~MetaFloatTransparentAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaFloatTransparentAction( const GDIMetaFile& rMtf, const Point& rPos, + const Size& rSize, const Gradient& rGradient ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const GDIMetaFile& GetGDIMetaFile() const { return maMtf; } + const Point& GetPoint() const { return maPoint; } + const Size& GetSize() const { return maSize; } + const Gradient& GetGradient() const { return maGradient; } + void SetGDIMetaFile(const GDIMetaFile &rMtf) { maMtf = rMtf; } + void SetPoint(const Point& rPoint) { maPoint = rPoint; } + void SetSize(const Size& rSize) { maSize = rSize; } + void SetGradient(const Gradient& rGradient) { maGradient = rGradient; } + bool IsTransparent() const override { return true; } +}; + +class VCL_DLLPUBLIC MetaEPSAction final : public MetaAction +{ +private: + + GfxLink maGfxLink; + GDIMetaFile maSubst; + Point maPoint; + Size maSize; + +public: + MetaEPSAction(); + MetaEPSAction(MetaEPSAction const &) = default; + MetaEPSAction(MetaEPSAction &&) = default; + MetaEPSAction & operator =(MetaEPSAction const &) = delete; // due to MetaAction + MetaEPSAction & operator =(MetaEPSAction &&) = delete; // due to MetaAction +private: + virtual ~MetaEPSAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaEPSAction( const Point& rPoint, const Size& rSize, + const GfxLink& rGfxLink, const GDIMetaFile& rSubst ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + const GfxLink& GetLink() const { return maGfxLink; } + const GDIMetaFile& GetSubstitute() const { return maSubst; } + const Point& GetPoint() const { return maPoint; } + const Size& GetSize() const { return maSize; } + void SetLink(const GfxLink& rGfxLink) { maGfxLink = rGfxLink; } + void SetSubstitute(const GDIMetaFile& rSubst) { maSubst = rSubst; } + void SetPoint(const Point& rPoint) { maPoint = rPoint; } + void SetSize(const Size& rSize) { maSize = rSize; } +}; + +class VCL_DLLPUBLIC MetaRefPointAction final : public MetaAction +{ +private: + + Point maRefPoint; + bool mbSet; + +public: + MetaRefPointAction(); + MetaRefPointAction(MetaRefPointAction const &) = default; + MetaRefPointAction(MetaRefPointAction &&) = default; + MetaRefPointAction & operator =(MetaRefPointAction const &) = delete; // due to MetaAction + MetaRefPointAction & operator =(MetaRefPointAction &&) = delete; // due to MetaAction +private: + virtual ~MetaRefPointAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + MetaRefPointAction( const Point& rRefPoint, bool bSet ); + + const Point& GetRefPoint() const { return maRefPoint; } + void SetRefPoint(const Point& rRefPoint) { maRefPoint = rRefPoint; } + void SetSetting(const bool bSet) { mbSet = bSet; } + bool IsSetting() const { return mbSet; } +}; + +class VCL_DLLPUBLIC MetaCommentAction final : public MetaAction +{ +private: + + OString maComment; + sal_Int32 mnValue; + sal_uInt32 mnDataSize; + std::unique_ptr<sal_uInt8[]> + mpData; + + SAL_DLLPRIVATE void ImplInitDynamicData( const sal_uInt8* pData, sal_uInt32 nDataSize ); + +private: + virtual ~MetaCommentAction() override; + +public: + explicit MetaCommentAction(); + explicit MetaCommentAction( const MetaCommentAction& rAct ); + explicit MetaCommentAction( const OString& rComment, sal_Int32 nValue = 0, const sal_uInt8* pData = nullptr, sal_uInt32 nDataSize = 0 ); + + virtual void Move( tools::Long nHorzMove, tools::Long nVertMove ) override; + virtual void Scale( double fScaleX, double fScaleY ) override; + + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + const OString& GetComment() const { return maComment; } + sal_Int32 GetValue() const { return mnValue; } + sal_uInt32 GetDataSize() const { return mnDataSize; } + const sal_uInt8* GetData() const { return mpData.get(); } + void SetComment(const OString& rComment) { maComment = rComment; } + void SetValue(const sal_Int32 nValue) { mnValue = nValue; } + void SetDataSize(const sal_Int32 nDataSize) { mnDataSize = nDataSize; } + void SetData(const sal_uInt8* pData, const sal_uInt32 nDataSize) { ImplInitDynamicData(pData, nDataSize); } +}; + +class VCL_DLLPUBLIC MetaLayoutModeAction final : public MetaAction +{ +private: + + vcl::text::ComplexTextLayoutFlags mnLayoutMode; + +public: + MetaLayoutModeAction(); + MetaLayoutModeAction(MetaLayoutModeAction const &) = default; + MetaLayoutModeAction(MetaLayoutModeAction &&) = default; + MetaLayoutModeAction & operator =(MetaLayoutModeAction const &) = delete; // due to MetaAction + MetaLayoutModeAction & operator =(MetaLayoutModeAction &&) = delete; // due to MetaAction +private: + virtual ~MetaLayoutModeAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + explicit MetaLayoutModeAction( vcl::text::ComplexTextLayoutFlags nLayoutMode ); + + vcl::text::ComplexTextLayoutFlags GetLayoutMode() const { return mnLayoutMode; } + void SetLayoutMode(const vcl::text::ComplexTextLayoutFlags nLayoutMode) { mnLayoutMode = nLayoutMode; } +}; + +class VCL_DLLPUBLIC MetaTextLanguageAction final : public MetaAction +{ +private: + + LanguageType meTextLanguage; + +public: + MetaTextLanguageAction(); + MetaTextLanguageAction(MetaTextLanguageAction const &) = default; + MetaTextLanguageAction(MetaTextLanguageAction &&) = default; + MetaTextLanguageAction & operator =(MetaTextLanguageAction const &) = delete; // due to MetaAction + MetaTextLanguageAction & operator =(MetaTextLanguageAction &&) = delete; // due to MetaAction +private: + virtual ~MetaTextLanguageAction() override; +public: + virtual void Execute( OutputDevice* pOut ) override; + virtual rtl::Reference<MetaAction> Clone() const override; + + explicit MetaTextLanguageAction( LanguageType ); + + LanguageType GetTextLanguage() const { return meTextLanguage; } + void SetTextLanguage(const LanguageType eTextLanguage) { meTextLanguage = eTextLanguage; } +}; + +#endif // INCLUDED_VCL_METAACT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/metaactiontypes.hxx b/include/vcl/metaactiontypes.hxx new file mode 100644 index 000000000..5a8a70cae --- /dev/null +++ b/include/vcl/metaactiontypes.hxx @@ -0,0 +1,85 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF), under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_METAACTIONTYPES_HXX +#define INCLUDED_VCL_METAACTIONTYPES_HXX + +enum class MetaActionType +{ + NONE = 0, + PIXEL = 100, + POINT = 101, + LINE = 102, + RECT = 103, + ROUNDRECT = 104, + ELLIPSE = 105, + ARC = 106, + PIE = 107, + CHORD = 108, + POLYLINE = 109, + POLYGON = 110, + POLYPOLYGON = 111, + TEXT = 112, + TEXTARRAY = 113, + STRETCHTEXT = 114, + TEXTRECT = 115, + BMP = 116, + BMPSCALE = 117, + BMPSCALEPART = 118, + BMPEX = 119, + BMPEXSCALE = 120, + BMPEXSCALEPART = 121, + MASK = 122, + MASKSCALE = 123, + MASKSCALEPART = 124, + GRADIENT = 125, + HATCH = 126, + WALLPAPER = 127, + CLIPREGION = 128, + ISECTRECTCLIPREGION = 129, + ISECTREGIONCLIPREGION = 130, + MOVECLIPREGION = 131, + LINECOLOR = 132, + FILLCOLOR = 133, + TEXTCOLOR = 134, + TEXTFILLCOLOR = 135, + TEXTALIGN = 136, + MAPMODE = 137, + FONT = 138, + PUSH = 139, + POP = 140, + RASTEROP = 141, + Transparent = 142, + EPS = 143, + REFPOINT = 144, + TEXTLINECOLOR = 145, + TEXTLINE = 146, + FLOATTRANSPARENT = 147, + GRADIENTEX = 148, + LAYOUTMODE = 149, + TEXTLANGUAGE = 150, + OVERLINECOLOR = 151, + + COMMENT = 512, + LAST = COMMENT +}; + +#endif // INCLUDED_VCL_METAACTIONTYPES_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/metric.hxx b/include/vcl/metric.hxx new file mode 100644 index 000000000..1e03232d7 --- /dev/null +++ b/include/vcl/metric.hxx @@ -0,0 +1,109 @@ +/* -*- 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 . + */ + +#pragma once + +#include <sal/config.h> + +#include <tools/ref.hxx> +#include <tools/gen.hxx> + +#include <vcl/dllapi.h> +#include <vcl/font.hxx> + +class FontCharMap; +namespace vcl::font { class PhysicalFontFace; } + +typedef tools::SvRef<FontCharMap> FontCharMapRef; + +class VCL_DLLPUBLIC FontMetric : public vcl::Font +{ +public: + explicit FontMetric(); + FontMetric( const FontMetric& ); // TODO make this explicit + FontMetric(vcl::font::PhysicalFontFace const& rFace); + ~FontMetric() override; + + tools::Long GetAscent() const { return mnAscent; } + tools::Long GetDescent() const { return mnDescent; } + tools::Long GetInternalLeading() const { return mnIntLeading; } + tools::Long GetExternalLeading() const { return mnExtLeading; } + tools::Long GetLineHeight() const { return mnLineHeight; } // TODO this is ascent + descnt + tools::Long GetSlant() const { return mnSlant; } + tools::Long GetBulletOffset() const { return mnBulletOffset; } + tools::Long GetHangingBaseline() const { return mnHangingBaseline; } + + void SetAscent( tools::Long nAscent ) { mnAscent = nAscent; } + void SetDescent( tools::Long nDescent ) { mnDescent = nDescent; } + void SetExternalLeading( tools::Long nExtLeading ) { mnExtLeading = nExtLeading; } + void SetInternalLeading( tools::Long nIntLeading ) { mnIntLeading = nIntLeading; } + void SetLineHeight( tools::Long nHeight ) { mnLineHeight = nHeight; } // TODO this is ascent + descent + void SetSlant( tools::Long nSlant ) { mnSlant = nSlant; } + void SetBulletOffset( tools::Long nOffset ) { mnBulletOffset = nOffset; } + void SetHangingBaseline( tools::Long nBaseline ) { mnHangingBaseline = nBaseline; } + + bool IsFullstopCentered() const { return mbFullstopCentered; } + + void SetFullstopCenteredFlag( bool bCentered ) { mbFullstopCentered = bCentered; } + + using Font::operator=; + FontMetric& operator=( const FontMetric& rMetric ); + FontMetric& operator=( FontMetric&& rMetric ); + bool operator==( const FontMetric& rMetric ) const; + bool operator!=( const FontMetric& rMetric ) const + { return !operator==( rMetric ); } + + bool EqualIgnoreColor( const FontMetric& ) const; + + // Compute value usable as hash. + size_t GetHashValueIgnoreColor() const; + +private: + bool EqualNoBase( const FontMetric& ) const; + size_t GetHashValueNoBase() const; + tools::Long mnAscent; // Ascent + tools::Long mnDescent; // Descent + tools::Long mnIntLeading; // Internal Leading + tools::Long mnExtLeading; // External Leading + tools::Long mnLineHeight; // Ascent+Descent+EmphasisMark + tools::Long mnSlant; // Slant + tools::Long mnBulletOffset; // Offset for non-printing character + tools::Long mnHangingBaseline; // Offset from Romn baseline to hanging baseline. + + bool mbFullstopCentered; +}; + +template< typename charT, typename traits > +inline std::basic_ostream<charT, traits> & operator <<( + std::basic_ostream<charT, traits> & stream, const FontMetric& rMetric ) +{ + stream << "{" + << "name=" << "\"" << rMetric.GetFamilyName() << "\"" + << ",size=(" << rMetric.GetFontSize().Width() << "," << rMetric.GetFontSize().Height() << ")" + << ",ascent=" << rMetric.GetAscent() + << ",descent=" << rMetric.GetDescent() + << ",intLeading=" << rMetric.GetInternalLeading() + << ",extLeading=" << rMetric.GetExternalLeading() + << ",lineHeight=" << rMetric.GetLineHeight() + << ",slant=" << rMetric.GetSlant() + << "}"; + return stream; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/mnemonic.hxx b/include/vcl/mnemonic.hxx new file mode 100644 index 000000000..23ea1d1e6 --- /dev/null +++ b/include/vcl/mnemonic.hxx @@ -0,0 +1,75 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_MNEMONIC_HXX +#define INCLUDED_VCL_MNEMONIC_HXX + +#include <com/sun/star/uno/Reference.h> +#include <rtl/ustring.hxx> +#include <vcl/dllapi.h> + +namespace com::sun::star::i18n { class XCharacterClassification; } + +// Mnemonic Chars, which we want support +// Latin 0-9 +#define MNEMONIC_RANGE_1_START 0x30 +#define MNEMONIC_RANGE_1_END 0x39 +// Latin a-z +#define MNEMONIC_RANGE_2_START 0x61 +#define MNEMONIC_RANGE_2_END 0x7A +// Cyrillic +#define MNEMONIC_RANGE_3_START 0x0430 +#define MNEMONIC_RANGE_3_END 0x044F +// Greek +#define MNEMONIC_RANGE_4_START 0x03B1 +#define MNEMONIC_RANGE_4_END 0x03CB +#define MNEMONIC_RANGES 4 +#define MAX_MNEMONICS ((MNEMONIC_RANGE_1_END-MNEMONIC_RANGE_1_START+1)+\ + (MNEMONIC_RANGE_2_END-MNEMONIC_RANGE_2_START+1)+\ + (MNEMONIC_RANGE_3_END-MNEMONIC_RANGE_3_START+1)+\ + (MNEMONIC_RANGE_4_END-MNEMONIC_RANGE_4_START+1)) + +#define MNEMONIC_CHAR u'~' +#define MNEMONIC_INDEX_NOTFOUND (sal_uInt16(0xFFFF)) + + +class VCL_DLLPUBLIC MnemonicGenerator +{ + sal_Unicode m_cMnemonic; + // 0 == Mnemonic; >0 == count of characters + sal_uInt8 maMnemonics[MAX_MNEMONICS]; + css::uno::Reference< css::i18n::XCharacterClassification > mxCharClass; + + SAL_DLLPRIVATE static sal_uInt16 ImplGetMnemonicIndex( sal_Unicode c ); + SAL_DLLPRIVATE sal_Unicode ImplFindMnemonic( const OUString& rKey ); + +public: + MnemonicGenerator(sal_Unicode cMnemonic = MNEMONIC_CHAR); + + void RegisterMnemonic( const OUString& rKey ); + [[nodiscard]] OUString CreateMnemonic(const OUString& rKey); + css::uno::Reference< css::i18n::XCharacterClassification > const & GetCharClass(); + + // returns a string where all '~'-characters and CJK mnemonics of the form (~A) are completely removed + static OUString EraseAllMnemonicChars( const OUString& rStr ); +}; + +#endif // INCLUDED_VCL_MNEMONIC_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/mtfxmldump.hxx b/include/vcl/mtfxmldump.hxx new file mode 100644 index 000000000..9970ea8a0 --- /dev/null +++ b/include/vcl/mtfxmldump.hxx @@ -0,0 +1,63 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_MTFXMLDUMP_HXX +#define INCLUDED_VCL_MTFXMLDUMP_HXX + +#include <sal/config.h> +#include <vcl/dllapi.h> +#include <vcl/metaactiontypes.hxx> +#include <o3tl/enumarray.hxx> + +namespace tools +{ +class XmlWriter; +} +class GDIMetaFile; +class SvStream; + +enum class MetaActionType; + +/** + * Class that is used for testing of the decomposition into shapes. Used like + * this: + * + * std::shared_ptr<GDIMetaFile> xMetaFile = xDocShRef->GetPreviewMetaFile(); + * MetafileXmlDump dumper; + * xmlDocUniquePtr pXmlDoc = XmlTestTools::dumpAndParse(dumper, *xMetaFile); + * CPPUNIT_ASSERT(pXmlDoc); + * + * assertXPath(pXmlDoc, "/metafile/push[1]/push[1]/textarray[1]", "x", "2093"); + * + * To see the dump to be able to create the assertXPath() call, use: + * + * xMetaFile->dumpAsXml(); + * + * and check the output in /tmp/metafile.xml + */ +class VCL_DLLPUBLIC MetafileXmlDump final +{ + o3tl::enumarray<MetaActionType, bool> maFilter; + + void writeXml(const GDIMetaFile& rMetaFile, tools::XmlWriter& rWriter); + +public: + MetafileXmlDump(); + + void filterActionType(const MetaActionType nActionType, bool bShouldFilter); + void filterAllActionTypes(); + + /** The actual result that will be used for testing. + */ + void dump(const GDIMetaFile& rMetaFile, SvStream& rStream); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/naturalsort.hxx b/include/vcl/naturalsort.hxx new file mode 100644 index 000000000..1883bb357 --- /dev/null +++ b/include/vcl/naturalsort.hxx @@ -0,0 +1,20 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#pragma once + +#include <vcl/dllapi.h> +#include <rtl/ustring.hxx> + +namespace vcl +{ +VCL_DLLPUBLIC sal_Int32 NaturalSortCompare(const OUString& rA, const OUString& rB); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/notebookbar/NotebookBarAddonsMerger.hxx b/include/vcl/notebookbar/NotebookBarAddonsMerger.hxx new file mode 100644 index 000000000..87c843620 --- /dev/null +++ b/include/vcl/notebookbar/NotebookBarAddonsMerger.hxx @@ -0,0 +1,62 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_NOTEBOOKBARADDONSMERGER_HXX +#define INCLUDED_VCL_NOTEBOOKBARADDONSMERGER_HXX + +#include <vcl/builder.hxx> +#include <vcl/window.hxx> +#include <vcl/image.hxx> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/frame/XFrame.hpp> +#include <com/sun/star/uno/Sequence.h> +#include <vector> + +class Menu; + +struct NotebookBarAddonsItem +{ + std::vector<Image> aImageValues; + std::vector<css::uno::Sequence<css::uno::Sequence<css::beans::PropertyValue>>> aAddonValues; +}; + +struct AddonNotebookBarItem +{ + OUString sCommandURL; + OUString sLabel; + OUString sTarget; + OUString sContext; + OUString sControlType; + sal_uInt16 nWidth; + OUString sStyle; +}; + +namespace NotebookBarAddonsMerger +{ +void MergeNotebookBarAddons(vcl::Window* pParent, const VclBuilder::customMakeWidget& pFunction, + const css::uno::Reference<css::frame::XFrame>& rFrame, + const NotebookBarAddonsItem& aNotebookBarAddonsItem, + VclBuilder::stringmap& rVec); +void MergeNotebookBarMenuAddons(Menu* pPopupMenu, sal_Int16 nItemId, const OString& sItemIdName, + NotebookBarAddonsItem& aNotebookBarAddonsItem); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/notebookbar/notebookbar.hxx b/include/vcl/notebookbar/notebookbar.hxx new file mode 100644 index 000000000..635bea058 --- /dev/null +++ b/include/vcl/notebookbar/notebookbar.hxx @@ -0,0 +1,77 @@ +/* -*- 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/. + */ + +#pragma once + +#include <vcl/syswin.hxx> +#include <vcl/ctrl.hxx> +#include <vcl/notebookbar/NotebookBarAddonsMerger.hxx> +#include <vcl/settings.hxx> +#include <set> +#include <vector> + +namespace com::sun::star::ui { class XContextChangeEventListener; } + +class NotebookbarContextControl; +class SystemWindow; +class SfxViewShell; + +/// This implements Widget Layout-based notebook-like menu bar. +class VCL_DLLPUBLIC NotebookBar final : public Control, public VclBuilderContainer +{ +friend class NotebookBarContextChangeEventListener; +public: + NotebookBar(Window* pParent, const OString& rID, const OUString& rUIXMLDescription, + const css::uno::Reference<css::frame::XFrame>& rFrame, + const NotebookBarAddonsItem& aNotebookBarAddonsItem); + virtual ~NotebookBar() override; + virtual void dispose() override; + + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + virtual Size GetOptimalSize() const override; + virtual void setPosSizePixel(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, PosSizeFlags nFlags = PosSizeFlags::All) override; + virtual void Resize() override; + + void SetSystemWindow(SystemWindow* pSystemWindow); + + void StateChanged(const StateChangedType nStateChange ) override; + + void DataChanged(const DataChangedEvent& rDCEvt) override; + + void ControlListenerForCurrentController(bool bListen); + void StopListeningAllControllers(); + + bool IsWelded() const { return m_bIsWelded; } + VclPtr<vcl::Window>& GetMainContainer() { return m_xVclContentArea; } + const OUString & GetUIFilePath() const { return m_sUIXMLDescription; } + void SetDisposeCallback(const Link<const SfxViewShell*, void> rDisposeCallback, const SfxViewShell* pViewShell); + +private: + VclPtr<SystemWindow> m_pSystemWindow; + css::uno::Reference<css::ui::XContextChangeEventListener> m_pEventListener; + std::set<css::uno::Reference<css::frame::XController>> m_alisteningControllers; + std::vector<NotebookbarContextControl*> m_pContextContainers; + css::uno::Reference<css::frame::XFrame> mxFrame; + const SfxViewShell* m_pViewShell; + + VclPtr<vcl::Window> m_xVclContentArea; + bool m_bIsWelded; + OUString m_sUIXMLDescription; + Link<const SfxViewShell*, void> m_rDisposeLink; + + AllSettings DefaultSettings; + AllSettings PersonaSettings; + + void UpdateBackground(); + + void UpdateDefaultSettings(); + void UpdatePersonaSettings(); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/oldprintadaptor.hxx b/include/vcl/oldprintadaptor.hxx new file mode 100644 index 000000000..3b74b0d76 --- /dev/null +++ b/include/vcl/oldprintadaptor.hxx @@ -0,0 +1,53 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_OLDPRINTADAPTOR_HXX +#define INCLUDED_VCL_OLDPRINTADAPTOR_HXX + +#include <config_options.h> +#include <memory> +#include <vcl/print.hxx> + +namespace weld +{ + class Window; +} + +namespace vcl +{ + struct ImplOldStyleAdaptorData; + class UNLESS_MERGELIBS(VCL_DLLPUBLIC) OldStylePrintAdaptor final : public PrinterController + { + std::unique_ptr<ImplOldStyleAdaptorData> mpData; + public: + OldStylePrintAdaptor(const VclPtr<Printer>&, weld::Window*); + virtual ~OldStylePrintAdaptor() override; + + void StartPage(); + void EndPage(); + + virtual int getPageCount() const override; + virtual css::uno::Sequence< css::beans::PropertyValue > getPageParameters( int i_nPage ) const override; + virtual void printPage( int i_nPage ) const override; + }; +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/opengl/OpenGLContext.hxx b/include/vcl/opengl/OpenGLContext.hxx new file mode 100644 index 000000000..428df1266 --- /dev/null +++ b/include/vcl/opengl/OpenGLContext.hxx @@ -0,0 +1,130 @@ +/* -*- 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/. + */ + +#pragma once + +#include <vcl/dllapi.h> +#include <vcl/sysdata.hxx> +#include <vcl/vclptr.hxx> +#include <rtl/ref.hxx> + +class Point; +class Size; +class SystemChildWindow; +namespace vcl { class Window; } + +/// Holds the information of our new child window +struct VCL_DLLPUBLIC GLWindow +{ + unsigned int Width; + unsigned int Height; + bool bMultiSampleSupported; + + GLWindow() + : Width(0) + , Height(0) + , bMultiSampleSupported(false) + { + } + + virtual bool Synchronize(bool bOnoff) const; + + virtual ~GLWindow(); +}; + +class VCL_DLLPUBLIC OpenGLContext +{ + friend class OpenGLTests; +protected: + OpenGLContext(); +public: + static rtl::Reference<OpenGLContext> Create(); + virtual ~OpenGLContext(); + + // Avoid implicitly defined copy constructors/assignments for the DLLPUBLIC class (they may + // require forward-declared classes used internally to be defined in places using OpenGLContext) + OpenGLContext(const OpenGLContext&) = delete; + OpenGLContext(OpenGLContext&&) = delete; + OpenGLContext& operator=(const OpenGLContext&) = delete; + OpenGLContext& operator=(OpenGLContext&&) = delete; + + void acquire() { mnRefCount++; } + void release() { if ( --mnRefCount == 0 ) delete this; } + void dispose(); + + void requestLegacyContext(); + + bool init(vcl::Window* pParent); + + void reset(); + + /// Is this GL context the current context ? + virtual bool isCurrent(); + /// Is any GL context the current context ? + virtual bool isAnyCurrent(); + /// release bound resources from the current context + static void clearCurrent(); + /// release contexts etc. before (potentially) allowing another thread run. + static void prepareForYield(); + /// Is there a current GL context ? + static bool hasCurrent(); + + /// make this GL context current - so it is implicit in subsequent GL calls + virtual void makeCurrent(); + /// Put this GL context to the end of the context list. + void registerAsCurrent(); + /// reset the GL context so this context is not implicit in subsequent GL calls. + virtual void resetCurrent(); + /// unbind the GL_FRAMEBUFFER to its default state, needed for gtk3 + virtual void restoreDefaultFramebuffer(); + virtual void swapBuffers(); + virtual void sync(); + void show(); + + void setWinPosAndSize(const Point &rPos, const Size& rSize); + virtual const GLWindow& getOpenGLWindow() const = 0; + + SystemChildWindow* getChildWindow(); + const SystemChildWindow* getChildWindow() const; + + bool isInitialized() const + { + return mbInitialized; + } + + virtual SystemWindowData generateWinData(vcl::Window* pParent, bool bRequestLegacyContext); + +private: + virtual void initWindow(); + virtual void destroyCurrentContext(); + virtual void adjustToNewSize(); + +protected: + bool InitGL(); + static void InitGLDebugging(); + static void InitChildWindow(SystemChildWindow *pChildWindow); + static void BuffersSwapped(); + virtual GLWindow& getModifiableOpenGLWindow() = 0; + virtual bool ImplInit(); + + VclPtr<vcl::Window> m_xWindow; + VclPtr<vcl::Window> mpWindow; //points to m_pWindow or the parent window, don't delete it + VclPtr<SystemChildWindow> m_pChildWindow; + bool mbInitialized; + int mnRefCount; + bool mbRequestLegacyContext; + +public: + + // Don't hold references to ourselves: + OpenGLContext *mpPrevContext; + OpenGLContext *mpNextContext; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/opengl/OpenGLHelper.hxx b/include/vcl/opengl/OpenGLHelper.hxx new file mode 100644 index 000000000..45383bd6f --- /dev/null +++ b/include/vcl/opengl/OpenGLHelper.hxx @@ -0,0 +1,124 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_OPENGL_OPENGLHELPER_HXX +#define INCLUDED_VCL_OPENGL_OPENGLHELPER_HXX + +#include <epoxy/gl.h> +#include <sal/detail/log.h> +#include <vcl/dllapi.h> +#include <vcl/bitmapex.hxx> + +#include <rtl/ustring.hxx> +#include <sstream> +#include <string_view> + +/// Helper to do a SAL_INFO as well as a GL log. +#define VCL_GL_INFO(stream) \ + do { \ + if (SAL_DETAIL_ENABLE_LOG_INFO) \ + { \ + ::std::ostringstream detail_stream; \ + detail_stream << stream; \ + OpenGLHelper::debugMsgStream(detail_stream); \ + } \ + } while (false) + +/// Helper to do a SAL_WARN as well as a GL log. +#define VCL_GL_WARN(stream) \ + do { \ + if (SAL_DETAIL_ENABLE_LOG_INFO) \ + { \ + ::std::ostringstream detail_stream; \ + detail_stream << stream; \ + OpenGLHelper::debugMsgStreamWarn(detail_stream); \ + } \ + } while (false) + +// All member functions static and VCL_DLLPUBLIC. Basically a glorified namespace. +struct VCL_DLLPUBLIC OpenGLHelper +{ + OpenGLHelper() = delete; // Should not be instantiated + +public: + +#if defined _WIN32 + static OString GetDigest(const OUString& rVertexShaderName, const OUString& rFragmentShaderName, std::string_view preamble ); +#endif + + static GLint LoadShaders(const OUString& rVertexShaderName, const OUString& rFragmentShaderName, const OUString& rGeometryShaderName, std::string_view preamble, std::string_view rDigest ); + static GLint LoadShaders(const OUString& rVertexShaderName, const OUString& rFragmentShaderName, std::string_view preamble, std::string_view rDigest ); + static GLint LoadShaders(const OUString& rVertexShaderName, const OUString& rFragmentShaderName, const OUString& rGeometryShaderName); + static GLint LoadShaders(const OUString& rVertexShaderName, const OUString& rFragmentShaderName); + + /** + * The caller is responsible for allocating the memory for the buffer before calling + * this method. The buffer size is assumed to be 4*width*height and the format + * to be OptimalBufferFormat(). + **/ + static BitmapEx ConvertBufferToBitmapEx(const sal_uInt8* const pBuffer, tools::Long nWidth, tools::Long nHeight); + /** + * Returns the optimal buffer format for OpenGL (GL_BGRA or GL_RGBA). + **/ + static GLenum OptimalBufferFormat(); + static void renderToFile(tools::Long nWidth, tools::Long nHeight, const OUString& rFileName); + + static const char* GLErrorString(GLenum errorCode); + + /** + * The caller is responsible for deleting the buffer objects identified by + * nFramebufferId, nRenderbufferDepthId and nRenderbufferColorId. + * This create a buffer for rendering to texture and should be freed with + * glDeleteTextures. + * + * @param nWidth Width of frame + * @param nHeight Height of frame + * @param nFramebufferId FrameBuffer ID + * @param nRenderbufferDepthId RenderBuffer's depth ID + * @param nRenderbufferColorId RenderBuffer's color ID + */ + static void createFramebuffer(tools::Long nWidth, tools::Long nHeight, GLuint& nFramebufferId, + GLuint& nRenderbufferDepthId, GLuint& nRenderbufferColorId); + + /// Get OpenGL version (needs a context) + static float getGLVersion(); + + static void checkGLError(const char* aFile, size_t nLine); + + /** + * Insert a glDebugMessage into the queue - helpful for debugging + * with apitrace to annotate the output and correlate it with code. + */ +#if defined __GNUC__ + __attribute__ ((format (printf, 2, 3))) +#endif + static void debugMsgPrint(const int nType, const char *pFormat, ...); + static void debugMsgStream(std::ostringstream const &pStream); + static void debugMsgStreamWarn(std::ostringstream const &pStream); + + /** + * checks if the device/driver pair is on our OpenGL denylist + */ + static bool isDeviceDenylisted(); + + /** + * checks if the system supports all features that are necessary for the OpenGL support + */ + static bool supportsOpenGL(); +}; + +#ifdef SAL_LOG_WARN +#define CHECK_GL_ERROR() OpenGLHelper::checkGLError(__FILE__, __LINE__) +#else +#define CHECK_GL_ERROR() do { } while (false) +#endif + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/opengl/OpenGLWrapper.hxx b/include/vcl/opengl/OpenGLWrapper.hxx new file mode 100644 index 000000000..3711b3fd4 --- /dev/null +++ b/include/vcl/opengl/OpenGLWrapper.hxx @@ -0,0 +1,31 @@ +/* -*- 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/. + */ + +// Fully wrapped methods that have no exotic GL header deps. + +#ifndef INCLUDED_VCL_OPENGL_OPENGLWRAPPER_HXX +#define INCLUDED_VCL_OPENGL_OPENGLWRAPPER_HXX + +#include <config_features.h> +#include <vcl/dllapi.h> + +// All member functions static and VCL_DLLPUBLIC. Basically a glorified namespace. +struct VCL_DLLPUBLIC OpenGLWrapper +{ + OpenGLWrapper() = delete; // Should not be instantiated + +#if HAVE_FEATURE_UI + /** + * Returns the number of times OpenGL buffers have been swapped. + */ + static sal_Int64 getBufferSwapCounter(); +#endif +}; + +#endif // INCLUDED_VCL_OPENGL_OPENGLWRAPPER_HXX diff --git a/include/vcl/outdev.hxx b/include/vcl/outdev.hxx new file mode 100644 index 000000000..ea14e3d01 --- /dev/null +++ b/include/vcl/outdev.hxx @@ -0,0 +1,1930 @@ +/* -*- 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 . + */ + +#pragma once + +#include <sal/config.h> + +#include <o3tl/span.hxx> +#include <tools/gen.hxx> +#include <tools/ref.hxx> +#include <tools/solar.h> +#include <tools/color.hxx> +#include <tools/poly.hxx> +#include <vcl/bitmap.hxx> +#include <vcl/cairo.hxx> +#include <vcl/devicecoordinate.hxx> +#include <vcl/dllapi.h> +#include <vcl/font.hxx> +#include <vcl/region.hxx> +#include <vcl/rendercontext/AddFontSubstituteFlags.hxx> +#include <vcl/rendercontext/AntialiasingFlags.hxx> +#include <vcl/rendercontext/SystemTextColorFlags.hxx> +#include <vcl/rendercontext/DrawGridFlags.hxx> +#include <vcl/rendercontext/DrawImageFlags.hxx> +#include <vcl/rendercontext/DrawModeFlags.hxx> +#include <vcl/rendercontext/DrawTextFlags.hxx> +#include <vcl/rendercontext/GetDefaultFontFlags.hxx> +#include <vcl/rendercontext/ImplMapRes.hxx> +#include <vcl/rendercontext/InvertFlags.hxx> +#include <vcl/rendercontext/RasterOp.hxx> +#include <vcl/rendercontext/SalLayoutFlags.hxx> +#include <vcl/rendercontext/State.hxx> +#include <vcl/mapmod.hxx> +#include <vcl/wall.hxx> +#include <vcl/metaactiontypes.hxx> +#include <vcl/salnativewidgets.hxx> +#include <vcl/vclreferencebase.hxx> + +#include <basegfx/numeric/ftools.hxx> +#include <basegfx/vector/b2enums.hxx> +#include <basegfx/polygon/b2dpolypolygon.hxx> + +#include <unotools/fontdefs.hxx> +#include <cppuhelper/weakref.hxx> + +#include <com/sun/star/drawing/LineCap.hpp> +#include <com/sun/star/uno/Reference.h> +#include <com/sun/star/awt/DeviceInfo.hpp> + +#include <memory> +#include <string_view> +#include <vector> + +struct ImplOutDevData; +class LogicalFontInstance; +struct SystemGraphicsData; +class ImplFontCache; +class ImplMultiTextLineInfo; +class SalGraphics; +class Gradient; +class Hatch; +class AllSettings; +class BitmapReadAccess; +class BitmapEx; +class Image; +class TextRectInfo; +class FontMetric; +class GDIMetaFile; +class GfxLink; +namespace tools { + class Line; +} +class LineInfo; +class AlphaMask; +class FontCharMap; +class SalLayout; +class VirtualDevice; +struct SalTwoRect; +class Printer; +class VCLXGraphics; +class OutDevStateStack; +class SalLayoutGlyphs; + +namespace vcl +{ + class ExtOutDevData; + class ITextLayout; + struct FontCapabilities; + class Window; + class WindowOutputDevice; + namespace font { + struct Feature; + class PhysicalFontCollection; + class PhysicalFontFaceCollection; + } + + namespace text { + class ImplLayoutArgs; + class TextLayoutCache; + } +} + +namespace basegfx { + class B2DHomMatrix; + class B2DPolygon; + class B2IVector; + typedef B2IVector B2ISize; +} + +namespace com::sun::star::awt { + class XGraphics; +} + +namespace com::sun::star::rendering { + class XCanvas; + class XSpriteCanvas; +} +namespace com::sun::star::linguistic2 { + class XHyphenator; +} +namespace com::sun::star::i18n { + class XBreakIterator; +} + +#if defined UNX +#define GLYPH_FONT_HEIGHT 128 +#else +#define GLYPH_FONT_HEIGHT 256 +#endif + +// OutputDevice-Types + +enum OutDevType { OUTDEV_WINDOW, OUTDEV_PRINTER, OUTDEV_VIRDEV, OUTDEV_PDF }; + +enum class OutDevViewType { DontKnow, PrintPreview, SlideShow }; + +// OutputDevice + +typedef tools::SvRef<FontCharMap> FontCharMapRef; + +BmpMirrorFlags AdjustTwoRect( SalTwoRect& rTwoRect, const Size& rSizePix ); +void AdjustTwoRect( SalTwoRect& rTwoRect, const tools::Rectangle& rValidSrcRect ); + +class OutputDevice; + +namespace vcl { + typedef OutputDevice RenderContext; +} + +VCL_DLLPUBLIC void InvertFocusRect(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect); + +typedef struct _cairo_surface cairo_surface_t; + +/** +* Some things multiple-inherit from VclAbstractDialog and OutputDevice, +* so we need to use virtual inheritance to keep the referencing counting +* OK. +*/ +class SAL_WARN_UNUSED VCL_DLLPUBLIC OutputDevice : public virtual VclReferenceBase +{ + friend class Printer; + friend class VirtualDevice; + friend class vcl::Window; + friend class vcl::WindowOutputDevice; + friend class WorkWindow; + friend void ImplHandleResize( vcl::Window* pWindow, tools::Long nNewWidth, tools::Long nNewHeight ); + +private: + OutputDevice(const OutputDevice&) = delete; + OutputDevice& operator=(const OutputDevice&) = delete; + + mutable SalGraphics* mpGraphics; ///< Graphics context to draw on + mutable VclPtr<OutputDevice> mpPrevGraphics; ///< Previous output device in list + mutable VclPtr<OutputDevice> mpNextGraphics; ///< Next output device in list + GDIMetaFile* mpMetaFile; + mutable rtl::Reference<LogicalFontInstance> mpFontInstance; + mutable std::unique_ptr<vcl::font::PhysicalFontFaceCollection> mpFontFaceCollection; + std::vector<vcl::State> maOutDevStateStack; + std::unique_ptr<ImplOutDevData> mpOutDevData; + std::vector< VCLXGraphics* >* mpUnoGraphicsList; + vcl::ExtOutDevData* mpExtOutDevData; + // The canvas interface for this output device. Is persistent after the first GetCanvas() call + mutable css::uno::WeakReference< css::rendering::XCanvas > mxCanvas; + + // TEMP TEMP TEMP + VclPtr<VirtualDevice> mpAlphaVDev; + + /// Additional output pixel offset, applied in LogicToPixel (used by SetPixelOffset/GetPixelOffset) + tools::Long mnOutOffOrigX; + /// Additional output offset in _logical_ coordinates, applied in PixelToLogic (used by SetPixelOffset/GetPixelOffset) + tools::Long mnOutOffLogicX; + /// Additional output pixel offset, applied in LogicToPixel (used by SetPixelOffset/GetPixelOffset) + tools::Long mnOutOffOrigY; + /// Additional output offset in _logical_ coordinates, applied in PixelToLogic (used by SetPixelOffset/GetPixelOffset) + tools::Long mnOutOffLogicY; + /// Output offset for device output in pixel (pseudo window offset within window system's frames) + tools::Long mnOutOffX; + /// Output offset for device output in pixel (pseudo window offset within window system's frames) + tools::Long mnOutOffY; + tools::Long mnOutWidth; + tools::Long mnOutHeight; + sal_Int32 mnDPIX; + sal_Int32 mnDPIY; + sal_Int32 mnDPIScalePercentage; ///< For HiDPI displays, we want to draw elements for a percentage larger + /// font specific text alignment offsets in pixel units + mutable tools::Long mnTextOffX; + mutable tools::Long mnTextOffY; + mutable tools::Long mnEmphasisAscent; + mutable tools::Long mnEmphasisDescent; + DrawModeFlags mnDrawMode; + vcl::text::ComplexTextLayoutFlags mnTextLayoutMode; + ImplMapRes maMapRes; + const OutDevType meOutDevType; + OutDevViewType meOutDevViewType; + vcl::Region maRegion; // contains the clip region, see SetClipRegion(...) + Color maLineColor; + Color maFillColor; + vcl::Font maFont; + Color maTextColor; + Color maTextLineColor; + Color maOverlineColor; + RasterOp meRasterOp; + Wallpaper maBackground; + std::unique_ptr<AllSettings> mxSettings; + MapMode maMapMode; + Point maRefPoint; + AntialiasingFlags mnAntialiasing; + LanguageType meTextLanguage; + bool mbTextRenderModeForResolutionIndependentLayout; + + mutable bool mbMap : 1; + mutable bool mbClipRegion : 1; + mutable bool mbBackground : 1; + mutable bool mbOutput : 1; + mutable bool mbDevOutput : 1; + mutable bool mbOutputClipped : 1; + mutable bool mbLineColor : 1; + mutable bool mbFillColor : 1; + mutable bool mbInitLineColor : 1; + mutable bool mbInitFillColor : 1; + mutable bool mbInitFont : 1; + mutable bool mbInitTextColor : 1; + mutable bool mbInitClipRegion : 1; + mutable bool mbClipRegionSet : 1; + mutable bool mbNewFont : 1; + mutable bool mbTextLines : 1; + mutable bool mbTextSpecial : 1; + mutable bool mbRefPoint : 1; + mutable bool mbEnableRTL : 1; + +protected: + mutable std::shared_ptr<vcl::font::PhysicalFontCollection> mxFontCollection; + mutable std::shared_ptr<ImplFontCache> mxFontCache; + + /** @name Initialization and accessor functions + */ + ///@{ + +protected: + OutputDevice(OutDevType eOutDevType); + virtual ~OutputDevice() override; + virtual void dispose() override; + +public: + + /** Get the graphic context that the output device uses to draw on. + + If no graphics device exists, then initialize it. + + @returns SalGraphics instance. + */ + SalGraphics const *GetGraphics() const; + SalGraphics* GetGraphics(); + + void SetConnectMetaFile( GDIMetaFile* pMtf ); + GDIMetaFile* GetConnectMetaFile() const { return mpMetaFile; } + + virtual void SetSettings( const AllSettings& rSettings ); + const AllSettings& GetSettings() const { return *mxSettings; } + + SystemGraphicsData GetSystemGfxData() const; + OUString GetRenderBackendName() const; + + // Used by the canvas module. Despite the name it does not always return true if Cairo is supported. + bool SupportsCairo() const; + /// Create Surface from given cairo surface + cairo::SurfaceSharedPtr CreateSurface(const cairo::CairoSurfaceSharedPtr& rSurface) const; + /// Create surface with given dimensions + cairo::SurfaceSharedPtr CreateSurface(int x, int y, int width, int height) const; + /// Create Surface for given bitmap data + cairo::SurfaceSharedPtr CreateBitmapSurface(const BitmapSystemData& rData, const Size& rSize) const; + /// Return native handle for underlying surface + css::uno::Any GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& rSurface, const basegfx::B2ISize& rSize) const; + css::uno::Any GetSystemGfxDataAny() const; + + void SetRefPoint(); + void SetRefPoint( const Point& rRefPoint ); + const Point& GetRefPoint() const { return maRefPoint; } + bool IsRefPoint() const { return mbRefPoint; } + + virtual bool IsScreenComp() const { return true; } + + virtual sal_uInt16 GetBitCount() const; + + Size GetOutputSizePixel() const + { return Size( mnOutWidth, mnOutHeight ); } + tools::Long GetOutputWidthPixel() const { return mnOutWidth; } + tools::Long GetOutputHeightPixel() const { return mnOutHeight; } + tools::Long GetOutOffXPixel() const { return mnOutOffX; } + tools::Long GetOutOffYPixel() const { return mnOutOffY; } + void SetOutOffXPixel(tools::Long nOutOffX); + void SetOutOffYPixel(tools::Long nOutOffY); + Point GetOutputOffPixel() const + { return Point( mnOutOffX, mnOutOffY ); } + tools::Rectangle GetOutputRectPixel() const + { return tools::Rectangle(GetOutputOffPixel(), GetOutputSizePixel() ); } + + Size GetOutputSize() const + { return PixelToLogic( GetOutputSizePixel() ); } + + css::uno::Reference< css::awt::XGraphics > + CreateUnoGraphics(); + std::vector< VCLXGraphics* > *GetUnoGraphicsList() const { return mpUnoGraphicsList; } + std::vector< VCLXGraphics* > *CreateUnoGraphicsList(); + + virtual size_t GetSyncCount() const { return 0xffffffff; } + + /// request XCanvas render interface + css::uno::Reference< css::rendering::XCanvas > GetCanvas() const; + /// request XSpriteCanvas render interface + css::uno::Reference< css::rendering::XSpriteCanvas > GetSpriteCanvas() const; + +protected: + + /** Acquire a graphics device that the output device uses to draw on. + + There is an LRU of OutputDevices that is used to get the graphics. The + actual creation of a SalGraphics instance is done via the SalFrame + implementation. + + However, the SalFrame instance will only return a valid SalGraphics + instance if it is not in use or there wasn't one in the first place. When + this happens, AcquireGraphics finds the least recently used OutputDevice + in a different frame and "steals" it (releases it then starts using it). + + If there are no frames to steal an OutputDevice's SalGraphics instance from + then it blocks until the graphics is released. + + Once it has acquired a graphics instance, then we add the OutputDevice to + the LRU. + + @returns true if was able to initialize the graphics device, false otherwise. + */ + virtual bool AcquireGraphics() const = 0; + + /** Release the graphics device, and remove it from the graphics device + list. + + @param bRelease Determines whether to release the fonts of the + physically released graphics device. + */ + virtual void ReleaseGraphics( bool bRelease = true ) = 0; + ///@} + + + /** @name Helper functions + */ + ///@{ + +public: + + /** Get the output device's DPI x-axis value. + + @returns x-axis DPI value + */ + SAL_DLLPRIVATE sal_Int32 GetDPIX() const { return mnDPIX; } + + /** Get the output device's DPI y-axis value. + + @returns y-axis DPI value + */ + SAL_DLLPRIVATE sal_Int32 GetDPIY() const { return mnDPIY; } + + SAL_DLLPRIVATE void SetDPIX( sal_Int32 nDPIX ) { mnDPIX = nDPIX; } + SAL_DLLPRIVATE void SetDPIY( sal_Int32 nDPIY ) { mnDPIY = nDPIY; } + + float GetDPIScaleFactor() const + { + return mnDPIScalePercentage / 100.0f; + } + + sal_Int32 GetDPIScalePercentage() const + { + return mnDPIScalePercentage; + } + + OutDevType GetOutDevType() const { return meOutDevType; } + virtual bool IsVirtual() const; + + /** Query an OutputDevice to see whether it supports a specific operation + + @returns true if operation supported, else false + */ + bool SupportsOperation( OutDevSupportType ) const; + + void SetExtOutDevData( vcl::ExtOutDevData* pExtOutDevData ) { mpExtOutDevData = pExtOutDevData; } + vcl::ExtOutDevData* GetExtOutDevData() const { return mpExtOutDevData; } + + ///@} + +public: + virtual Size GetButtonBorderSize() { return Size(1, 1); }; + virtual Color GetMonochromeButtonColor() { return COL_WHITE; } + + /** @name Direct OutputDevice drawing functions + */ + ///@{ + +public: + virtual void Flush() {} + + virtual void DrawOutDev( + const Point& rDestPt, const Size& rDestSize, + const Point& rSrcPt, const Size& rSrcSize ); + + virtual void DrawOutDev( + const Point& rDestPt, const Size& rDestSize, + const Point& rSrcPt, const Size& rSrcSize, + const OutputDevice& rOutDev ); + + virtual void CopyArea( + const Point& rDestPt, + const Point& rSrcPt, const Size& rSrcSize, + bool bWindowInvalidate = false ); + +protected: + + virtual void CopyDeviceArea( SalTwoRect& aPosAry, bool bWindowInvalidate); + + virtual tools::Rectangle GetBackgroundComponentBounds() const; + + virtual const OutputDevice* DrawOutDevDirectCheck(const OutputDevice& rSrcDev) const; + + virtual void DrawOutDevDirectProcess(const OutputDevice& rSrcDev, SalTwoRect& rPosAry, SalGraphics* pSrcGraphics); + + SAL_DLLPRIVATE void drawOutDevDirect(const OutputDevice& rSrcDev, SalTwoRect& rPosAry); + + SAL_DLLPRIVATE bool is_double_buffered_window() const; + + virtual css::uno::Reference< css::rendering::XCanvas > ImplGetCanvas( bool bSpriteCanvas ) const; + SAL_DLLPRIVATE void ImplDisposeCanvas(); + +private: + + // not implemented; to detect misuses of DrawOutDev(...OutputDevice&); + SAL_DLLPRIVATE void DrawOutDev( const Point&, const Size&, const Point&, const Size&, const Printer&) = delete; + ///@} + + + /** @name OutputDevice state functions + */ + ///@{ + +public: + + void Push( vcl::PushFlags nFlags = vcl::PushFlags::ALL ); + void Pop(); + void ClearStack(); + + void EnableOutput( bool bEnable = true ); + bool IsOutputEnabled() const { return mbOutput; } + bool IsDeviceOutputNecessary() const { return (mbOutput && mbDevOutput); } + + void SetAntialiasing( AntialiasingFlags nMode ); + AntialiasingFlags GetAntialiasing() const { return mnAntialiasing; } + + // Render glyphs with a mode suitable for rendering of resolution-independent layout positions. + void SetTextRenderModeForResolutionIndependentLayout(bool bMode); + bool GetTextRenderModeForResolutionIndependentLayout() const { return mbTextRenderModeForResolutionIndependentLayout; } + + void SetDrawMode( DrawModeFlags nDrawMode ); + DrawModeFlags GetDrawMode() const { return mnDrawMode; } + + void SetLayoutMode( vcl::text::ComplexTextLayoutFlags nTextLayoutMode ); + vcl::text::ComplexTextLayoutFlags GetLayoutMode() const { return mnTextLayoutMode; } + + void SetDigitLanguage( LanguageType ); + LanguageType GetDigitLanguage() const { return meTextLanguage; } + + void SetRasterOp( RasterOp eRasterOp ); + RasterOp GetRasterOp() const { return meRasterOp; } + + /** + If this OutputDevice is used for displaying a Print Preview + the OutDevViewType should be set to 'OutDevViewType::PrintPreview'. + + A View can then make painting decisions dependent on this OutDevViewType. + E.g. text colors need to be handled differently, dependent on whether it's a PrintPreview or not. (see #106611# for more) + */ + void SetOutDevViewType( OutDevViewType eOutDevViewType ) { meOutDevViewType=eOutDevViewType; } + OutDevViewType GetOutDevViewType() const { return meOutDevViewType; } + + void SetLineColor(); + void SetLineColor( const Color& rColor ); + const Color& GetLineColor() const { return maLineColor; } + bool IsLineColor() const { return mbLineColor; } + + void SetFillColor(); + void SetFillColor( const Color& rColor ); + const Color& GetFillColor() const { return maFillColor; } + bool IsFillColor() const { return mbFillColor; } + + void SetBackground(); + void SetBackground( const Wallpaper& rBackground ); + virtual void SaveBackground(VirtualDevice& rSaveDevice, + const Point& rPos, const Size& rSize, const Size& rBackgroundSize) const; + + const Wallpaper& GetBackground() const { return maBackground; } + virtual Color GetBackgroundColor() const; + virtual Color GetReadableFontColor(const Color& rFontColor, const Color& rBgColor) const; + bool IsBackground() const { return mbBackground; } + + void SetFont( const vcl::Font& rNewFont ); + const vcl::Font& GetFont() const { return maFont; } + +protected: + + virtual void ImplReleaseFonts(); + +private: + + SAL_DLLPRIVATE void InitLineColor(); + + SAL_DLLPRIVATE void InitFillColor(); + + ///@} + + + /** @name Clipping functions + */ + ///@{ + +public: + + vcl::Region GetClipRegion() const; + void SetClipRegion(); + void SetClipRegion( const vcl::Region& rRegion ); + bool SelectClipRegion( const vcl::Region&, SalGraphics* pGraphics = nullptr ); + + bool IsClipRegion() const { return mbClipRegion; } + + void MoveClipRegion( tools::Long nHorzMove, tools::Long nVertMove ); + void IntersectClipRegion( const tools::Rectangle& rRect ); + void IntersectClipRegion( const vcl::Region& rRegion ); + + virtual vcl::Region GetActiveClipRegion() const; + virtual vcl::Region GetOutputBoundsClipRegion() const; + +protected: + + virtual void InitClipRegion(); + + /** Perform actual rect clip against outdev dimensions, to generate + empty clips whenever one of the values is completely off the device. + + @param aRegion region to be clipped to the device dimensions + @returns region clipped to the device bounds + **/ + virtual vcl::Region ClipToDeviceBounds(vcl::Region aRegion) const; + virtual void ClipToPaintRegion ( tools::Rectangle& rDstRect ); + +private: + + SAL_DLLPRIVATE void SetDeviceClipRegion( const vcl::Region* pRegion ); + ///@} + +public: + virtual void DrawBorder(tools::Rectangle aBorderRect); + + + /** @name Pixel functions + */ + ///@{ + +public: + + void DrawPixel( const Point& rPt ); + void DrawPixel( const Point& rPt, const Color& rColor ); + + Color GetPixel( const Point& rPt ) const; + ///@} + + + /** @name Rectangle functions + */ + ///@{ + +public: + + void DrawRect( const tools::Rectangle& rRect ); + void DrawRect( const tools::Rectangle& rRect, + sal_uLong nHorzRount, sal_uLong nVertRound ); + + /// Fill the given rectangle with checkered rectangles of size nLen x nLen using the colors aStart and aEnd + void DrawCheckered( + const Point& rPos, + const Size& rSize, + sal_uInt32 nLen = 8, + Color aStart = COL_WHITE, + Color aEnd = COL_BLACK); + + void DrawGrid( const tools::Rectangle& rRect, const Size& rDist, DrawGridFlags nFlags ); + + ///@} + + /** @name Invert functions + */ + ///@{ +public: + void Invert( const tools::Rectangle& rRect, InvertFlags nFlags = InvertFlags::NONE ); + void Invert( const tools::Polygon& rPoly, InvertFlags nFlags = InvertFlags::NONE ); + ///@} + + /** @name Line functions + */ + ///@{ + +public: + + void DrawLine( const Point& rStartPt, const Point& rEndPt ); + + void DrawLine( const Point& rStartPt, const Point& rEndPt, + const LineInfo& rLineInfo ); + +protected: + virtual void DrawHatchLine_DrawLine(const Point& rStartPoint, const Point& rEndPoint); + +private: + + /** Helper for line geometry paint with support for graphic expansion (pattern and fat_to_area) + */ + SAL_DLLPRIVATE void drawLine( basegfx::B2DPolyPolygon aLinePolyPolygon, const LineInfo& rInfo ); + ///@} + + + /** @name Polyline functions + */ + ///@{ + +public: + + /** Render the given polygon as a line stroke + + The given polygon is stroked with the current LineColor, start + and end point are not automatically connected + + @see DrawPolygon + @see DrawPolyPolygon + */ + void DrawPolyLine( const tools::Polygon& rPoly ); + + void DrawPolyLine( + const basegfx::B2DPolygon&, + double fLineWidth = 0.0, + basegfx::B2DLineJoin eLineJoin = basegfx::B2DLineJoin::Round, + css::drawing::LineCap eLineCap = css::drawing::LineCap_BUTT, + double fMiterMinimumAngle = basegfx::deg2rad(15.0)); + + /** Render the given polygon as a line stroke + + The given polygon is stroked with the current LineColor, start + and end point are not automatically connected. The line is + rendered according to the specified LineInfo, e.g. supplying a + dash pattern, or a line thickness. + + @see DrawPolygon + @see DrawPolyPolygon + */ + void DrawPolyLine( const tools::Polygon& rPoly, + const LineInfo& rLineInfo ); + + // #i101491# + // Helper who tries to use SalGDI's DrawPolyLine direct and returns it's bool. + bool DrawPolyLineDirect( + const basegfx::B2DHomMatrix& rObjectTransform, + const basegfx::B2DPolygon& rB2DPolygon, + double fLineWidth = 0.0, + double fTransparency = 0.0, + const std::vector< double >* = nullptr, // MM01 + basegfx::B2DLineJoin eLineJoin = basegfx::B2DLineJoin::NONE, + css::drawing::LineCap eLineCap = css::drawing::LineCap_BUTT, + double fMiterMinimumAngle = basegfx::deg2rad(15.0)); + +private: + + // #i101491# + // Helper which holds the old line geometry creation and is extended to use AA when + // switched on. Advantage is that line geometry is only temporarily used for paint + SAL_DLLPRIVATE void drawPolyLine(const tools::Polygon& rPoly, const LineInfo& rLineInfo); + + ///@} + + bool DrawPolyLineDirectInternal( + const basegfx::B2DHomMatrix& rObjectTransform, + const basegfx::B2DPolygon& rB2DPolygon, + double fLineWidth = 0.0, + double fTransparency = 0.0, + const std::vector< double >* = nullptr, // MM01 + basegfx::B2DLineJoin eLineJoin = basegfx::B2DLineJoin::NONE, + css::drawing::LineCap eLineCap = css::drawing::LineCap_BUTT, + double fMiterMinimumAngle = basegfx::deg2rad(15.0)); + + /** @name Polygon functions + */ + ///@{ + +public: + + /** Render the given polygon + + The given polygon is stroked with the current LineColor, and + filled with the current FillColor. If one of these colors are + transparent, the corresponding stroke or fill stays + invisible. Start and end point of the polygon are + automatically connected. + + @see DrawPolyLine + */ + void DrawPolygon( const tools::Polygon& rPoly ); + void DrawPolygon( const basegfx::B2DPolygon& ); + + /** Render the given poly-polygon + + The given poly-polygon is stroked with the current LineColor, + and filled with the current FillColor. If one of these colors + are transparent, the corresponding stroke or fill stays + invisible. Start and end points of the contained polygons are + automatically connected. + + @see DrawPolyLine + */ + void DrawPolyPolygon( const tools::PolyPolygon& rPolyPoly ); + void DrawPolyPolygon( const basegfx::B2DPolyPolygon& ); + +private: + + SAL_DLLPRIVATE void ImplDrawPolygon( const tools::Polygon& rPoly, const tools::PolyPolygon* pClipPolyPoly = nullptr ); + SAL_DLLPRIVATE void ImplDrawPolyPolygon( const tools::PolyPolygon& rPolyPoly, const tools::PolyPolygon* pClipPolyPoly ); + SAL_DLLPRIVATE void ImplDrawPolyPolygon( sal_uInt16 nPoly, const tools::PolyPolygon& rPolyPoly ); + // #i101491# + // Helper who implements the DrawPolyPolygon functionality for basegfx::B2DPolyPolygon + // without MetaFile processing + SAL_DLLPRIVATE void ImplDrawPolyPolygonWithB2DPolyPolygon(const basegfx::B2DPolyPolygon& rB2DPolyPoly); + ///@} + + SAL_DLLPRIVATE void ImplDrawWaveLineBezier(tools::Long nStartX, tools::Long nStartY, tools::Long nEndX, tools::Long nEndY, tools::Long nWaveHeight, double fOrientation, tools::Long nLineWidth); + + + /** @name Curved shape functions + */ + ///@{ + +public: + + void DrawEllipse( const tools::Rectangle& rRect ); + + void DrawArc( + const tools::Rectangle& rRect, + const Point& rStartPt, const Point& rEndPt ); + + void DrawPie( + const tools::Rectangle& rRect, + const Point& rStartPt, const Point& rEndPt ); + + void DrawChord( + const tools::Rectangle& rRect, + const Point& rStartPt, const Point& rEndPt ); + + ///@} + + + /** @name Gradient functions + */ + ///@{ + +public: + void DrawGradient( const tools::Rectangle& rRect, const Gradient& rGradient ); + void DrawGradient( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient ); + +protected: + + virtual bool UsePolyPolygonForComplexGradient() = 0; + + virtual tools::Long GetGradientStepCount( tools::Long nMinRect ); + +private: + + SAL_DLLPRIVATE void DrawLinearGradient( const tools::Rectangle& rRect, const Gradient& rGradient, const tools::PolyPolygon* pClipPolyPoly ); + SAL_DLLPRIVATE void DrawComplexGradient( const tools::Rectangle& rRect, const Gradient& rGradient, const tools::PolyPolygon* pClipPolyPoly ); + SAL_DLLPRIVATE void DrawGradientToMetafile( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient ); + SAL_DLLPRIVATE tools::Long GetGradientSteps(Gradient const& rGradient, tools::Rectangle const& rRect); + SAL_DLLPRIVATE Color GetSingleColorGradientFill(); + ///@} + + + /** @name Hatch functions + */ + ///@{ + +public: + +#ifdef _MSC_VER + void DrawHatch( const tools::PolyPolygon& rPolyPoly, const ::Hatch& rHatch ); + void AddHatchActions( const tools::PolyPolygon& rPolyPoly, + const ::Hatch& rHatch, + GDIMetaFile& rMtf ); +#else + void DrawHatch( const tools::PolyPolygon& rPolyPoly, const Hatch& rHatch ); + void AddHatchActions( const tools::PolyPolygon& rPolyPoly, + const Hatch& rHatch, + GDIMetaFile& rMtf ); +#endif + + void DrawHatch( const tools::PolyPolygon& rPolyPoly, const Hatch& rHatch, bool bMtf ); + +private: + + SAL_DLLPRIVATE void CalcHatchValues( const tools::Rectangle& rRect, tools::Long nDist, Degree10 nAngle10, Point& rPt1, Point& rPt2, Size& rInc, Point& rEndPt1 ); + SAL_DLLPRIVATE void DrawHatchLine( const tools::Line& rLine, const tools::PolyPolygon& rPolyPoly, Point* pPtBuffer, bool bMtf ); + ///@} + + + /** @name Wallpaper functions + */ + ///@{ + +public: + void DrawWallpaper( const tools::Rectangle& rRect, const Wallpaper& rWallpaper ); + + void Erase(); + void Erase(const tools::Rectangle& rRect); + +protected: + void DrawGradientWallpaper( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, const Wallpaper& rWallpaper ); + +private: + SAL_DLLPRIVATE void DrawWallpaper( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, const Wallpaper& rWallpaper ); + SAL_DLLPRIVATE void DrawColorWallpaper( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, const Wallpaper& rWallpaper ); + SAL_DLLPRIVATE void DrawBitmapWallpaper( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, const Wallpaper& rWallpaper ); + ///@} + + + /** @name Text functions + */ + ///@{ + +public: + + void DrawText( const Point& rStartPt, const OUString& rStr, + sal_Int32 nIndex = 0, sal_Int32 nLen = -1, + std::vector< tools::Rectangle >* pVector = nullptr, OUString* pDisplayText = nullptr, + const SalLayoutGlyphs* pLayoutCache = nullptr ); + + void DrawText( const tools::Rectangle& rRect, + const OUString& rStr, DrawTextFlags nStyle = DrawTextFlags::NONE, + std::vector< tools::Rectangle >* pVector = nullptr, OUString* pDisplayText = nullptr, + vcl::ITextLayout* _pTextLayout = nullptr ); + + static void ImplDrawText( OutputDevice& rTargetDevice, const tools::Rectangle& rRect, + const OUString& rOrigStr, DrawTextFlags nStyle, + std::vector< tools::Rectangle >* pVector, OUString* pDisplayText, vcl::ITextLayout& _rLayout ); + + void ImplDrawText( SalLayout& ); + + void ImplDrawTextBackground( const SalLayout& ); + + void DrawCtrlText( const Point& rPos, const OUString& rStr, + sal_Int32 nIndex = 0, sal_Int32 nLen = -1, + DrawTextFlags nStyle = DrawTextFlags::Mnemonic, std::vector< tools::Rectangle >* pVector = nullptr, OUString* pDisplayText = nullptr, + const SalLayoutGlyphs* pGlyphs = nullptr); + + void DrawTextLine( const Point& rPos, tools::Long nWidth, + FontStrikeout eStrikeout, + FontLineStyle eUnderline, + FontLineStyle eOverline, + bool bUnderlineAbove = false ); + + void ImplDrawTextLine( tools::Long nBaseX, tools::Long nX, tools::Long nY, DeviceCoordinate nWidth, + FontStrikeout eStrikeout, FontLineStyle eUnderline, + FontLineStyle eOverline, bool bUnderlineAbove ); + + void ImplDrawTextLines( SalLayout&, FontStrikeout eStrikeout, FontLineStyle eUnderline, + FontLineStyle eOverline, bool bWordLine, bool bUnderlineAbove ); + + void DrawWaveLine( const Point& rStartPos, const Point& rEndPos, tools::Long nLineWidth = 1, tools::Long nWaveHeight = 3); + + bool ImplDrawRotateText( SalLayout& ); + + tools::Rectangle GetTextRect( const tools::Rectangle& rRect, + const OUString& rStr, DrawTextFlags nStyle = DrawTextFlags::WordBreak, + TextRectInfo* pInfo = nullptr, + const vcl::ITextLayout* _pTextLayout = nullptr ) const; + + /** Return the exact bounding rectangle of rStr. + + The text is then drawn exactly from rRect.TopLeft() to + rRect.BottomRight(), don't assume that rRect.TopLeft() is [0, 0]. + + Please note that you don't always want to use GetTextBoundRect(); in + many cases you actually want to use GetTextHeight(), because + GetTextBoundRect() gives you the exact bounding rectangle regardless + what is the baseline of the text. + + Code snippet to get just exactly the text (no filling around that) as + a bitmap via a VirtualDevice (regardless what is the baseline): + + <code> + VirtualDevice aDevice; + vcl::Font aFont = aDevice.GetFont(); + aFont.SetSize(Size(0, 96)); + aFont.SetColor(COL_BLACK); + aDevice.SetFont(aFont); + aDevice.Erase(); + + tools::Rectangle aRect; + aDevice.GetTextBoundRect(aRect, aText); + aDevice.SetOutputSize(Size(aRect.Right() + 1, aRect.Bottom() + 1)); + aDevice.SetBackground(Wallpaper(COL_TRANSPARENT)); + aDevice.DrawText(Point(0,0), aText); + + // exactly only the text, regardless of the baseline + Bitmap aBitmap(aDevice.GetBitmap(aRect.TopLeft(), aRect.GetSize())); + </code> + + Code snippet to get the text as a bitmap via a Virtual device that + contains even the filling so that the baseline is always preserved + (ie. the text will not jump up and down according to whether it + contains 'y' or not etc.) + + <code> + VirtualDevice aDevice; + // + the appropriate font / device setup, see above + + aDevice.SetOutputSize(Size(aDevice.GetTextWidth(aText), aDevice.GetTextHeight())); + aDevice.SetBackground(Wallpaper(COL_TRANSPARENT)); + aDevice.DrawText(Point(0,0), aText); + + // bitmap that contains even the space around the text, + // that means, preserves the baseline etc. + Bitmap aBitmap(aDevice.GetBitmap(Point(0, 0), aDevice.GetOutputSize())); + </code> + */ + bool GetTextBoundRect( tools::Rectangle& rRect, + const OUString& rStr, sal_Int32 nBase = 0, sal_Int32 nIndex = 0, sal_Int32 nLen = -1, + sal_uLong nLayoutWidth = 0, o3tl::span<const sal_Int32> pDXArray = {}, + const SalLayoutGlyphs* pGlyphs = nullptr ) const; + + tools::Rectangle ImplGetTextBoundRect( const SalLayout& ) const; + + bool GetTextOutline( tools::PolyPolygon&, + const OUString& rStr ) const; + + bool GetTextOutlines( PolyPolyVector&, + const OUString& rStr, sal_Int32 nBase = 0, sal_Int32 nIndex = 0, + sal_Int32 nLen = -1, + sal_uLong nLayoutWidth = 0, o3tl::span<const sal_Int32> pDXArray = {} ) const; + + bool GetTextOutlines( basegfx::B2DPolyPolygonVector &rVector, + const OUString& rStr, sal_Int32 nBase, sal_Int32 nIndex = 0, + sal_Int32 nLen = -1, + sal_uLong nLayoutWidth = 0, o3tl::span<const sal_Int32> pDXArray = {} ) const; + + + OUString GetEllipsisString( const OUString& rStr, tools::Long nMaxWidth, + DrawTextFlags nStyle = DrawTextFlags::EndEllipsis ) const; + + tools::Long GetCtrlTextWidth( const OUString& rStr, + const SalLayoutGlyphs* pLayoutCache = nullptr ) const; + + static OUString GetNonMnemonicString( const OUString& rStr, sal_Int32& rMnemonicPos ); + + static OUString GetNonMnemonicString( const OUString& rStr ) + { sal_Int32 nDummy; return GetNonMnemonicString( rStr, nDummy ); } + + /** Generate MetaTextActions for the text rect + + This method splits up the text rect into multiple + MetaTextActions, one for each line of text. This is comparable + to AddGradientActions(), which splits up a gradient into its + constituent polygons. Parameter semantics fully compatible to + DrawText(). + */ + void AddTextRectActions( const tools::Rectangle& rRect, + const OUString& rOrigStr, + DrawTextFlags nStyle, + GDIMetaFile& rMtf ); + + void SetTextColor( const Color& rColor ); + virtual void SetSystemTextColor(SystemTextColorFlags nFlags, bool bEnabled); + const Color& GetTextColor() const { return maTextColor; } + + void SetTextFillColor(); + void SetTextFillColor( const Color& rColor ); + Color GetTextFillColor() const; + bool IsTextFillColor() const { return !maFont.IsTransparent(); } + + void SetTextLineColor(); + void SetTextLineColor( const Color& rColor ); + const Color& GetTextLineColor() const { return maTextLineColor; } + bool IsTextLineColor() const { return !maTextLineColor.IsTransparent(); } + + void SetOverlineColor(); + void SetOverlineColor( const Color& rColor ); + const Color& GetOverlineColor() const { return maOverlineColor; } + bool IsOverlineColor() const { return !maOverlineColor.IsTransparent(); } + + void SetTextAlign( TextAlign eAlign ); + TextAlign GetTextAlign() const { return maFont.GetAlignment(); } + + /** Width of the text. + + See also GetTextBoundRect() for more explanation + code examples. + */ + tools::Long GetTextWidth( const OUString& rStr, sal_Int32 nIndex = 0, sal_Int32 nLen = -1, + vcl::text::TextLayoutCache const* = nullptr, + SalLayoutGlyphs const*const pLayoutCache = nullptr) const; + + /** Height where any character of the current font fits; in logic coordinates. + + See also GetTextBoundRect() for more explanation + code examples. + */ + tools::Long GetTextHeight() const; + float approximate_digit_width() const; + + void DrawTextArray( const Point& rStartPt, const OUString& rStr, + o3tl::span<const sal_Int32> pDXAry, + sal_Int32 nIndex = 0, + sal_Int32 nLen = -1, + SalLayoutFlags flags = SalLayoutFlags::NONE, + const SalLayoutGlyphs* pLayoutCache = nullptr); + tools::Long GetTextArray( const OUString& rStr, std::vector<sal_Int32>* pDXAry, + sal_Int32 nIndex = 0, sal_Int32 nLen = -1, + vcl::text::TextLayoutCache const* = nullptr, + SalLayoutGlyphs const*const pLayoutCache = nullptr) const; + + void GetCaretPositions( const OUString&, sal_Int32* pCaretXArray, + sal_Int32 nIndex, sal_Int32 nLen, + const SalLayoutGlyphs* pGlyphs = nullptr ) const; + void DrawStretchText( const Point& rStartPt, sal_uLong nWidth, + const OUString& rStr, + sal_Int32 nIndex = 0, sal_Int32 nLen = -1); + sal_Int32 GetTextBreak( const OUString& rStr, tools::Long nTextWidth, + sal_Int32 nIndex, sal_Int32 nLen = -1, + tools::Long nCharExtra = 0, + vcl::text::TextLayoutCache const* = nullptr, + const SalLayoutGlyphs* pGlyphs = nullptr) const; + sal_Int32 GetTextBreak( const OUString& rStr, tools::Long nTextWidth, + sal_Unicode nExtraChar, sal_Int32& rExtraCharPos, + sal_Int32 nIndex, sal_Int32 nLen, + tools::Long nCharExtra, + vcl::text::TextLayoutCache const* = nullptr, + const SalLayoutGlyphs* pGlyphs = nullptr) const; + static std::shared_ptr<const vcl::text::TextLayoutCache> CreateTextLayoutCache(OUString const&); + + SAL_DLLPRIVATE SalLayoutFlags GetBiDiLayoutFlags( std::u16string_view rStr, + const sal_Int32 nMinIndex, + const sal_Int32 nEndIndex ) const; + +protected: + SAL_DLLPRIVATE void ImplInitTextLineSize(); + SAL_DLLPRIVATE void ImplInitAboveTextLineSize(); + static + SAL_DLLPRIVATE tools::Long ImplGetTextLines( const tools::Rectangle& rRect, tools::Long nTextHeight, ImplMultiTextLineInfo& rLineInfo, tools::Long nWidth, const OUString& rStr, DrawTextFlags nStyle, const vcl::ITextLayout& _rLayout ); + static + SAL_DLLPRIVATE sal_Int32 ImplBreakLinesWithIterator(const tools::Long nWidth, const OUString& rStr, const vcl::ITextLayout& _rLayout, + const css::uno::Reference<css::linguistic2::XHyphenator>& xHyph, + const css::uno::Reference<css::i18n::XBreakIterator>& xBI, + const bool bHyphenate, + const sal_Int32 nPos, sal_Int32 nBreakPos); + static + SAL_DLLPRIVATE sal_Int32 ImplBreakLinesSimple( const tools::Long nWidth, const OUString& rStr, + const vcl::ITextLayout& _rLayout, const sal_Int32 nPos, sal_Int32 nBreakPos, tools::Long& nLineWidth ); + SAL_DLLPRIVATE float approximate_char_width() const; + + virtual bool shouldDrawWavePixelAsRect(tools::Long nLineWidth) const; + virtual void SetWaveLineColors(Color const& rColor, tools::Long nLineWidth); + virtual Size GetWaveLineSize(tools::Long nLineWidth) const; + +private: + SAL_DLLPRIVATE void ImplInitTextColor(); + + SAL_DLLPRIVATE void ImplDrawTextDirect( SalLayout&, bool bTextLines); + SAL_DLLPRIVATE void ImplDrawSpecialText( SalLayout& ); + SAL_DLLPRIVATE void ImplDrawTextRect( tools::Long nBaseX, tools::Long nBaseY, tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight ); + + SAL_DLLPRIVATE void ImplDrawWavePixel( tools::Long nOriginX, tools::Long nOriginY, tools::Long nCurX, tools::Long nCurY, tools::Long nWidth, Degree10 nOrientation, SalGraphics* pGraphics, const OutputDevice& rOutDev, tools::Long nPixWidth, tools::Long nPixHeight ); + + SAL_DLLPRIVATE void ImplDrawWaveLine( tools::Long nBaseX, tools::Long nBaseY, tools::Long nStartX, tools::Long nStartY, tools::Long nWidth, tools::Long nHeight, tools::Long nLineWidth, Degree10 nOrientation, const Color& rColor ); + SAL_DLLPRIVATE void ImplDrawWaveTextLine( tools::Long nBaseX, tools::Long nBaseY, tools::Long nX, tools::Long nY, tools::Long nWidth, FontLineStyle eTextLine, Color aColor, bool bIsAbove ); + SAL_DLLPRIVATE void ImplDrawStraightTextLine( tools::Long nBaseX, tools::Long nBaseY, tools::Long nX, tools::Long nY, tools::Long nWidth, FontLineStyle eTextLine, Color aColor, bool bIsAbove ); + SAL_DLLPRIVATE void ImplDrawStrikeoutLine( tools::Long nBaseX, tools::Long nBaseY, tools::Long nX, tools::Long nY, tools::Long nWidth, FontStrikeout eStrikeout, Color aColor ); + SAL_DLLPRIVATE void ImplDrawStrikeoutChar( tools::Long nBaseX, tools::Long nBaseY, tools::Long nX, tools::Long nY, tools::Long nWidth, FontStrikeout eStrikeout, Color aColor ); + SAL_DLLPRIVATE void ImplDrawMnemonicLine( tools::Long nX, tools::Long nY, tools::Long nWidth ); + + SAL_DLLPRIVATE bool AttemptOLEFontScaleFix(vcl::Font& rFont, tools::Long nHeight) const; + + ///@} + + + /** @name Font functions + */ + ///@{ + +public: + + FontMetric GetFontMetricFromCollection( int nDevFontIndex ) const; + int GetFontFaceCollectionCount() const; + + bool IsFontAvailable( std::u16string_view rFontName ) const; + + bool AddTempDevFont( const OUString& rFileURL, const OUString& rFontName ); + void RefreshFontData( const bool bNewFontLists ); + + FontMetric GetFontMetric() const; + FontMetric GetFontMetric( const vcl::Font& rFont ) const; + + bool GetFontCharMap( FontCharMapRef& rxFontCharMap ) const; + bool GetFontCapabilities( vcl::FontCapabilities& rFontCapabilities ) const; + + bool GetFontFeatures(std::vector<vcl::font::Feature>& rFontFeatures) const; + + SAL_DLLPRIVATE void ImplGetEmphasisMark( tools::PolyPolygon& rPolyPoly, bool& rPolyLine, tools::Rectangle& rRect1, tools::Rectangle& rRect2, + tools::Long& rYOff, tools::Long& rWidth, FontEmphasisMark eEmphasis, tools::Long nHeight ); + SAL_DLLPRIVATE static FontEmphasisMark + ImplGetEmphasisMarkStyle( const vcl::Font& rFont ); + + bool GetGlyphBoundRects( const Point& rOrigin, const OUString& rStr, int nIndex, + int nLen, std::vector< tools::Rectangle >& rVector ) const; + + sal_Int32 HasGlyphs( const vcl::Font& rFont, const OUString& rStr, + sal_Int32 nIndex = 0, sal_Int32 nLen = -1 ) const; + + tools::Long GetMinKashida() const; + + // i60594 + // validate kashida positions against the current font + // returns count of invalid kashida positions + sal_Int32 ValidateKashidas( const OUString& rTxt, sal_Int32 nIdx, sal_Int32 nLen, + sal_Int32 nKashCount, // number of suggested kashida positions (in) + const sal_Int32* pKashidaPos, // suggested kashida positions (in) + sal_Int32* pKashidaPosDropped // invalid kashida positions (out) + ) const; + + static void BeginFontSubstitution(); + static void EndFontSubstitution(); + static void AddFontSubstitute( const OUString& rFontName, + const OUString& rReplaceFontName, + AddFontSubstituteFlags nFlags ); + static void RemoveFontsSubstitute(); + + static vcl::Font GetDefaultFont( DefaultFontType nType, + LanguageType eLang, + GetDefaultFontFlags nFlags, + const OutputDevice* pOutDev = nullptr ); + + SAL_DLLPRIVATE void ImplInitFontList() const; + SAL_DLLPRIVATE void ImplUpdateFontData(); + + //drop font data for all outputdevices. + //If bNewFontLists is true then empty lists of system fonts + static void ImplClearAllFontData( bool bNewFontLists ); + //fetch font data for all outputdevices + //If bNewFontLists is true then fetch lists of system fonts + static void ImplRefreshAllFontData( bool bNewFontLists ); + //drop and fetch font data for all outputdevices + //If bNewFontLists is true then drop and refetch lists of system fonts + SAL_DLLPRIVATE static void ImplUpdateAllFontData( bool bNewFontLists ); + + SAL_DLLPRIVATE const LogicalFontInstance* GetFontInstance() const; + +protected: + SAL_DLLPRIVATE tools::Long GetEmphasisAscent() const { return mnEmphasisAscent; } + SAL_DLLPRIVATE tools::Long GetEmphasisDescent() const { return mnEmphasisDescent; } + + SAL_DLLPRIVATE bool InitFont() const; + virtual void SetFontOrientation( LogicalFontInstance* const pFontInstance ) const; + virtual tools::Long GetFontExtLeading() const; + + virtual void ImplClearFontData(bool bNewFontLists); + virtual void ImplRefreshFontData(bool bNewFontLists); + void ReleaseFontCache(); + void ReleaseFontCollection(); + void SetFontCollectionFromSVData(); + void ResetNewFontCache(); + + virtual bool ImplNewFont() const; + +private: + + typedef void ( OutputDevice::* FontUpdateHandler_t )( bool ); + + SAL_DLLPRIVATE static void ImplUpdateFontDataForAllFrames( FontUpdateHandler_t pHdl, bool bNewFontLists ); + + static + SAL_DLLPRIVATE OUString ImplGetEllipsisString( const OutputDevice& rTargetDevice, const OUString& rStr, + tools::Long nMaxWidth, DrawTextFlags nStyle, const vcl::ITextLayout& _rLayout ); + + SAL_DLLPRIVATE void ImplDrawEmphasisMark( tools::Long nBaseX, tools::Long nX, tools::Long nY, const tools::PolyPolygon& rPolyPoly, bool bPolyLine, const tools::Rectangle& rRect1, const tools::Rectangle& rRect2 ); + SAL_DLLPRIVATE void ImplDrawEmphasisMarks( SalLayout& ); + ///@} + + + /** @name Layout functions + */ + ///@{ + +public: + + // tells whether this output device is RTL in an LTR UI or LTR in a RTL UI + SAL_DLLPRIVATE bool ImplIsAntiparallel() const ; + SAL_DLLPRIVATE void ReMirror( Point &rPoint ) const; + SAL_DLLPRIVATE void ReMirror( tools::Rectangle &rRect ) const; + SAL_DLLPRIVATE void ReMirror( vcl::Region &rRegion ) const; + SAL_DLLPRIVATE bool ImplIsRecordLayout() const; + virtual bool HasMirroredGraphics() const; + std::unique_ptr<SalLayout> + ImplLayout( const OUString&, sal_Int32 nIndex, sal_Int32 nLen, + const Point& rLogicPos = Point(0,0), tools::Long nLogicWidth=0, + o3tl::span<const sal_Int32> pLogicDXArray={}, SalLayoutFlags flags = SalLayoutFlags::NONE, + vcl::text::TextLayoutCache const* = nullptr, + const SalLayoutGlyphs* pGlyphs = nullptr) const; + + SAL_DLLPRIVATE vcl::text::ImplLayoutArgs ImplPrepareLayoutArgs( OUString&, const sal_Int32 nIndex, const sal_Int32 nLen, + DeviceCoordinate nPixelWidth, + SalLayoutFlags flags = SalLayoutFlags::NONE, + vcl::text::TextLayoutCache const* = nullptr) const; + SAL_DLLPRIVATE std::unique_ptr<SalLayout> + ImplGlyphFallbackLayout( std::unique_ptr<SalLayout>, + vcl::text::ImplLayoutArgs&, + const SalLayoutGlyphs* ) const; + SAL_DLLPRIVATE std::unique_ptr<SalLayout> + getFallbackLayout( + LogicalFontInstance* pLogicalFont, int nFallbackLevel, + vcl::text::ImplLayoutArgs& rLayoutArgs, const SalLayoutGlyphs* ) const; + + /* + These functions allow collecting information on how fonts are mapped when used, such as what + replacements are used when a requested font is missing or which fonts are used as fallbacks + when a font doesn't provide all necessary glyphs. + After StartTrackingFontMappingUse() is called, VCL starts collecting font usage for all + text layout calls, FinishTrackingFontMappingUse() will stop collecting and providing + the collected information. + Each item is a mapping from a requested font to a list of actually used fonts and the number + of times this mapping was done. + */ + struct FontMappingUseItem + { + OUString mOriginalFont; + std::vector<OUString> mUsedFonts; + int mCount; + }; + typedef std::vector<FontMappingUseItem> FontMappingUseData; + static void StartTrackingFontMappingUse(); + static FontMappingUseData FinishTrackingFontMappingUse(); + + // Enabling/disabling RTL only makes sense for OutputDevices that use a mirroring SalGraphicsLayout + virtual void EnableRTL( bool bEnable = true); + bool IsRTLEnabled() const { return mbEnableRTL; } + + bool GetTextIsRTL( const OUString&, sal_Int32 nIndex, sal_Int32 nLen ) const; + + ///@} + + + /** @name Bitmap functions + */ + ///@{ + +public: + void DrawBitmap( + const Point& rDestPt, + const Bitmap& rBitmap ); + + void DrawBitmap( + const Point& rDestPt, + const Size& rDestSize, + const Bitmap& rBitmap ); + + void DrawBitmap( + const Point& rDestPt, + const Size& rDestSize, + const Point& rSrcPtPixel, + const Size& rSrcSizePixel, + const Bitmap& rBitmap); + + void DrawBitmap( + const Point& rDestPt, + const Size& rDestSize, + const Point& rSrcPtPixel, + const Size& rSrcSizePixel, + const Bitmap& rBitmap, + MetaActionType nAction ); + + void DrawBitmapEx( + const Point& rDestPt, + const BitmapEx& rBitmapEx ); + + + void DrawBitmapEx( + const Point& rDestPt, + const Size& rDestSize, + const BitmapEx& rBitmapEx ); + + void DrawBitmapEx( + const Point& rDestPt, + const Size& rDestSize, + const Point& rSrcPtPixel, + const Size& rSrcSizePixel, + const BitmapEx& rBitmapEx); + + void DrawBitmapEx( + const Point& rDestPt, + const Size& rDestSize, + const Point& rSrcPtPixel, + const Size& rSrcSizePixel, + const BitmapEx& rBitmapEx, + MetaActionType nAction ); + + /** @overload + virtual void DrawImage( + const Point& rPos, + const Size& rSize, + const Image& rImage, + sal_uInt16 nStyle = 0) + */ + void DrawImage( + const Point& rPos, + const Image& rImage, + DrawImageFlags nStyle = DrawImageFlags::NONE ); + + void DrawImage( + const Point& rPos, + const Size& rSize, + const Image& rImage, + DrawImageFlags nStyle = DrawImageFlags::NONE ); + + + virtual Bitmap GetBitmap( const Point& rSrcPt, const Size& rSize ) const; + + /** Query extended bitmap (with alpha channel, if available). + */ + BitmapEx GetBitmapEx( const Point& rSrcPt, const Size& rSize ) const; + + + /** Draw BitmapEx transformed + + @param rTransformation + The transformation describing the target positioning of the given bitmap. Transforming + the unit object coordinates (0, 0, 1, 1) with this matrix is the transformation to + discrete coordinates + + @param rBitmapEx + The BitmapEx to be painted + + @param fAlpha + Optional additional alpha to use for drawing (0 to 1, 1 being no change). + */ + void DrawTransformedBitmapEx( + const basegfx::B2DHomMatrix& rTransformation, + const BitmapEx& rBitmapEx, + double fAlpha = 1.0); + + /** Return true if DrawTransformedBitmapEx() is fast. + + @since 7.2 + */ + bool HasFastDrawTransformedBitmap() const; + +protected: + + virtual void DrawDeviceBitmapEx( + const Point& rDestPt, const Size& rDestSize, + const Point& rSrcPtPixel, const Size& rSrcSizePixel, + BitmapEx& rBitmapEx ); + + virtual bool CanSubsampleBitmap() const { return true; } + + /** Transform and draw a bitmap directly + + @param aFullTransform The B2DHomMatrix used for the transformation + @param rBitmapEx Reference to the bitmap to be transformed and drawn + + @return true if it was able to draw the bitmap, false if not + */ + virtual bool DrawTransformBitmapExDirect( + const basegfx::B2DHomMatrix& aFullTransform, + const BitmapEx& rBitmapEx, + double fAlpha = 1.0); + + /** Transform and reduce the area that needs to be drawn of the bitmap and return the new + visible range and the maximum area. + + + @param aFullTransform B2DHomMatrix used for transformation + @param aVisibleRange The new visible area of the bitmap + @param fMaximumArea The maximum area of the bitmap + + @returns true if there is an area to be drawn, otherwise nothing is left to be drawn + so return false + */ + virtual bool TransformAndReduceBitmapExToTargetRange( + const basegfx::B2DHomMatrix& aFullTransform, + basegfx::B2DRange &aVisibleRange, + double &fMaximumArea); + +private: + + SAL_DLLPRIVATE void DrawDeviceAlphaBitmap( + const Bitmap& rBmp, + const AlphaMask& rAlpha, + const Point& rDestPt, + const Size& rDestSize, + const Point& rSrcPtPixel, + const Size& rSrcSizePixel ); + + SAL_DLLPRIVATE void DrawDeviceAlphaBitmapSlowPath( + const Bitmap& rBitmap, const AlphaMask& rAlpha, + tools::Rectangle aDstRect, tools::Rectangle aBmpRect, + Size const & aOutSz, Point const & aOutPt); + + + SAL_DLLPRIVATE void BlendBitmap( + const SalTwoRect& rPosAry, + const Bitmap& rBmp ); + + SAL_DLLPRIVATE Bitmap BlendBitmap( + Bitmap& aBmp, + BitmapReadAccess const * pP, + BitmapReadAccess const * pA, + const sal_Int32 nOffY, + const sal_Int32 nDstHeight, + const sal_Int32 nOffX, + const sal_Int32 nDstWidth, + const tools::Rectangle& aBmpRect, + const Size& aOutSz, + const bool bHMirr, + const bool bVMirr, + const sal_Int32* pMapX, + const sal_Int32* pMapY ); + + SAL_DLLPRIVATE Bitmap BlendBitmapWithAlpha( + Bitmap& aBmp, + BitmapReadAccess const * pP, + BitmapReadAccess const * pA, + const tools::Rectangle& aDstRect, + const sal_Int32 nOffY, + const sal_Int32 nDstHeight, + const sal_Int32 nOffX, + const sal_Int32 nDstWidth, + const sal_Int32* pMapX, + const sal_Int32* pMapY ); + + ///@} + + + /** @name Transparency functions + */ + ///@{ + +public: + + /** helper method removing transparencies from a metafile (e.g. for printing) + + @returns + true: transparencies were removed + false: output metafile is unchanged input metafile + + @attention this is a member method, so current state can influence the result ! + @attention the output metafile is prepared in pixel mode for the currentOutputDevice + state. It can not be moved or rotated reliably anymore. + */ + bool RemoveTransparenciesFromMetaFile( + const GDIMetaFile& rInMtf, GDIMetaFile& rOutMtf, + tools::Long nMaxBmpDPIX, tools::Long nMaxBmpDPIY, + bool bReduceTransparency, + bool bTransparencyAutoMode, + bool bDownsampleBitmaps, + const Color& rBackground = COL_TRANSPARENT ); + + void DrawTransparent( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent ); + + void DrawTransparent( + const basegfx::B2DHomMatrix& rObjectTransform, + const basegfx::B2DPolyPolygon& rB2DPolyPoly, + double fTransparency); + + void DrawTransparent( + const GDIMetaFile& rMtf, const Point& rPos, const Size& rSize, + const Gradient& rTransparenceGradient ); + +protected: + + virtual void EmulateDrawTransparent( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent ); + + virtual void ClipAndDrawGradientMetafile ( const Gradient &rGradient, const tools::PolyPolygon &rPolyPoly ); + +private: + + SAL_DLLPRIVATE bool DrawTransparentNatively( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent ); + ///@} + + + /** @name Mask functions + */ + ///@{ + +public: + + void DrawMask( const Point& rDestPt, + const Bitmap& rBitmap, const Color& rMaskColor ); + + void DrawMask( const Point& rDestPt, const Size& rDestSize, + const Bitmap& rBitmap, const Color& rMaskColor ); + + void DrawMask( const Point& rDestPt, const Size& rDestSize, + const Point& rSrcPtPixel, const Size& rSrcSizePixel, + const Bitmap& rBitmap, const Color& rMaskColor); + + void DrawMask( const Point& rDestPt, const Size& rDestSize, + const Point& rSrcPtPixel, const Size& rSrcSizePixel, + const Bitmap& rBitmap, const Color& rMaskColor, + MetaActionType nAction ); + +protected: + + virtual void DrawDeviceMask ( + const Bitmap& rMask, const Color& rMaskColor, + const Point& rDestPt, const Size& rDestSize, + const Point& rSrcPtPixel, const Size& rSrcSizePixel ); + ///@} + + + /** @name Map functions + */ + ///@{ + +public: + + void EnableMapMode( bool bEnable = true ); + bool IsMapModeEnabled() const { return mbMap; } + + void SetMapMode(); + void SetMapMode( const MapMode& rNewMapMode ); + void SetRelativeMapMode( const MapMode& rNewMapMode ); + virtual void SetMetafileMapMode(const MapMode& rNewMapMode, bool bIsRecord); + const MapMode& GetMapMode() const { return maMapMode; } + +protected: + virtual void ImplInitMapModeObjects(); + +public: + // #i75163# + basegfx::B2DHomMatrix GetViewTransformation() const; + basegfx::B2DHomMatrix GetInverseViewTransformation() const; + + basegfx::B2DHomMatrix GetViewTransformation( const MapMode& rMapMode ) const; + basegfx::B2DHomMatrix GetInverseViewTransformation( const MapMode& rMapMode ) const; + + + /** Set an offset in pixel + + This method offsets every drawing operation that converts its + coordinates to pixel by the given value. Normally, the effect + can be achieved by setting a MapMode with a different + origin. Unfortunately, this origin is in logical coordinates + and can lead to rounding errors (see #102532# for details). + + @attention This offset is only applied when converting to + pixel, i.e. some output modes such as metafile recordings + might be completely unaffected by this method! Use with + care. Furthermore, if the OutputDevice's MapMode is the + default (that's MapUnit::MapPixel), then any pixel offset set is + ignored also. This might be unintuitive for cases, but would + have been far more fragile to implement. What's more, the + reason why the pixel offset was introduced (avoiding rounding + errors) does not apply for MapUnit::MapPixel, because one can always + use the MapMode origin then. + + @param rOffset + The offset in pixel + */ + void SetPixelOffset( const Size& rOffset ); + + /** Get the offset in pixel + + @see OutputDevice::SetPixelOffset for details + + @return the current offset in pixel + */ + SAL_WARN_UNUSED_RESULT Size GetPixelOffset() const { return Size(mnOutOffOrigX, mnOutOffOrigY);} + + SAL_WARN_UNUSED_RESULT Point LogicToPixel(const Point& rLogicPt) const; + SAL_WARN_UNUSED_RESULT Size LogicToPixel(const Size& rLogicSize) const; + SAL_WARN_UNUSED_RESULT tools::Rectangle LogicToPixel(const tools::Rectangle& rLogicRect) const; + SAL_WARN_UNUSED_RESULT tools::Polygon LogicToPixel(const tools::Polygon& rLogicPoly) const; + SAL_WARN_UNUSED_RESULT tools::PolyPolygon LogicToPixel(const tools::PolyPolygon& rLogicPolyPoly) const; + SAL_WARN_UNUSED_RESULT basegfx::B2DPolyPolygon LogicToPixel(const basegfx::B2DPolyPolygon& rLogicPolyPoly) const; + SAL_WARN_UNUSED_RESULT vcl::Region LogicToPixel(const vcl::Region& rLogicRegion)const; + SAL_WARN_UNUSED_RESULT Point LogicToPixel(const Point& rLogicPt, const MapMode& rMapMode) const; + SAL_WARN_UNUSED_RESULT Size LogicToPixel(const Size& rLogicSize, const MapMode& rMapMode) const; + SAL_WARN_UNUSED_RESULT tools::Rectangle LogicToPixel(const tools::Rectangle& rLogicRect, + const MapMode& rMapMode) const; + SAL_WARN_UNUSED_RESULT tools::Polygon LogicToPixel(const tools::Polygon& rLogicPoly, + const MapMode& rMapMode) const; + SAL_WARN_UNUSED_RESULT basegfx::B2DPolyPolygon LogicToPixel(const basegfx::B2DPolyPolygon& rLogicPolyPoly, + const MapMode& rMapMode) const; + + SAL_WARN_UNUSED_RESULT Point PixelToLogic(const Point& rDevicePt) const; + SAL_WARN_UNUSED_RESULT Size PixelToLogic(const Size& rDeviceSize) const; + SAL_WARN_UNUSED_RESULT tools::Rectangle PixelToLogic(const tools::Rectangle& rDeviceRect) const; + SAL_WARN_UNUSED_RESULT tools::Polygon PixelToLogic(const tools::Polygon& rDevicePoly) const; + SAL_WARN_UNUSED_RESULT tools::PolyPolygon PixelToLogic(const tools::PolyPolygon& rDevicePolyPoly) const; + SAL_WARN_UNUSED_RESULT basegfx::B2DPolyPolygon PixelToLogic(const basegfx::B2DPolyPolygon& rDevicePolyPoly) const; + SAL_WARN_UNUSED_RESULT vcl::Region PixelToLogic(const vcl::Region& rDeviceRegion) const; + SAL_WARN_UNUSED_RESULT Point PixelToLogic(const Point& rDevicePt, const MapMode& rMapMode) const; + SAL_WARN_UNUSED_RESULT Size PixelToLogic(const Size& rDeviceSize, const MapMode& rMapMode) const; + SAL_WARN_UNUSED_RESULT tools::Rectangle PixelToLogic(const tools::Rectangle& rDeviceRect, + const MapMode& rMapMode) const; + SAL_WARN_UNUSED_RESULT tools::Polygon PixelToLogic(const tools::Polygon& rDevicePoly, + const MapMode& rMapMode) const; + SAL_WARN_UNUSED_RESULT basegfx::B2DPolygon PixelToLogic(const basegfx::B2DPolygon& rDevicePoly, + const MapMode& rMapMode) const; + SAL_WARN_UNUSED_RESULT basegfx::B2DPolyPolygon PixelToLogic(const basegfx::B2DPolyPolygon& rDevicePolyPoly, + const MapMode& rMapMode) const; + + SAL_WARN_UNUSED_RESULT Point LogicToLogic(const Point& rPtSource, + const MapMode* pMapModeSource, + const MapMode* pMapModeDest) const; + SAL_WARN_UNUSED_RESULT Size LogicToLogic(const Size& rSzSource, + const MapMode* pMapModeSource, + const MapMode* pMapModeDest) const; + SAL_WARN_UNUSED_RESULT tools::Rectangle LogicToLogic(const tools::Rectangle& rRectSource, + const MapMode* pMapModeSource, + const MapMode* pMapModeDest) const; + SAL_WARN_UNUSED_RESULT static Point LogicToLogic(const Point& rPtSource, + const MapMode& rMapModeSource, + const MapMode& rMapModeDest); + SAL_WARN_UNUSED_RESULT static Size LogicToLogic(const Size& rSzSource, + const MapMode& rMapModeSource, + const MapMode& rMapModeDest); + SAL_WARN_UNUSED_RESULT static tools::Rectangle LogicToLogic(const tools::Rectangle& rRectSource, + const MapMode& rMapModeSource, + const MapMode& rMapModeDest); + SAL_WARN_UNUSED_RESULT static tools::Long LogicToLogic(tools::Long nLongSource, + MapUnit eUnitSource, + MapUnit eUnitDest); + + SAL_WARN_UNUSED_RESULT static basegfx::B2DPolygon LogicToLogic(const basegfx::B2DPolygon& rPoly, + const MapMode& rMapModeSource, + const MapMode& rMapModeDest); + + // create a mapping transformation from rMapModeSource to rMapModeDest (the above methods + // for B2DPoly/Polygons use this internally anyway to transform the B2DPolygon) + SAL_WARN_UNUSED_RESULT static basegfx::B2DHomMatrix LogicToLogic(const MapMode& rMapModeSource, + const MapMode& rMapModeDest); + + /** Convert a logical rectangle to a rectangle in physical device pixel units. + + @param rLogicRect Const reference to a rectangle in logical units + + @returns Rectangle based on physical device pixel coordinates and units. + */ + SAL_DLLPRIVATE tools::Rectangle ImplLogicToDevicePixel( const tools::Rectangle& rLogicRect ) const; + + /** Convert a logical point to a physical point on the device. + + @param rLogicPt Const reference to a point in logical units. + + @returns Physical point on the device. + */ + SAL_DLLPRIVATE Point ImplLogicToDevicePixel( const Point& rLogicPt ) const; + SAL_DLLPRIVATE DevicePoint ImplLogicToDeviceFontCoordinate(const Point& rLogicPt) const; + + /** Convert a logical width to a width in units of device pixels. + + To get the number of device pixels, it must calculate the X-DPI of the device and + the map scaling factor. If there is no mapping, then it just returns the + width as nothing more needs to be done. + + @param nWidth Logical width + + @returns Width in units of device pixels. + */ + SAL_DLLPRIVATE tools::Long ImplLogicWidthToDevicePixel( tools::Long nWidth ) const; + SAL_DLLPRIVATE double ImplLogicWidthToDeviceFontWidth(tools::Long nWidth) const; + + SAL_DLLPRIVATE DeviceCoordinate LogicWidthToDeviceCoordinate( tools::Long nWidth ) const; + + /** Convert a logical X coordinate to a device pixel's X coordinate. + + To get the device's X coordinate, it must calculate the mapping offset + coordinate X position (if there is one - if not then it just adds + the pseudo-window offset to the logical X coordinate), the X-DPI of + the device and the mapping's X scaling factor. + + @param nX Logical X coordinate + + @returns Device's X pixel coordinate + */ + SAL_DLLPRIVATE tools::Long ImplLogicXToDevicePixel( tools::Long nX ) const; + + /** Convert a logical Y coordinate to a device pixel's Y coordinate. + + To get the device's Y coordinate, it must calculate the mapping offset + coordinate Y position (if there is one - if not then it just adds + the pseudo-window offset to the logical Y coordinate), the Y-DPI of + the device and the mapping's Y scaling factor. + + @param nY Logical Y coordinate + + @returns Device's Y pixel coordinate + */ + SAL_DLLPRIVATE tools::Long ImplLogicYToDevicePixel( tools::Long nY ) const; + + /** Convert a logical height to a height in units of device pixels. + + To get the number of device pixels, it must calculate the Y-DPI of the device and + the map scaling factor. If there is no mapping, then it just returns the + height as nothing more needs to be done. + + @param nHeight Logical height + + @returns Height in units of device pixels. + */ + SAL_DLLPRIVATE tools::Long ImplLogicHeightToDevicePixel( tools::Long nHeight ) const; + + /** Convert device pixels to a width in logical units. + + To get the logical width, it must calculate the X-DPI of the device and the + map scaling factor. + + @param nWidth Width in device pixels + + @returns Width in logical units. + */ + SAL_DLLPRIVATE tools::Long ImplDevicePixelToLogicWidth( tools::Long nWidth ) const; + + /** Convert device pixels to a height in logical units. + + To get the logical height, it must calculate the Y-DPI of the device and the + map scaling factor. + + @param nHeight Height in device pixels + + @returns Height in logical units. + */ + SAL_DLLPRIVATE tools::Long ImplDevicePixelToLogicHeight( tools::Long nHeight ) const; + + /** Convert logical height to device pixels, with exact sub-pixel value. + + To get the \em exact pixel height, it must calculate the Y-DPI of the device and the + map scaling factor. + + @param fLogicHeight Exact height in logical units. + + @returns Exact height in pixels - returns as a float to provide for subpixel value. + */ + SAL_DLLPRIVATE float ImplFloatLogicHeightToDevicePixel( float fLogicHeight ) const; + + /** Convert a logical size to the size on the physical device. + + @param rLogicSize Const reference to a size in logical units + + @returns Physical size on the device. + */ + SAL_DLLPRIVATE Size ImplLogicToDevicePixel( const Size& rLogicSize ) const; + + /** Convert a rectangle in physical pixel units to a rectangle in physical pixel units and coords. + + @param rPixelRect Const reference to rectangle in logical units and coords. + + @returns Rectangle based on logical coordinates and units. + */ + SAL_DLLPRIVATE tools::Rectangle ImplDevicePixelToLogic( const tools::Rectangle& rPixelRect ) const; + + /** Convert a logical polygon to a polygon in physical device pixel units. + + @param rLogicPoly Const reference to a polygon in logical units + + @returns Polygon based on physical device pixel coordinates and units. + */ + SAL_DLLPRIVATE tools::Polygon ImplLogicToDevicePixel( const tools::Polygon& rLogicPoly ) const; + + /** Convert a logical B2DPolygon to a B2DPolygon in physical device pixel units. + + @param rLogicSize Const reference to a B2DPolygon in logical units + + @returns B2DPolyPolygon based on physical device pixel coordinates and units. + */ + SAL_DLLPRIVATE ::basegfx::B2DPolygon ImplLogicToDevicePixel( const ::basegfx::B2DPolygon& rLogicPoly ) const; + + /** Convert a logical polypolygon to a polypolygon in physical device pixel units. + + @param rLogicPolyPoly Const reference to a polypolygon in logical units + + @returns Polypolygon based on physical device pixel coordinates and units. + */ + SAL_DLLPRIVATE tools::PolyPolygon ImplLogicToDevicePixel( const tools::PolyPolygon& rLogicPolyPoly ) const; + + /** Convert a line in logical units to a line in physical device pixel units. + + @param rLineInfo Const reference to a line in logical units + + @returns Line based on physical device pixel coordinates and units. + */ + SAL_DLLPRIVATE LineInfo ImplLogicToDevicePixel( const LineInfo& rLineInfo ) const; + + /** Convert a region in pixel units to a region in device pixel units and coords. + + @param rRegion Const reference to region. + + @returns vcl::Region based on device pixel coordinates and units. + */ + SAL_DLLPRIVATE vcl::Region ImplPixelToDevicePixel( const vcl::Region& rRegion ) const; + + /** Invalidate the view transformation. + + @since AOO bug 75163 (OpenOffice.org 2.4.3 - OOH 680 milestone 212) + */ + SAL_DLLPRIVATE void ImplInvalidateViewTransform(); + + /** Get device transformation. + + @since AOO bug 75163 (OpenOffice.org 2.4.3 - OOH 680 milestone 212) + */ + SAL_DLLPRIVATE basegfx::B2DHomMatrix ImplGetDeviceTransformation() const; + ///@} + + + /** @name Native Widget Rendering functions + + These all just call through to the private mpGraphics functions of the same name. + */ + ///@{ + +public: + + /** Determine if native widgets can be enabled + */ + virtual bool CanEnableNativeWidget() const { return false; } + + /** Query the platform layer for control support + */ + bool IsNativeControlSupported( ControlType nType, ControlPart nPart ) const; + + /** Query the native control to determine if it was acted upon + */ + bool HitTestNativeScrollbar( + ControlPart nPart, + const tools::Rectangle& rControlRegion, + const Point& aPos, + bool& rIsInside ) const; + + /** Request rendering of a particular control and/or part + */ + bool DrawNativeControl( + ControlType nType, + ControlPart nPart, + const tools::Rectangle& rControlRegion, + ControlState nState, + const ImplControlValue& aValue, + const OUString& aCaption, + const Color& rBackgroundColor = COL_AUTO ); + + /** Query the native control's actual drawing region (including adornment) + */ + bool GetNativeControlRegion( + ControlType nType, + ControlPart nPart, + const tools::Rectangle& rControlRegion, + ControlState nState, + const ImplControlValue& aValue, + tools::Rectangle &rNativeBoundingRegion, + tools::Rectangle &rNativeContentRegion ) const; + ///@} + + /** @name EPS functions + */ + ///@{ + +public: + + /** @returns boolean value to see if EPS could be painted directly. + Theoretically, handing over a matrix would be needed to handle + painting rotated EPS files (e.g. contained in Metafiles). This + would then need to be supported for Mac and PS printers, but + that's too much for now, wrote \#i107046# for this */ + bool DrawEPS( + const Point& rPt, const Size& rSz, + const GfxLink& rGfxLink, GDIMetaFile* pSubst = nullptr ); + ///@} + +public: + virtual css::awt::DeviceInfo GetDeviceInfo() const; + + /** Get the vcl::Window that this OutputDevice belongs to, if any */ + virtual vcl::Window* GetOwnerWindow() const { return nullptr; } + +protected: + css::awt::DeviceInfo GetCommonDeviceInfo(Size const& aDevSize) const; + +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/outdev/ScopedStates.hxx b/include/vcl/outdev/ScopedStates.hxx new file mode 100644 index 000000000..7542cfeed --- /dev/null +++ b/include/vcl/outdev/ScopedStates.hxx @@ -0,0 +1,41 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_VCL_SCOPEDSTATES_HXX +#define INCLUDED_VCL_SCOPEDSTATES_HXX + +#include <vcl/outdev.hxx> + +namespace vcl +{ +class ScopedAntialiasing +{ +private: + OutputDevice& m_rOutputDevice; + AntialiasingFlags m_nPreviousAAState; + +public: + ScopedAntialiasing(OutputDevice& rOutputDevice, bool bAAState) + : m_rOutputDevice(rOutputDevice) + , m_nPreviousAAState(m_rOutputDevice.GetAntialiasing()) + { + if (bAAState) + rOutputDevice.SetAntialiasing(m_nPreviousAAState | AntialiasingFlags::Enable); + else + rOutputDevice.SetAntialiasing(m_nPreviousAAState & ~AntialiasingFlags::Enable); + } + + ~ScopedAntialiasing() { m_rOutputDevice.SetAntialiasing(m_nPreviousAAState); } +}; +} + +#endif // INCLUDED_VCL_SCOPEDSTATES_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/pdf/PDFAnnotationMarker.hxx b/include/vcl/pdf/PDFAnnotationMarker.hxx new file mode 100644 index 000000000..c4be54d69 --- /dev/null +++ b/include/vcl/pdf/PDFAnnotationMarker.hxx @@ -0,0 +1,77 @@ +/* -*- 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/. + * + */ + +#pragma once + +#include <vcl/dllapi.h> +#include <tools/color.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <basegfx/point/b2dpoint.hxx> + +namespace vcl::pdf +{ +struct VCL_DLLPUBLIC PDFAnnotationMarker +{ + PDFAnnotationMarker() + : mnWidth(0.0f) + , maFillColor(COL_TRANSPARENT) + { + } + + float mnWidth; + Color maFillColor; +}; + +struct VCL_DLLPUBLIC PDFAnnotationMarkerCircle : public PDFAnnotationMarker +{ +}; + +struct VCL_DLLPUBLIC PDFAnnotationMarkerSquare : public PDFAnnotationMarker +{ +}; + +struct VCL_DLLPUBLIC PDFAnnotationMarkerInk : public PDFAnnotationMarker +{ + std::vector<basegfx::B2DPolygon> maStrokes; +}; + +struct VCL_DLLPUBLIC PDFAnnotationMarkerPolygon : public PDFAnnotationMarker +{ + basegfx::B2DPolygon maPolygon; +}; + +struct VCL_DLLPUBLIC PDFAnnotationMarkerLine : public PDFAnnotationMarker +{ + basegfx::B2DPoint maLineStart; + basegfx::B2DPoint maLineEnd; +}; + +enum class PDFTextMarkerType +{ + Highlight, + Underline, + Squiggly, + StrikeOut +}; + +struct VCL_DLLPUBLIC PDFAnnotationMarkerHighlight : public PDFAnnotationMarker +{ + std::vector<basegfx::B2DPolygon> maQuads; + PDFTextMarkerType meTextMarkerType; + + PDFAnnotationMarkerHighlight(PDFTextMarkerType eTextMarkerType) + : meTextMarkerType(eTextMarkerType) + { + } +}; + +} // namespace vcl::pdf + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/pdf/PDFAnnotationSubType.hxx b/include/vcl/pdf/PDFAnnotationSubType.hxx new file mode 100644 index 000000000..749100e36 --- /dev/null +++ b/include/vcl/pdf/PDFAnnotationSubType.hxx @@ -0,0 +1,50 @@ +/* -*- 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/. + * + */ + +#pragma once + +namespace vcl::pdf +{ +enum class PDFAnnotationSubType +{ + Unknown = 0, + Text = 1, + Link = 2, + FreeText = 3, + Line = 4, + Square = 5, + Circle = 6, + Polygon = 7, + Polyline = 8, + Highlight = 9, + Underline = 10, + Squiggly = 11, + Strikeout = 12, + Stamp = 13, + Caret = 14, + Ink = 15, + Popup = 16, + FileAttachment = 17, + Sound = 18, + Movie = 19, + Widget = 20, + Screen = 21, + Printermark = 22, + Trapnet = 23, + Watermark = 24, + Threed = 25, + Richmedia = 26, + XFAWidget = 27, + Redact = 28 +}; + +} // namespace vcl::pdf + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/pdf/PDFBitmapType.hxx b/include/vcl/pdf/PDFBitmapType.hxx new file mode 100644 index 000000000..fe5921276 --- /dev/null +++ b/include/vcl/pdf/PDFBitmapType.hxx @@ -0,0 +1,26 @@ +/* -*- 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/. + * + */ + +#pragma once + +namespace vcl::pdf +{ +enum class PDFBitmapType +{ + Unknown = 0, + Gray = 1, + BGR = 2, + BGRx = 3, + BGRA = 4, +}; + +} // namespace vcl::pdf + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/pdf/PDFErrorType.hxx b/include/vcl/pdf/PDFErrorType.hxx new file mode 100644 index 000000000..82cee9e5e --- /dev/null +++ b/include/vcl/pdf/PDFErrorType.hxx @@ -0,0 +1,28 @@ +/* -*- 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/. + * + */ + +#pragma once + +namespace vcl::pdf +{ +enum class PDFErrorType +{ + Success = 0, + Unknown = 1, + File = 2, + Format = 3, + Password = 4, + Security = 5, + Page = 6, +}; + +} // namespace vcl::pdf + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/pdf/PDFFillMode.hxx b/include/vcl/pdf/PDFFillMode.hxx new file mode 100644 index 000000000..e5bc71f0d --- /dev/null +++ b/include/vcl/pdf/PDFFillMode.hxx @@ -0,0 +1,24 @@ +/* -*- 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/. + * + */ + +#pragma once + +namespace vcl::pdf +{ +enum class PDFFillMode +{ + None = 0, + Alternate = 1, + Winding = 2, +}; + +} // namespace vcl::pdf + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/pdf/PDFFindFlags.hxx b/include/vcl/pdf/PDFFindFlags.hxx new file mode 100644 index 000000000..3ad8c77e3 --- /dev/null +++ b/include/vcl/pdf/PDFFindFlags.hxx @@ -0,0 +1,35 @@ +/* -*- 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/. + * + */ + +#pragma once + +#include <o3tl/typed_flags_set.hxx> +#include <sal/types.h> + +namespace vcl::pdf +{ +enum class PDFFindFlags : sal_uInt32 +{ + MatchCase = 0x00000001, + MatchWholeWord = 0x00000002, + Consecutive = 0x00000004, +}; + +} // namespace vcl::pdf + +namespace o3tl +{ +template <> +struct typed_flags<vcl::pdf::PDFFindFlags> : is_typed_flags<vcl::pdf::PDFFindFlags, 0x00000007> +{ +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/pdf/PDFObjectType.hxx b/include/vcl/pdf/PDFObjectType.hxx new file mode 100644 index 000000000..c3ee6c752 --- /dev/null +++ b/include/vcl/pdf/PDFObjectType.hxx @@ -0,0 +1,31 @@ +/* -*- 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/. + * + */ + +#pragma once + +namespace vcl::pdf +{ +enum class PDFObjectType +{ + Unknown = 0, + Boolean = 1, + Number = 2, + String = 3, + Name = 4, + Array = 5, + Dictionary = 6, + Stream = 7, + Nullobj = 8, + Reference = 9 +}; + +} // namespace vcl::pdf + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/pdf/PDFPageObjectType.hxx b/include/vcl/pdf/PDFPageObjectType.hxx new file mode 100644 index 000000000..68e763e64 --- /dev/null +++ b/include/vcl/pdf/PDFPageObjectType.hxx @@ -0,0 +1,27 @@ +/* -*- 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/. + * + */ + +#pragma once + +namespace vcl::pdf +{ +enum class PDFPageObjectType +{ + Unknown = 0, + Text = 1, + Path = 2, + Image = 3, + Shading = 4, + Form = 5 +}; + +} // namespace vcl::pdf + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/pdf/PDFSegmentType.hxx b/include/vcl/pdf/PDFSegmentType.hxx new file mode 100644 index 000000000..98f74482e --- /dev/null +++ b/include/vcl/pdf/PDFSegmentType.hxx @@ -0,0 +1,25 @@ +/* -*- 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/. + * + */ + +#pragma once + +namespace vcl::pdf +{ +enum class PDFSegmentType +{ + Unknown = -1, + Lineto = 0, + Bezierto = 1, + Moveto = 2, +}; + +} // namespace vcl::pdf + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/pdf/PDFTextRenderMode.hxx b/include/vcl/pdf/PDFTextRenderMode.hxx new file mode 100644 index 000000000..366a080fb --- /dev/null +++ b/include/vcl/pdf/PDFTextRenderMode.hxx @@ -0,0 +1,30 @@ +/* -*- 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/. + * + */ + +#pragma once + +namespace vcl::pdf +{ +enum class PDFTextRenderMode +{ + Unknown = -1, + Fill = 0, + Stroke = 1, + FillStroke = 2, + Invisible = 3, + FillClip = 4, + StrokeClip = 5, + FillStrokeClip = 6, + Clip = 7 +}; + +} // namespace vcl::pdf + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/pdfextoutdevdata.hxx b/include/vcl/pdfextoutdevdata.hxx new file mode 100644 index 000000000..45cb71682 --- /dev/null +++ b/include/vcl/pdfextoutdevdata.hxx @@ -0,0 +1,488 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_PDFEXTOUTDEVDATA_HXX +#define INCLUDED_VCL_PDFEXTOUTDEVDATA_HXX + +#include <vcl/dllapi.h> + +#include <vcl/pdfwriter.hxx> +#include <vcl/extoutdevdata.hxx> +#include <vector> +#include <memory> + +class Graphic; +class GDIMetaFile; + +namespace vcl +{ + +/* + A PDFExtOutDevBookmarkEntry is being created by the EditEngine if + a bookmark URL has been parsed. The Application is requested to take + care of each bookmark entry by emptying out the bookmark vector. +*/ +struct PDFExtOutDevBookmarkEntry +{ + /** ID of the link pointing to the bookmark, or -1 if the entry denotes a destination instead of a link. + */ + sal_Int32 nLinkId; + + /** ID of the named destination denoted by the bookmark, or -1 if the entry denotes a link instead of a named destination. + */ + sal_Int32 nDestId; + + /** link target name, respectively destination name + */ + OUString aBookmark; + + PDFExtOutDevBookmarkEntry() + :nLinkId( -1 ) + ,nDestId( -1 ) + { + } +}; + +/* + Class that is being set at the OutputDevice allowing the + application to send enhanced PDF commands like CreateLink +*/ +struct PageSyncData; +struct GlobalSyncData; +class VCL_DLLPUBLIC PDFExtOutDevData final : public ExtOutDevData +{ + + const OutputDevice& mrOutDev; + + bool mbTaggedPDF; + bool mbExportNotes; + bool mbExportNotesPages; + bool mbTransitionEffects; + bool mbUseLosslessCompression; + bool mbReduceImageResolution; + bool mbExportFormFields; + bool mbExportBookmarks; + bool mbExportHiddenSlides; + bool mbSinglePageSheets; + bool mbExportNDests; //i56629 + sal_Int32 mnPage; + sal_Int32 mnCompressionQuality; + css::lang::Locale maDocLocale; + + std::unique_ptr<PageSyncData> mpPageSyncData; + std::unique_ptr<GlobalSyncData> mpGlobalSyncData; + + std::vector< PDFExtOutDevBookmarkEntry > maBookmarks; + std::vector<OUString> maChapterNames; + +public: + + PDFExtOutDevData( const OutputDevice& rOutDev ); + virtual ~PDFExtOutDevData() override; + + bool PlaySyncPageAct( PDFWriter& rWriter, sal_uInt32& rCurGDIMtfAction, const GDIMetaFile& rMtf ); + void ResetSyncData(); + + void PlayGlobalActions( PDFWriter& rWriter ); + + bool GetIsExportNotes() const { return mbExportNotes;} + void SetIsExportNotes( const bool bExportNotes ); + + bool GetIsExportNotesPages() const { return mbExportNotesPages;} + void SetIsExportNotesPages( const bool bExportNotesPages ); + + bool GetIsExportTaggedPDF() const { return mbTaggedPDF;} + void SetIsExportTaggedPDF( const bool bTaggedPDF ); + + bool GetIsExportTransitionEffects() const { return mbTransitionEffects;} + void SetIsExportTransitionEffects( const bool bTransitionalEffects ); + + bool GetIsExportFormFields() const { return mbExportFormFields;} + void SetIsExportFormFields( const bool bExportFormFields ); + + bool GetIsExportBookmarks() const { return mbExportBookmarks;} + void SetIsExportBookmarks( const bool bExportBookmarks ); + + bool GetIsExportHiddenSlides() const { return mbExportHiddenSlides;} + void SetIsExportHiddenSlides( const bool bExportHiddenSlides ); + + void SetIsSinglePageSheets( const bool bSinglePageSheets ); + + bool GetIsExportNamedDestinations() const { return mbExportNDests;} //i56629 + void SetIsExportNamedDestinations( const bool bExportNDests ); //i56629 + + // PageNumber, Compression is being set by the PDFExport + sal_Int32 GetCurrentPageNumber() const { return mnPage;} + void SetCurrentPageNumber( const sal_Int32 nPage ); + + bool GetIsLosslessCompression() const { return mbUseLosslessCompression;} + void SetIsLosslessCompression( const bool bLosslessCompression ); + + void SetCompressionQuality( const sal_Int32 nQuality ); + + bool GetIsReduceImageResolution() const { return mbReduceImageResolution;} + void SetIsReduceImageResolution( const bool bReduceImageResolution ); + + const css::lang::Locale& GetDocumentLocale() const { return maDocLocale;} + void SetDocumentLocale( const css::lang::Locale& rLoc ); + + std::vector< PDFExtOutDevBookmarkEntry >& GetBookmarks() { return maBookmarks;} + const std::vector<OUString>& GetChapterNames() const { return maChapterNames; } + + const Graphic& GetCurrentGraphic() const; + + /** Start a new group of render output + + Use this method to group render output. + */ + void BeginGroup(); + + /** End render output + + This method ends grouped render output, that can be + represented by a GfxLink. This is typically used for + external graphic files, such as JPEGs, EPS files etc. + The BeginGroup/EndGroup calls must exactly enclose the + relevant OutputDevice calls issued to render the + graphic the normal way. + + @param rGraphic + The link to the original graphic + + @param nTransparency + Eight bit transparency value, with 0 denoting full opacity, + and 255 full transparency. + + @param rOutputRect + The output rectangle of the graphic. + + @param rVisibleOutputRect + The visible part of the output. This might be less than + rOutputRect, e.g. for cropped graphics. + */ + void EndGroup( const Graphic& rGraphic, + sal_uInt8 nTransparency, + const tools::Rectangle& rOutputRect, + const tools::Rectangle& rVisibleOutputRect ); + + /// Detect if stream is compressed enough to avoid de-compress / scale & re-compress + bool HasAdequateCompression( const Graphic &rGraphic, + const tools::Rectangle &rOutputRect, + const tools::Rectangle &rVisibleOutputRect ) const; + +//--->i56629 + /** Create a new named destination to be used in a link to this document from another PDF document + (see PDF spec 1.4, 8.2.1) + + @param sDestName + the name this destination will be addressed with from others PDF document + + @param rRect + target rectangle on page to be displayed if dest is jumped to + + @param nPageNr + number of page the dest is on (as returned by NewPage) + or -1 in which case the current page is used + + @returns + the destination id (to be used in SetLinkDest) or + -1 if page id does not exist + */ + sal_Int32 CreateNamedDest( const OUString& sDestName, const tools::Rectangle& rRect, sal_Int32 nPageNr = -1 ); + + /** registers a destination for which a destination ID needs to be known immediately, instead of later on setting it via + SetLinkDest. + + This is used in contexts where a destination is referenced by means other than a link. + + Later in the export process, a call to DescribeRegisteredDest must be made, providing the information about + the destination. + + @return + the unique Id of the destination + */ + sal_Int32 RegisterDest(); + + /** provides detailed information about a destination range which previously has been registered using RegisterDest. + */ + void DescribeRegisteredDest( sal_Int32 nDestId, const tools::Rectangle& rRect, sal_Int32 nPageNr, PDFWriter::DestAreaType eType = PDFWriter::DestAreaType::XYZ ); + +//<---i56629 + + /** Create a new destination to be used in a link + + @param rRect + target rectangle on page to be displayed if dest is jumped to + + @param nPageNr + number of page the dest is on (as returned by NewPage) + or -1 in which case the current page is used + + @param eType + what dest type to use + + @returns + the destination id (to be used in SetLinkDest) or + -1 if page id does not exist + */ + sal_Int32 CreateDest( const tools::Rectangle& rRect, sal_Int32 nPageNr = -1, PDFWriter::DestAreaType eType = PDFWriter::DestAreaType::XYZ ); + /** Create a new link on a page + + @param rRect + active rectangle of the link (that is the area that has to be + hit to activate the link) + + @param nPageNr + number of page the link is on (as returned by NewPage) + or -1 in which case the current page is used + + @param rAltText + Alt text for the link + + @returns + the link id (to be used in SetLinkDest, SetLinkURL) or + -1 if page id does not exist + */ + sal_Int32 CreateLink(const tools::Rectangle& rRect, OUString const& rAltText, sal_Int32 nPageNr = -1); + + /// Create a Screen annotation. + sal_Int32 CreateScreen(const tools::Rectangle& rRect, sal_Int32 nPageNr); + + /** Set the destination for a link + <p>will change a URL type link to a dest link if necessary</p> + + @param nLinkId + the link to be changed + + @param nDestId + the dest the link shall point to + */ + void SetLinkDest( sal_Int32 nLinkId, sal_Int32 nDestId ); + /** Set the URL for a link + <p>will change a dest type link to a URL type link if necessary</p> + @param nLinkId + the link to be changed + + @param rURL + the URL the link shall point to. + there will be no error checking or any kind of + conversion done to this parameter execept this: + it will be output as 7bit Ascii. The URL + will appear literally in the PDF file produced + */ + void SetLinkURL( sal_Int32 nLinkId, const OUString& rURL ); + + /// Set URL for a linked Screen annotation. + void SetScreenURL(sal_Int32 nScreenId, const OUString& rURL); + /// Set URL for an embedded Screen annotation. + void SetScreenStream(sal_Int32 nScreenId, const OUString& rURL); + + /** Create a new outline item + + @param nParent + declares the parent of the new item in the outline hierarchy. + An invalid value will result in a new toplevel item. + + @param rText + sets the title text of the item + + @param nDestID + declares which Dest (created with CreateDest) the outline item + will point to + + @returns + the outline item id of the new item + */ + sal_Int32 CreateOutlineItem( sal_Int32 nParent, const OUString& rText, sal_Int32 nDestID ); + + /** Create a new note on a page + + @param rRect + active rectangle of the note (that is the area that has to be + hit to popup the annotation) + + @param rNote + specifies the contents of the note + + @param nPageNr + number of page the note is on (as returned by NewPage) + or -1 in which case the current page is used + */ + void CreateNote( const tools::Rectangle& rRect, const PDFNote& rNote, sal_Int32 nPageNr = -1 ); + + /** begin a new logical structure element + + BeginStructureElement/EndStructureElement calls build the logical structure + of the PDF - the basis for tagged PDF. Structural elements are implemented + using marked content tags. Each structural element can contain sub elements + (e.g. a section can contain a heading and a paragraph). The structure hierarchy + is build automatically from the Begin/EndStructureElement calls. + + A structural element need not be contained on one page; e.g. paragraphs often + run from one page to the next. In this case the corresponding EndStructureElement + must be called while drawing the next page. + + BeginStructureElement and EndStructureElement must be called only after + PDFWriter::NewPage has been called and before + PDFWriter::Emit gets called. The current page + number is an implicit context parameter for Begin/EndStructureElement. + + For pagination artifacts that are not part of the logical structure + of the document (like header, footer or page number) the special + StructElement NonStructElement exists. To place content + outside of the structure tree simply call + BeginStructureElement( NonStructElement ) then draw your + content and then call EndStructureElement(). Any children + of a NonStructElement will not be part of the structure as well. + + @param eType + denotes what kind of element to begin (e.g. a heading or paragraph) + + @param rAlias + the specified alias will be used as structure tag. Also an entry in the PDF's + role map will be created mapping alias to regular structure type. + + @returns + the id of the newly created structural element + */ + sal_Int32 BeginStructureElement( PDFWriter::StructElement eType, const OUString& rAlias = OUString() ); + /** end a logical structure element + + @see BeginStructureElement + */ + void EndStructureElement(); + /** set the current structure element + + <p> + For different purposes it may be useful to paint a structure element's + content discontinuously. In that case an already existing structure element + can be appended to by using SetCurrentStructureElement. The + referenced structure element becomes the current structure element with + all consequences: all following structure elements are appended as children + of the current element. + </p> + + @param nElement + the id of the new current structure element + + @returns + True if the current structure element could be set successfully + False if the current structure element could not be changed + (e.g. if the passed element id is invalid) + */ + bool SetCurrentStructureElement( sal_Int32 nElement ); + /** get the current structure element id + + @returns + the id of the current structure element + */ + sal_Int32 GetCurrentStructureElement() const; + + /** set a structure attribute on the current structural element + + SetStructureAttribute sets an attribute of the current structural element to a + new value. A consistency check is performed before actually setting the value; + if the check fails, the function returns False and the attribute remains + unchanged. + + @param eAttr + denotes what attribute to change + + @param eVal + the value to set the attribute to + */ + void SetStructureAttribute( PDFWriter::StructAttribute eAttr, PDFWriter::StructAttributeValue eVal ); + /** set a structure attribute on the current structural element + + SetStructureAttributeNumerical sets an attribute of the current structural element + to a new numerical value. A consistency check is performed before actually setting + the value; if the check fails, the function returns False and the attribute + remains unchanged. + + @param eAttr + denotes what attribute to change + + @param nValue + the value to set the attribute to + */ + void SetStructureAttributeNumerical( PDFWriter::StructAttribute eAttr, sal_Int32 nValue ); + /** set the bounding box of a structural element + + SetStructureBoundingBox sets the BBox attribute to a new value. Since the BBox + attribute can only be applied to Table, Figure, + Form and Formula elements, a call of this function + for other element types will be ignored and the BBox attribute not be set. + + @param rRect + the new bounding box for the structural element + */ + void SetStructureBoundingBox( const tools::Rectangle& rRect ); + + /** set the ActualText attribute of a structural element + + ActualText contains the Unicode text without layout artifacts that is shown by + a structural element. For example if a line is ended prematurely with a break in + a word and continued on the next line (e.g. "happen-<newline>stance") the + corresponding ActualText would contain the unbroken line (e.g. "happenstance"). + + @param rText + contains the complete logical text the structural element displays. + */ + void SetActualText( const OUString& rText ); + + /** set the Alt attribute of a strutural element + + Alt is s replacement text describing the contents of a structural element. This + is mainly used by accessibility applications; e.g. a screen reader would read + the Alt replacement text for an image to a visually impaired user. + + @param rText + contains the replacement text for the structural element + */ + void SetAlternateText( const OUString& rText ); + + /** Sets the transitional effect to be applied when the current page gets shown. + + @param eType + the kind of effect to be used; use Regular to disable transitional effects + for this page + + @param nMilliSec + the duration of the transitional effect in milliseconds; + set 0 to disable transitional effects + */ + void SetPageTransition( PDFWriter::PageTransition eType, sal_uInt32 nMilliSec ); + + /** create a new form control + + This function creates a new form control in the PDF and sets its various + properties. Do not pass an actual AnyWidget as rControlType + will be cast to the type described by the type member. + + @param rControlType + a descendant of AnyWidget determining the control's properties + */ + void CreateControl( const PDFWriter::AnyWidget& rControlType ); +}; + +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/pdfread.hxx b/include/vcl/pdfread.hxx new file mode 100644 index 000000000..72508a548 --- /dev/null +++ b/include/vcl/pdfread.hxx @@ -0,0 +1,107 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#ifndef INCLUDED_VCL_SOURCE_FILTER_IPDF_PDFREAD_HXX +#define INCLUDED_VCL_SOURCE_FILTER_IPDF_PDFREAD_HXX + +#include <vector> +#include <tools/gen.hxx> +#include <tools/stream.hxx> +#include <tools/color.hxx> +#include <vcl/graph.hxx> +#include <basegfx/range/b2drectangle.hxx> +#include <com/sun/star/util/DateTime.hpp> + +#include <vcl/pdf/PDFAnnotationSubType.hxx> +#include <vcl/pdf/PDFAnnotationMarker.hxx> + +namespace com::sun::star::uno +{ +template <typename> class Sequence; +} +class Bitmap; + +namespace vcl +{ +/// Fills the rBitmaps vector with rendered pages. +VCL_DLLPUBLIC size_t RenderPDFBitmaps(const void* pBuffer, int nSize, + std::vector<BitmapEx>& rBitmaps, size_t nFirstPage = 0, + int nPages = 1, const basegfx::B2DTuple* pSizeHint = nullptr); + +/// Imports a PDF stream as a VectorGraphicData. +VCL_DLLPUBLIC bool +importPdfVectorGraphicData(SvStream& rStream, + std::shared_ptr<VectorGraphicData>& rVectorGraphicData); + +/// Imports a PDF stream into rGraphic. +VCL_DLLPUBLIC bool ImportPDF(SvStream& rStream, Graphic& rGraphic); + +// When inserting a PDF file as an image or pasting PDF data from the clipboard, at least on a +// Retina iMac, the resulting rendered image does not look sharp without this surprisingly large +// extra scaling factor. Exact reasons unknown. And it isn't enough to have it be just 2 (which is +// the actual Retina factor on my iMac). Possibly the fuzziness is related to what Pdfium uses to +// render text. + +// Also, look at CountDPIScaleFactor() in vcl/source/window/window.cxx. The GetDPIScaleFactor() API +// lies on macOS even more than it does on other platforms, it claims that the DPI scale factor is +// always 1. But in fact most Macs nowadays have a HiDPI ("Retina") display. But we can't just "fix" +// things by making GetDPIScaleFactor() always return 2 on macOS, even if that wouldn't be any more +// wrong, because that then causes other regressions that I have no time to look into now. + +#ifdef MACOSX +constexpr int PDF_INSERT_MAGIC_SCALE_FACTOR = 8; +#else +constexpr int PDF_INSERT_MAGIC_SCALE_FACTOR = 1; +#endif + +struct PDFGraphicAnnotation +{ + OUString maAuthor; + OUString maText; + + basegfx::B2DRectangle maRectangle; // In HMM + css::util::DateTime maDateTime; + + Color maColor; + + pdf::PDFAnnotationSubType meSubType; + std::shared_ptr<pdf::PDFAnnotationMarker> mpMarker; +}; + +class PDFGraphicResult +{ + Graphic maGraphic; + // Size in HMM + Size maSize; + + std::vector<PDFGraphicAnnotation> maAnnotations; + +public: + PDFGraphicResult(Graphic aGraphic, Size const& rSize, + std::vector<PDFGraphicAnnotation> aAnnotations) + : maGraphic(std::move(aGraphic)) + , maSize(rSize) + , maAnnotations(std::move(aAnnotations)) + { + } + + const Graphic& GetGraphic() const { return maGraphic; } + const Size& GetSize() const { return maSize; } + const std::vector<PDFGraphicAnnotation>& GetAnnotations() const { return maAnnotations; } +}; + +/// Import PDF as Graphic images (1 per page), but not loaded yet. +/// Returns the number of pages read. +VCL_DLLPUBLIC size_t ImportPDFUnloaded(const OUString& rURL, + std::vector<PDFGraphicResult>& rGraphics); +} + +#endif // INCLUDED_VCL_SOURCE_FILTER_IPDF_PDFREAD_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/pdfwriter.hxx b/include/vcl/pdfwriter.hxx new file mode 100644 index 000000000..2122a4503 --- /dev/null +++ b/include/vcl/pdfwriter.hxx @@ -0,0 +1,1227 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_VCL_PDFWRITER_HXX +#define INCLUDED_VCL_PDFWRITER_HXX + +#include <config_options.h> +#include <sal/types.h> + +#include <tools/gen.hxx> +#include <tools/color.hxx> +#include <rtl/strbuf.hxx> + +#include <vcl/dllapi.h> +#include <vcl/font.hxx> +#include <vcl/outdev.hxx> +#include <vcl/graph.hxx> + +#include <com/sun/star/lang/Locale.hpp> +#include <com/sun/star/util/DateTime.hpp> + +#include <memory> +#include <vector> +#include <set> + +namespace com::sun::star::beans { class XMaterialHolder; } +namespace com::sun::star::io { class XOutputStream; } +namespace com::sun::star::security { class XCertificate; } + +class GDIMetaFile; +class MapMode; +class LineInfo; +namespace tools { + class Polygon; + class PolyPolygon; +} +class Bitmap; +class BitmapEx; +class Gradient; +class Hatch; +class Wallpaper; + +namespace vcl +{ + +class PDFExtOutDevData; +class PDFWriterImpl; + +struct PDFNote +{ + OUString Title; // optional title for the popup containing the note + OUString Contents; // contents of the note + css::util::DateTime maModificationDate; +}; + +class VCL_DLLPUBLIC PDFOutputStream +{ + public: + virtual ~PDFOutputStream(); + virtual void write( const css::uno::Reference< css::io::XOutputStream >& xStream ) = 0; +}; + +class VCL_DLLPUBLIC PDFWriter +{ + ScopedVclPtr<PDFWriterImpl> xImplementation; + + PDFWriter(const PDFWriter&) = delete; + PDFWriter& operator=(const PDFWriter&) = delete; + +public: + // extended line info + enum CapType { capButt, capRound, capSquare }; + enum JoinType { joinMiter, joinRound, joinBevel }; + struct ExtLineInfo + { + double m_fLineWidth; + double m_fTransparency; + CapType m_eCap; + JoinType m_eJoin; + double m_fMiterLimit; + std::vector< double > m_aDashArray; + + ExtLineInfo() : m_fLineWidth( 0.0 ), + m_fTransparency( 0.0 ), + m_eCap( capButt ), + m_eJoin( joinMiter ), + m_fMiterLimit( 10.0 ) + {} + }; + + enum class Orientation { Portrait, Inherit }; + + // in case the below enum is added PDF_1_6 PDF_1_7, please add them just after PDF_1_5 + enum class PDFVersion { PDF_1_2, PDF_1_3, PDF_1_4, PDF_1_5, PDF_1_6, PDF_A_1, PDF_A_2, PDF_A_3 };//i59651, PDF/A-1b & -1a, only -1b implemented for now + // for the meaning of DestAreaType please look at PDF Reference Manual + // version 1.4 section 8.2.1, page 475 + enum class DestAreaType { XYZ, FitRectangle }; + + // for a definition of structural element types please refer to + // PDF Reference, 3rd ed. section 9.7.4 + enum StructElement + { + // special element to place outside the structure hierarchy + NonStructElement, + // Grouping elements + Document, Part, Article, Section, Division, BlockQuote, + Caption, TOC, TOCI, Index, + + // block level elements + Paragraph, Heading, H1, H2, H3, H4, H5, H6, + List, ListItem, LILabel, LIBody, + Table, TableRow, TableHeader, TableData, + + // inline level elements + Span, Quote, Note, Reference, BibEntry, Code, Link, + + // illustration elements + Figure, Formula, Form + }; + + enum StructAttribute + { + Placement, WritingMode, SpaceBefore, SpaceAfter, StartIndent, EndIndent, + TextIndent, TextAlign, Width, Height, BlockAlign, InlineAlign, + LineHeight, BaselineShift, TextDecorationType, ListNumbering, + RowSpan, ColSpan, Scope, + + // link destination is an artificial attribute that sets + // the link annotation ID of a Link element + // further note: since structure attributes can only be + // set during content creation, but links can be + // created after the fact, it is possible to set + // an arbitrary id as structure attribute here. In this + // case the arbitrary id has to be passed again when the + // actual link annotation is created via SetLinkPropertyID + LinkAnnotation, + // Language currently sets a LanguageType (see i18nlangtag/lang.h) + // which will be internally changed to a corresponding locale + Language + }; + + enum StructAttributeValue + { + Invalid, + NONE, + // Placement + Block, Inline, Before, After, Start, End, + // WritingMode + LrTb, RlTb, TbRl, + // TextAlign + Center, Justify, + // Width, Height, + Auto, + // BlockAlign + Middle, + // LineHeight + Normal, + // TextDecorationType + Underline, Overline, LineThrough, + // Scope + Row, Column, Both, + // ListNumbering + Disc, Circle, Square, Decimal, UpperRoman, LowerRoman, UpperAlpha, LowerAlpha + }; + + enum class PageTransition + { + Regular, + SplitHorizontalInward, SplitHorizontalOutward, + SplitVerticalInward, SplitVerticalOutward, + BlindsHorizontal, BlindsVertical, + BoxInward, BoxOutward, + WipeLeftToRight, WipeBottomToTop, WipeRightToLeft, WipeTopToBottom, + Dissolve + }; + + enum WidgetType + { + PushButton, RadioButton, CheckBox, Edit, ListBox, ComboBox, Hierarchy, + Signature + }; + + enum FormatType + { + Text, Number, Time, Date + }; + + enum ErrorCode + { + // transparent object occurred and was draw opaque because + // PDF/A does not allow transparency + Warning_Transparency_Omitted_PDFA, + + // transparent object occurred but is only supported since + // PDF 1.4 + Warning_Transparency_Omitted_PDF13, + + // a form action was exported that is not suitable for PDF/A + // the action was skipped + Warning_FormAction_Omitted_PDFA, + + // transparent objects were converted to a bitmap in order + // to removetransparencies from the output + Warning_Transparency_Converted, + + // signature generation failed + Error_Signature_Failed, + }; + + struct UNLESS_MERGELIBS(VCL_DLLPUBLIC) AnyWidget + { + WidgetType Type; // primitive RTTI + public: + OUString Name; // a distinct name to identify the control + OUString Description;// descriptive text for the control (e.g. for tool tip) + OUString Text; // user text to appear on the control + DrawTextFlags TextStyle; // style flags + bool ReadOnly; + tools::Rectangle Location; // describes the area filled by the control + bool Border; // true: widget should have a border, false: no border + Color BorderColor;// COL_TRANSPARENT and Border=true means get color from application settings + bool Background; // true: widget shall draw its background, false: no background + Color BackgroundColor; // COL_TRANSPARENT and Background=true means get color from application settings + vcl::Font TextFont; // an empty font will be replaced by the + // appropriate font from the user settings + Color TextColor; // COL_TRANSPARENT will be replaced by the appropriate color from application settings + sal_Int32 TabOrder; // lowest number is first in tab order + + /* style flags for text are those for OutputDevice::DrawText + allowed values are: + DrawTextFlags::Left, DrawTextFlags::Center, DrawTextFlags::Right, DrawTextFlags::Top, + DrawTextFlags::VCenter, DrawTextFlags::Bottom, + DrawTextFlags::MultiLine, DrawTextFlags::WordBreak + + if TextStyle is 0, then each control will fill in default values + */ + + // note: the Name member comprises the field name of the resulting + // PDF field names need to be globally unique. Therefore if any + // Widget with an already used name is created, the name will be + // made unique by adding an underscore ('_') and an ascending number + // to the name. + + AnyWidget( WidgetType eType ) : + Type( eType ), + TextStyle( DrawTextFlags::NONE ), + ReadOnly( false ), + Border( false ), + BorderColor( COL_TRANSPARENT ), + Background( false ), + BackgroundColor( COL_TRANSPARENT ), + TextColor( COL_TRANSPARENT ), + TabOrder( -1 ) + {} + virtual ~AnyWidget(); + + WidgetType getType() const { return Type; } + + virtual std::shared_ptr<AnyWidget> Clone() const = 0; + + protected: + // note that this equals the default compiler-generated copy-ctor, but we want to have it + // protected, to only allow sub classes to access it + AnyWidget( const AnyWidget& rSource ) + :Type( rSource.Type ) + ,Name( rSource.Name ) + ,Description( rSource.Description ) + ,Text( rSource.Text ) + ,TextStyle( rSource.TextStyle ) + ,ReadOnly( rSource.ReadOnly ) + ,Location( rSource.Location ) + ,Border( rSource.Border ) + ,BorderColor( rSource.BorderColor ) + ,Background( rSource.Background ) + ,BackgroundColor( rSource.BackgroundColor ) + ,TextFont( rSource.TextFont ) + ,TextColor( rSource.TextColor ) + ,TabOrder( rSource.TabOrder ) + { + } + AnyWidget& operator=( const AnyWidget& ); // never implemented + }; + + struct PushButtonWidget final : public AnyWidget + { + /* If Dest is set to a valid link destination, + Then pressing the button will act as a goto + action within the document. + + Else: + An empty URL means this button will reset the form. + + If URL is not empty and Submit is set, then the URL + contained will be set as the URL to submit the + form to. In this case the submit method will be + either GET if SubmitGet is true or POST if + SubmitGet is false. + + If URL is not empty and Submit is clear, then + the URL contained will be interpreted as a + hyperlink to be executed on pushing the button. + + There will be no error checking or any kind of + conversion done to the URL parameter execept this: + it will be output as 7bit Ascii. The URL + will appear literally in the PDF file produced + */ + sal_Int32 Dest; + OUString URL; + bool Submit; + bool SubmitGet; + + PushButtonWidget() + : AnyWidget( vcl::PDFWriter::PushButton ), + Dest( -1 ), Submit( false ), SubmitGet( false ) + {} + + virtual std::shared_ptr<AnyWidget> Clone() const override + { + return std::make_shared<PushButtonWidget>( *this ); + } + }; + + struct CheckBoxWidget final : public AnyWidget + { + bool Checked; + OUString OnValue; // the value of the checkbox if it is selected + OUString OffValue; // the value of the checkbox if it is not selected + + CheckBoxWidget() + : AnyWidget( vcl::PDFWriter::CheckBox ), + Checked( false ) + {} + + virtual std::shared_ptr<AnyWidget> Clone() const override + { + return std::make_shared<CheckBoxWidget>( *this ); + } + }; + + struct RadioButtonWidget final : public AnyWidget + { + bool Selected; + sal_Int32 RadioGroup; + OUString OnValue; // the value of the radio button if it is selected + OUString OffValue; // the value of the radio button if it is not selected + + RadioButtonWidget() + : AnyWidget( vcl::PDFWriter::RadioButton ), + Selected( false ), + RadioGroup( 0 ) + {} + + virtual std::shared_ptr<AnyWidget> Clone() const override + { + return std::make_shared<RadioButtonWidget>( *this ); + } + // radio buttons having the same RadioGroup id comprise one + // logical radio button group, that is at most one of the RadioButtons + // in a group can be checked at any time + // + // note: a PDF radio button field consists of a named field + // containing unnamed checkbox child fields. The name of the + // radio button field is taken from the first RadioButtonWidget created + // in the group + }; + + struct EditWidget final : public AnyWidget + { + bool MultiLine; // whether multiple lines are allowed + bool Password; // visible echo off + bool FileSelect; // field is a file selector + sal_Int32 MaxLen; // maximum field length in characters, 0 means unlimited + FormatType Format; + OUString CurrencySymbol; + sal_Int32 DecimalAccuracy; + bool PrependCurrencySymbol; + OUString TimeFormat; + OUString DateFormat; + + EditWidget() + : AnyWidget( vcl::PDFWriter::Edit ), + MultiLine( false ), + Password( false ), + FileSelect( false ), + MaxLen( 0 ), + Format( FormatType::Text ), + DecimalAccuracy ( 0 ), + PrependCurrencySymbol( false ) + {} + + virtual std::shared_ptr<AnyWidget> Clone() const override + { + return std::make_shared<EditWidget>( *this ); + } + }; + + struct ListBoxWidget final : public AnyWidget + { + bool DropDown; + bool MultiSelect; + std::vector<OUString> Entries; + std::vector<sal_Int32> SelectedEntries; + // if MultiSelect is false only the first entry of SelectedEntries + // will be taken into account. the same is implicit for PDF < 1.4 + // since multiselect is a 1.4+ feature + + ListBoxWidget() + : AnyWidget( vcl::PDFWriter::ListBox ), + DropDown( false ), + MultiSelect( false ) + {} + + virtual std::shared_ptr<AnyWidget> Clone() const override + { + return std::make_shared<ListBoxWidget>( *this ); + } + }; + + // note: PDF only supports dropdown comboboxes + struct ComboBoxWidget final : public AnyWidget + { + std::vector<OUString> Entries; + // set the current value in AnyWidget::Text + + ComboBoxWidget() + : AnyWidget( vcl::PDFWriter::ComboBox ) + {} + + virtual std::shared_ptr<AnyWidget> Clone() const override + { + return std::make_shared<ComboBoxWidget>( *this ); + } + }; + + struct SignatureWidget final : public AnyWidget + { + SignatureWidget() + : AnyWidget( vcl::PDFWriter::Signature ) + {} + + virtual std::shared_ptr<AnyWidget> Clone() const override + { + return std::make_shared<SignatureWidget>( *this ); + } + }; + + enum ExportDataFormat { HTML, XML, FDF, PDF }; +// see 3.6.1 of PDF 1.4 ref for details, used for 8.1 PDF v 1.4 ref also +// These emuns are treated as integer while reading/writing to configuration + enum PDFViewerPageMode + { + ModeDefault, + UseOutlines, + UseThumbs + }; +// These emuns are treated as integer while reading/writing to configuration + enum PDFViewerAction + { + ActionDefault, + FitInWindow, + FitWidth, + FitVisible, + ActionZoom + }; +// These enums are treated as integer while reading/writing to configuration + enum PDFPageLayout + { + DefaultLayout, + SinglePage, + Continuous, + ContinuousFacing + }; + + // These emuns are treated as integer while reading/writing to configuration + //what default action to generate in a PDF hyperlink to external document/site + enum PDFLinkDefaultAction + { + URIAction, + URIActionDestination, + LaunchAction + }; + +/* +The following structure describes the permissions used in PDF security + */ + struct PDFEncryptionProperties + { + + //for both 40 and 128 bit security, see 3.5.2 PDF v 1.4 table 3.15, v 1.5 and v 1.6 table 3.20. + bool CanPrintTheDocument; + bool CanModifyTheContent; + bool CanCopyOrExtract; + bool CanAddOrModify; + //for revision 3 (bit 128 security) only + bool CanFillInteractive; + bool CanExtractForAccessibility; + bool CanAssemble; + bool CanPrintFull; + + // encryption will only happen if EncryptionKey is not empty + // EncryptionKey is actually a construct out of OValue, UValue and DocumentIdentifier + // if these do not match, behavior is undefined, most likely an invalid PDF will be produced + // OValue, UValue, EncryptionKey and DocumentIdentifier can be computed from + // PDFDocInfo, Owner password and User password used the InitEncryption method which + // implements the algorithms described in the PDF reference chapter 3.5: Encryption + std::vector<sal_uInt8> OValue; + std::vector<sal_uInt8> UValue; + std::vector<sal_uInt8> EncryptionKey; + std::vector<sal_uInt8> DocumentIdentifier; + + //permission default set for 128 bit, accessibility only + PDFEncryptionProperties() : + CanPrintTheDocument ( false ), + CanModifyTheContent ( false ), + CanCopyOrExtract ( false ), + CanAddOrModify ( false ), + CanFillInteractive ( false ), + CanExtractForAccessibility ( true ), + CanAssemble ( false ), + CanPrintFull ( false ) + {} + + + bool Encrypt() const + { return ! OValue.empty() && ! UValue.empty() && ! DocumentIdentifier.empty(); } + }; + + struct PDFDocInfo + { + OUString Title; // document title + OUString Author; // document author + OUString Subject; // subject + OUString Keywords; // keywords + OUString Creator; // application that created the original document + OUString Producer; // OpenOffice + }; + + enum ColorMode + { + DrawColor, DrawGreyscale + }; + + struct PDFWriterContext + { + /* must be a valid file: URL usable by osl */ + OUString URL; + /* the URL of the document being exported, used for relative links*/ + OUString BaseURL; + /*if relative to file system should be formed*/ + bool RelFsys;//i56629, i49415?, i64585? + /*the action to set the PDF hyperlink to*/ + PDFWriter::PDFLinkDefaultAction DefaultLinkAction; + //convert the .od? target file type in a link to a .pdf type + //this is examined before doing anything else + bool ConvertOOoTargetToPDFTarget; + //when the file type is .pdf, force the GoToR action + bool ForcePDFAction; + + /* decides the PDF language level to be produced */ + PDFVersion Version; + + /* PDF/UA compliance */ + bool UniversalAccessibilityCompliance; + + /* valid for PDF >= 1.4 + causes the MarkInfo entry in the document catalog to be set + */ + bool Tagged; + /* determines in which format a form + will be submitted. + */ + PDFWriter::ExportDataFormat SubmitFormat; + bool AllowDuplicateFieldNames; + /* the following data members are used to customize the PDF viewer + preferences + */ + /* see 3.6.1 PDF v 1.4 ref*/ + PDFWriter::PDFViewerPageMode PDFDocumentMode; + PDFWriter::PDFViewerAction PDFDocumentAction; + // in percent, valid only if PDFDocumentAction == ActionZoom + sal_Int32 Zoom; + + /* see 8.6 PDF v 1.4 ref + specifies whether to hide the viewer tool + bars when the document is active. + */ + bool HideViewerToolbar; + bool HideViewerMenubar; + bool HideViewerWindowControls; + bool FitWindow; + bool OpenInFullScreenMode; + bool CenterWindow; + bool DisplayPDFDocumentTitle; + PDFPageLayout PageLayout; + bool FirstPageLeft; + // initially visible page in viewer (starting with 0 for first page) + sal_Int32 InitialPage; + sal_Int32 OpenBookmarkLevels; // -1 means all levels + + PDFWriter::PDFEncryptionProperties Encryption; + PDFWriter::PDFDocInfo DocumentInfo; + + bool SignPDF; + OUString SignLocation; + OUString SignPassword; + OUString SignReason; + OUString SignContact; + css::lang::Locale DocumentLocale; // defines the document default language + sal_uInt32 DPIx, DPIy; // how to handle MapMode( MapUnit::MapPixel ) + // 0 here specifies a default handling + PDFWriter::ColorMode ColorMode; + css::uno::Reference< css::security::XCertificate> SignCertificate; + OUString SignTSA; + /// Use reference XObject markup for PDF images. + bool UseReferenceXObject; + + PDFWriterContext() : + RelFsys( false ), //i56629, i49415?, i64585? + DefaultLinkAction( PDFWriter::URIAction ), + ConvertOOoTargetToPDFTarget( false ), + ForcePDFAction( false ), + Version( PDFWriter::PDFVersion::PDF_1_6 ), + UniversalAccessibilityCompliance( false ), + Tagged( false ), + SubmitFormat( PDFWriter::FDF ), + AllowDuplicateFieldNames( false ), + PDFDocumentMode( PDFWriter::ModeDefault ), + PDFDocumentAction( PDFWriter::ActionDefault ), + Zoom( 100 ), + HideViewerToolbar( false ), + HideViewerMenubar( false ), + HideViewerWindowControls( false ), + FitWindow( false ), + OpenInFullScreenMode( false ), + CenterWindow( false ), + DisplayPDFDocumentTitle( true ), + PageLayout( PDFWriter::DefaultLayout ), + FirstPageLeft( false ), + InitialPage( 1 ), + OpenBookmarkLevels( -1 ), + SignPDF( false ), + DPIx( 0 ), + DPIy( 0 ), + ColorMode( PDFWriter::DrawColor ), + UseReferenceXObject( false ) + {} + }; + + PDFWriter( const PDFWriterContext& rContext, const css::uno::Reference< css::beans::XMaterialHolder >& ); + ~PDFWriter(); + + /** Returns an OutputDevice for formatting + This Output device is guaranteed to use the same + font metrics as the resulting PDF file. + + @returns + the reference output device + */ + OutputDevice* GetReferenceDevice(); + + /** Creates a new page to fill + If width and height are not set the page size + is inherited from the page tree + other effects: + resets the graphics state: MapMode, Font + Colors and other state information MUST + be set again or are undefined. + */ + void NewPage( double nPageWidth, double nPageHeight, Orientation eOrientation = Orientation::Inherit ); + /** Play a metafile like an outputdevice would do + */ + struct PlayMetafileContext + { + int m_nMaxImageResolution; + bool m_bOnlyLosslessCompression; + int m_nJPEGQuality; + bool m_bTransparenciesWereRemoved; + + PlayMetafileContext() + : m_nMaxImageResolution( 0 ) + , m_bOnlyLosslessCompression( false ) + , m_nJPEGQuality( 90 ) + , m_bTransparenciesWereRemoved( false ) + {} + + }; + void PlayMetafile( const GDIMetaFile&, const PlayMetafileContext&, vcl::PDFExtOutDevData* pDevDat = nullptr ); + + /* sets the document locale originally passed with the context to a new value + * only affects the output if used before calling Emit. + */ + void SetDocumentLocale( const css::lang::Locale& rDocLocale ); + + /* finishes the file */ + bool Emit(); + + /* + * Get a list of errors that occurred during processing + * this should enable the producer to give feedback about + * any anomalies that might have occurred + */ + std::set< ErrorCode > const & GetErrors() const; + + // uses 128bit encryption + static css::uno::Reference< css::beans::XMaterialHolder > + InitEncryption( const OUString& i_rOwnerPassword, + const OUString& i_rUserPassword + ); + + /* functions for graphics state */ + /* flag values: see vcl/outdev.hxx */ + void Push( PushFlags nFlags = PushFlags::ALL ); + void Pop(); + + void SetClipRegion(); + void SetClipRegion( const basegfx::B2DPolyPolygon& rRegion ); + void MoveClipRegion( tools::Long nHorzMove, tools::Long nVertMove ); + void IntersectClipRegion( const tools::Rectangle& rRect ); + void IntersectClipRegion( const basegfx::B2DPolyPolygon& rRegion ); + + void SetLayoutMode( vcl::text::ComplexTextLayoutFlags nMode ); + void SetDigitLanguage( LanguageType eLang ); + + void SetLineColor( const Color& rColor ); + void SetLineColor() { SetLineColor( COL_TRANSPARENT ); } + + void SetFillColor( const Color& rColor ); + void SetFillColor() { SetFillColor( COL_TRANSPARENT ); } + + void SetFont( const vcl::Font& rNewFont ); + void SetTextColor( const Color& rColor ); + void SetTextFillColor(); + void SetTextFillColor( const Color& rColor ); + + void SetTextLineColor(); + void SetTextLineColor( const Color& rColor ); + void SetOverlineColor(); + void SetOverlineColor( const Color& rColor ); + void SetTextAlign( ::TextAlign eAlign ); + + void SetMapMode( const MapMode& rNewMapMode ); + + + /* actual drawing functions */ + void DrawText( const Point& rPos, const OUString& rText ); + + void DrawTextLine( const Point& rPos, tools::Long nWidth, + FontStrikeout eStrikeout, + FontLineStyle eUnderline, + FontLineStyle eOverline ); + void DrawTextArray( const Point& rStartPt, const OUString& rStr, + o3tl::span<const sal_Int32> pDXAry, + sal_Int32 nIndex, + sal_Int32 nLen ); + void DrawStretchText( const Point& rStartPt, sal_uLong nWidth, + const OUString& rStr, + sal_Int32 nIndex, sal_Int32 nLen ); + void DrawText( const tools::Rectangle& rRect, + const OUString& rStr, DrawTextFlags nStyle ); + + void DrawPixel( const Point& rPt, const Color& rColor ); + void DrawPixel( const Point& rPt ) + { DrawPixel( rPt, COL_TRANSPARENT ); } + + void DrawLine( const Point& rStartPt, const Point& rEndPt ); + void DrawLine( const Point& rStartPt, const Point& rEndPt, + const LineInfo& rLineInfo ); + void DrawPolyLine( const tools::Polygon& rPoly ); + void DrawPolyLine( const tools::Polygon& rPoly, + const LineInfo& rLineInfo ); + void DrawPolyLine( const tools::Polygon& rPoly, const ExtLineInfo& rInfo ); + void DrawPolygon( const tools::Polygon& rPoly ); + void DrawPolyPolygon( const tools::PolyPolygon& rPolyPoly ); + void DrawRect( const tools::Rectangle& rRect ); + void DrawRect( const tools::Rectangle& rRect, + sal_uLong nHorzRount, sal_uLong nVertRound ); + void DrawEllipse( const tools::Rectangle& rRect ); + void DrawArc( const tools::Rectangle& rRect, + const Point& rStartPt, const Point& rEndPt ); + void DrawPie( const tools::Rectangle& rRect, + const Point& rStartPt, const Point& rEndPt ); + void DrawChord( const tools::Rectangle& rRect, + const Point& rStartPt, const Point& rEndPt ); + + void DrawBitmap( const Point& rDestPt, const Size& rDestSize, + const Bitmap& rBitmap, const Graphic& rGraphic ); + + void DrawBitmapEx( const Point& rDestPt, const Size& rDestSize, + const BitmapEx& rBitmapEx ); + + void DrawGradient( const tools::Rectangle& rRect, const Gradient& rGradient ); + void DrawGradient( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient ); + + void DrawHatch( const tools::PolyPolygon& rPolyPoly, const Hatch& rHatch ); + + void DrawWallpaper( const tools::Rectangle& rRect, const Wallpaper& rWallpaper ); + void DrawTransparent( const tools::PolyPolygon& rPolyPoly, + sal_uInt16 nTransparencePercent ); + + /** Start a transparency group + + Drawing operations can be grouped together to acquire a common transparency + behaviour; after calling BeginTransparencyGroup all drawing + operations will be grouped together into a transparent object. + + The transparency behaviour is set with one of the EndTransparencyGroup + calls and can be either a constant transparency factor or a transparent + soft mask in form of an 8 bit gray scale bitmap. + + It is permissible to nest transparency group. + + Transparency groups MUST NOT span multiple pages + + Transparency is a feature introduced in PDF1.4, so transparency group + will be ignored if the produced PDF has a lower version. The drawing + operations will be emitted normally. + */ + void BeginTransparencyGroup(); + + /** End a transparency group with constant transparency factor + + This ends a transparency group and inserts it on the current page. The + coordinates of the group result out of the grouped drawing operations. + + @param rBoundRect + The bounding rectangle of the group + + @param nTransparencePercent + The transparency factor + */ + void EndTransparencyGroup( const tools::Rectangle& rBoundRect, sal_uInt16 nTransparencePercent ); + + /** Insert a JPG encoded image (optionally with mask) + + @param rJPGData + a Stream containing the encoded image + + @param bIsTrueColor + true: jpeg is 24 bit true color, false: jpeg is 8 bit greyscale + + @param rSrcSizePixel + size in pixel of the image + + @param rTargetArea + where to put the image + + @param rMask + optional mask; if not empty it must have + the same pixel size as the image and + be either 1 bit black&white or 8 bit grey + */ + void DrawJPGBitmap( SvStream& rJPGData, bool bIsTrueColor, const Size& rSrcSizePixel, const tools::Rectangle& rTargetArea, const AlphaMask& rAlphaMask, const Graphic& rGraphic ); + + /** Create a new named destination to be used in a link from another PDF document + + @param sDestName + the name (label) of the bookmark, to be used to jump to + + @param rRect + target rectangle on page to be displayed if dest is jumped to + + @param nPageNr + number of page the dest is on (as returned by NewPage) + or -1 in which case the current page is used + + @param eType + what dest type to use + + @returns + the destination id (to be used in SetLinkDest) or + -1 if page id does not exist + */ + sal_Int32 CreateNamedDest( const OUString& sDestName, const tools::Rectangle& rRect, sal_Int32 nPageNr, DestAreaType eType ); + /** Create a new destination to be used in a link + + @param rRect + target rectangle on page to be displayed if dest is jumped to + + @param nPageNr + number of page the dest is on (as returned by NewPage) + or -1 in which case the current page is used + + @param eType + what dest type to use + + @returns + the destination id (to be used in SetLinkDest) or + -1 if page id does not exist + */ + sal_Int32 CreateDest( const tools::Rectangle& rRect, sal_Int32 nPageNr, DestAreaType eType ); + /** Create a new link on a page + + @param rRect + active rectangle of the link (that is the area that has to be + hit to activate the link) + + @param nPageNr + number of page the link is on (as returned by NewPage) + or -1 in which case the current page is used + + @returns + the link id (to be used in SetLinkDest, SetLinkURL) or + -1 if page id does not exist + */ + sal_Int32 CreateLink(const tools::Rectangle& rRect, sal_Int32 nPageNr, OUString const& rAltText); + + /// Creates a screen annotation. + sal_Int32 CreateScreen(const tools::Rectangle& rRect, sal_Int32 nPageNr); + + /** creates a destination which is not intended to be referred to by a link, but by a public destination Id. + + Form widgets, for instance, might refer to a destination, without ever actually creating a source link to + point to this destination. In such cases, a public destination Id will be assigned to the form widget, + and later on, the concrete destination data for this public Id will be registered using RegisterDestReference. + + @param nDestId + destination ID + + @param rRect + target rectangle on page to be displayed if dest is jumped to + + @param nPageNr + number of page the dest is on (as returned by NewPage) + or -1 in which case the current page is used + + @param eType + what dest type to use + + @returns + the internal destination Id. + */ + sal_Int32 RegisterDestReference( sal_Int32 nDestId, const tools::Rectangle& rRect, sal_Int32 nPageNr, DestAreaType eType ); + + + /** Set the destination for a link + will change a URL type link to a dest link if necessary + + @param nLinkId + the link to be changed + + @param nDestId + the dest the link shall point to + */ + void SetLinkDest( sal_Int32 nLinkId, sal_Int32 nDestId ); + /** Set the URL for a link + will change a dest type link to a URL type link if necessary + @param nLinkId + the link to be changed + + @param rURL + the URL the link shall point to. + The URL will be parsed (and corrected) by the com.sun.star.util.URLTransformer + service; the result will then appear literally in the PDF file produced + */ + void SetLinkURL( sal_Int32 nLinkId, const OUString& rURL ); + + /// Sets the URL of a linked screen annotation. + void SetScreenURL(sal_Int32 nScreenId, const OUString& rURL); + /// Sets the URL of an embedded screen annotation. + void SetScreenStream(sal_Int32 nScreenId, const OUString& rURL); + + /** Resolve link in logical structure + + If a link is created after the corresponding visual appearance was drawn + it is not possible to set the link id as a property attribute to the + link structure item that should be created in tagged PDF around the + visual appearance of a link. + + For this reason an arbitrary id can be given to + SetStructureAttributeNumerical at the time the text for + the link is drawn. To resolve this arbitrary id again when the actual + link annotation is created use SetLinkPropertyID. When Emit + finally gets called all LinkAnnotation type structure attributes + will be replaced with the correct link id. + + CAUTION: this technique must be used either for all or none of the links + in a document since the link id space and arbitrary property id space + could overlap and it would be impossible to resolve whether a Link + structure attribute value was arbitrary or already a real id. + + @param nLinkId + the link to be mapped + + @param nPropertyID + the arbitrary id set in a Link structure element to address + the link with real id nLinkId + */ + void SetLinkPropertyID( sal_Int32 nLinkId, sal_Int32 nPropertyID ); + /** Create a new outline item + + @param nParent + declares the parent of the new item in the outline hierarchy. + An invalid value will result in a new toplevel item. + + @param rText + sets the title text of the item + + @param nDestID + declares which Dest (created with CreateDest) the outline item + will point to + + @returns + the outline item id of the new item + */ + sal_Int32 CreateOutlineItem( sal_Int32 nParent, std::u16string_view rText, sal_Int32 nDestID ); + + /** Create a new note on a page + + @param rRect + active rectangle of the note (that is the area that has to be + hit to popup the annotation) + + @param rNote + specifies the contents of the note + + @param nPageNr + number of page the note is on (as returned by NewPage) + or -1 in which case the current page is used + */ + void CreateNote( const tools::Rectangle& rRect, const PDFNote& rNote, sal_Int32 nPageNr ); + + /** begin a new logical structure element + + BeginStructureElement/EndStructureElement calls build the logical structure + of the PDF - the basis for tagged PDF. Structural elements are implemented + using marked content tags. Each structural element can contain sub elements + (e.g. a section can contain a heading and a paragraph). The structure hierarchy + is build automatically from the Begin/EndStructureElement calls. + + A structural element need not be contained on one page; e.g. paragraphs often + run from one page to the next. In this case the corresponding EndStructureElement + must be called while drawing the next page. + + BeginStructureElement and EndStructureElement must be called only after + PDFWriter::NewPage has been called and before PDFWriter::Emit gets called. The + current page number is an implicit context parameter for Begin/EndStructureElement. + + For pagination artifacts that are not part of the logical structure + of the document (like header, footer or page number) the special + StructElement NonStructElement exists. To place content + outside of the structure tree simply call + BeginStructureElement( NonStructElement ) then draw your + content and then call EndStructureElement(). All children + of a NonStructElement will not be part of the structure. + Nonetheless if you add a child structural element to a + NonStructElement you will still have to call + EndStructureElement for it. Best think of the structure + tree as a stack. + + Note: there is always one structural element in existence without having + called BeginStructureElement; this is the root of the structure + tree (called StructTreeRoot). The StructTreeRoot has always the id 0. + + @param eType + denotes what kind of element to begin (e.g. a heading or paragraph) + + @param rAlias + the specified alias will be used as structure tag. Also an entry in the PDF's + role map will be created mapping alias to regular structure type. + + @returns + the new structure element's id for use in SetCurrentStructureElement + */ + sal_Int32 BeginStructureElement( enum StructElement eType, const OUString& rAlias ); + /** end the current logical structure element + + Close the current structure element. The current element's + parent becomes the current structure element again. + + @see BeginStructureElement + */ + void EndStructureElement(); + /** set the current structure element + + For different purposes it may be useful to paint a structure element's + content discontinuously. In that case an already existing structure element + can be appended to by using SetCurrentStructureElement. The + referenced structure element becomes the current structure element with + all consequences: all following structure elements are appended as children + of the current element. + + @param nElement + the id of the new current structure element + */ + void SetCurrentStructureElement( sal_Int32 nElement ); + + /** set a structure attribute on the current structural element + + SetStructureAttribute sets an attribute of the current structural element to a + new value. A consistency check is performed before actually setting the value; + if the check fails, the function returns False and the attribute remains + unchanged. + + @param eAttr + denotes what attribute to change + + @param eVal + the value to set the attribute to + */ + void SetStructureAttribute( enum StructAttribute eAttr, enum StructAttributeValue eVal ); + /** set a structure attribute on the current structural element + + SetStructureAttributeNumerical sets an attribute of the current structural element + to a new numerical value. A consistency check is performed before actually setting + the value; if the check fails, the function returns False and the attribute + remains unchanged. + + @param eAttr + denotes what attribute to change + + @param nValue + the value to set the attribute to + */ + void SetStructureAttributeNumerical( enum StructAttribute eAttr, sal_Int32 nValue ); + /** set the bounding box of a structural element + + SetStructureBoundingBox sets the BBox attribute to a new value. Since the BBox + attribute can only be applied to Table, Figure, + Form and Formula elements, a call of this function + for other element types will be ignored and the BBox attribute not be set. + + @param rRect + the new bounding box for the structural element + */ + void SetStructureBoundingBox( const tools::Rectangle& rRect ); + + /** set the ActualText attribute of a structural element + + ActualText contains the Unicode text without layout artifacts that is shown by + a structural element. For example if a line is ended prematurely with a break in + a word and continued on the next line (e.g. "happen-<newline>stance") the + corresponding ActualText would contain the unbroken line (e.g. "happenstance"). + + @param rText + contains the complete logical text the structural element displays. + */ + void SetActualText( const OUString& rText ); + + /** set the Alt attribute of a strutural element + + Alt is s replacement text describing the contents of a structural element. This + is mainly used by accessibility applications; e.g. a screen reader would read + the Alt replacement text for an image to a visually impaired user. + + @param rText + contains the replacement text for the structural element + */ + void SetAlternateText( const OUString& rText ); + + /** Sets the transitional effect to be applied when the current page gets shown. + + @param eType + the kind of effect to be used; use Regular to disable transitional effects + for this page + + @param nMilliSec + the duration of the transitional effect in milliseconds; + set 0 to disable transitional effects + + @param nPageNr + the page number to apply the effect to; -1 denotes the current page + */ + void SetPageTransition( PageTransition eType, sal_uInt32 nMilliSec, sal_Int32 nPageNr ); + + /** create a new form control + + This function creates a new form control in the PDF and sets its various + properties. Do not pass an actual AnyWidget as rControlType + will be cast to the type described by the type member. + + @param rControlType + a descendant of AnyWidget determining the control's properties + + @returns + the new control's id for reference purposes + */ + sal_Int32 CreateControl( const AnyWidget& rControlType ); + + /** Inserts an additional stream to the PDF file + + This function adds an arbitrary stream to the produced PDF file. May be called + any time before Emit(). The stream will be written during + Emit by calling the PDFOutputStream Object's write + method. After the call the PDFOutputStream will be deleted. + + All additional streams and their mimetypes will be entered into an array + in the trailer dictionary. + + @param rMimeType + the mimetype of the stream + + @param pStream + the interface to the additional stream + + */ + void AddStream( const OUString& rMimeType, PDFOutputStream* pStream ); + + /// Write rString as a PDF hex string into rBuffer. + static void AppendUnicodeTextString(const OUString& rString, OStringBuffer& rBuffer); + + /// Get current date/time in PDF D:YYYYMMDDHHMMSS form. + static OString GetDateTime(); +}; + +VCL_DLLPUBLIC void escapeStringXML( const OUString& rStr, OUString &rValue); + +} + +#endif // INCLUDED_VCL_PDFWRITER_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/pngwrite.hxx b/include/vcl/pngwrite.hxx new file mode 100644 index 000000000..de2b1c6e1 --- /dev/null +++ b/include/vcl/pngwrite.hxx @@ -0,0 +1,60 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_PNGWRITE_HXX +#define INCLUDED_VCL_PNGWRITE_HXX + +#include <vcl/dllapi.h> +#include <memory> +#include <vector> + +namespace com::sun::star::beans { struct PropertyValue; } +namespace com::sun::star::uno { template <typename > class Sequence; } + +class BitmapEx; +class SvStream; + +namespace vcl +{ + class PNGWriterImpl; + + class VCL_DLLPUBLIC PNGWriter + { + const std::unique_ptr<PNGWriterImpl> mpImpl; + + public: + + explicit PNGWriter(const BitmapEx&, const css::uno::Sequence<css::beans::PropertyValue>* pFilterData = nullptr); + ~PNGWriter(); + + bool Write(SvStream& rStream); + + // additional method to be able to modify all chunk before they are stored + struct ChunkData + { + sal_uInt32 nType; + std::vector<sal_uInt8> aData; + }; + std::vector<vcl::PNGWriter::ChunkData>& GetChunks(); + }; +} + +#endif // INCLUDED_VCL_PNGWRITE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/print.hxx b/include/vcl/print.hxx new file mode 100644 index 000000000..e919b8ee2 --- /dev/null +++ b/include/vcl/print.hxx @@ -0,0 +1,615 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_PRINT_HXX +#define INCLUDED_VCL_PRINT_HXX + +#include <sal/config.h> + +#include <sal/types.h> +#include <rtl/ustring.hxx> +#include <tools/gen.hxx> +#include <tools/long.hxx> +#include <i18nutil/paper.hxx> + +#include <vcl/dllapi.h> +#include <vcl/PrinterSupport.hxx> +#include <vcl/errcode.hxx> +#include <vcl/outdev.hxx> +#include <vcl/prntypes.hxx> +#include <vcl/region.hxx> +#include <vcl/jobset.hxx> + +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/uno/Sequence.hxx> +#include <com/sun/star/view/PrintableState.hpp> + +#include <memory> +#include <unordered_map> + +class GDIMetaFile; +class SalInfoPrinter; +struct SalPrinterQueueInfo; +class QueueInfo; +class SalPrinter; +class VirtualDevice; +enum class SalPrinterError; + +namespace vcl { + class PrinterController; + + namespace printer { + class Options; + } +} + +namespace weld { class Window; } + +class VCL_DLLPUBLIC Printer : public OutputDevice +{ + friend class ::OutputDevice; + +private: + SalInfoPrinter* mpInfoPrinter; + std::unique_ptr<SalPrinter> mpPrinter; + SalGraphics* mpJobGraphics; + VclPtr<Printer> mpPrev; + VclPtr<Printer> mpNext; + VclPtr<VirtualDevice> mpDisplayDev; + std::unique_ptr<vcl::printer::Options> mpPrinterOptions; + OUString maPrinterName; + OUString maDriver; + OUString maPrintFile; + JobSetup maJobSetup; + Point maPageOffset; + Size maPaperSize; + ErrCode mnError; + sal_uInt16 mnPageQueueSize; + sal_uInt16 mnCopyCount; + bool mbDefPrinter; + bool mbPrinting; + bool mbJobActive; + bool mbCollateCopy; + bool mbPrintFile; + bool mbInPrintPage; + bool mbNewJobSetup; + bool mbSinglePrintJobs; + + VCL_DLLPRIVATE void ImplInitData(); + VCL_DLLPRIVATE void ImplInit( SalPrinterQueueInfo* pInfo ); + VCL_DLLPRIVATE void ImplInitDisplay(); + VCL_DLLPRIVATE static SalPrinterQueueInfo* + ImplGetQueueInfo( const OUString& rPrinterName, const OUString* pDriver ); + VCL_DLLPRIVATE void ImplUpdatePageData(); + VCL_DLLPRIVATE void ImplUpdateFontList(); + VCL_DLLPRIVATE void ImplFindPaperFormatForUserSize( JobSetup& ); + + VCL_DLLPRIVATE bool StartJob( const OUString& rJobName, std::shared_ptr<vcl::PrinterController> const & ); + + static VCL_DLLPRIVATE ErrCode + ImplSalPrinterErrorCodeToVCL( SalPrinterError nError ); + + SAL_DLLPRIVATE void ImplPrintTransparent ( + const Bitmap& rBmp, const Bitmap& rMask, + const Point& rDestPt, const Size& rDestSize, + const Point& rSrcPtPixel, const Size& rSrcSizePixel ); + +private: + VCL_DLLPRIVATE void EndJob(); + Printer( const Printer& rPrinter ) = delete; + Printer& operator =( const Printer& rPrinter ) = delete; + +public: + VCL_DLLPRIVATE void ImplStartPage(); + VCL_DLLPRIVATE void ImplEndPage(); + +protected: + virtual bool AcquireGraphics() const override; + virtual void ReleaseGraphics( bool bRelease = true ) override; + void ImplReleaseGraphics(bool bRelease = true); + virtual void ImplReleaseFonts() override; + + virtual tools::Long GetGradientStepCount( tools::Long nMinRect ) override; + virtual bool UsePolyPolygonForComplexGradient() override; + virtual void ClipAndDrawGradientMetafile ( const Gradient &rGradient, + const tools::PolyPolygon &rPolyPoly ) override; + + bool CanSubsampleBitmap() const override { return false; } + vcl::Region ClipToDeviceBounds(vcl::Region aRegion) const override; + +public: + void SetSystemTextColor(SystemTextColorFlags, bool) override; + void DrawGradientEx( OutputDevice* pOut, const tools::Rectangle& rRect, + const Gradient& rGradient ); + virtual Bitmap GetBitmap( const Point& rSrcPt, const Size& rSize ) const override; + virtual Size GetButtonBorderSize() override; + virtual Color GetMonochromeButtonColor() override { return COL_LIGHTGRAY; } + + bool IsScreenComp() const override { return false; } + + void DrawBorder(tools::Rectangle aBorderRect) override + { + SetLineColor(COL_BLACK); + DrawRect(aBorderRect); + } + + css::awt::DeviceInfo GetDeviceInfo() const override; + +protected: + virtual void DrawDeviceMask( const Bitmap& rMask, const Color& rMaskColor, + const Point& rDestPt, const Size& rDestSize, + const Point& rSrcPtPixel, const Size& rSrcSizePixel) override; + + bool DrawTransformBitmapExDirect( const basegfx::B2DHomMatrix& aFullTransform, + const BitmapEx& rBitmapEx, double fAlpha = 1.0) override; + + bool TransformAndReduceBitmapExToTargetRange( const basegfx::B2DHomMatrix& aFullTransform, + basegfx::B2DRange &aVisibleRange, double &fMaximumArea) override; + + void DrawDeviceBitmapEx( const Point& rDestPt, const Size& rDestSize, + const Point& rSrcPtPixel, const Size& rSrcSizePixel, + BitmapEx& rBitmapEx ) override; + + virtual void EmulateDrawTransparent( const tools::PolyPolygon& rPolyPoly, + sal_uInt16 nTransparencePercent ) override; + + virtual void SetFontOrientation( LogicalFontInstance* const pFontInstance ) const override; + + bool shouldDrawWavePixelAsRect(tools::Long) const override { return true; } + void SetWaveLineColors(Color const& rColor, tools::Long) override; + Size GetWaveLineSize(tools::Long nLineWidth) const override; + +public: + Printer(); + Printer( const JobSetup& rJobSetup ); + Printer( const QueueInfo& rQueueInfo ); + Printer( const OUString& rPrinterName ); + virtual ~Printer() override; + virtual void dispose() override; + + virtual void SetMetafileMapMode(const MapMode& rNewMapMode, bool) override { SetMapMode(rNewMapMode); } + + static const std::vector< OUString >& + GetPrinterQueues(); + static const QueueInfo* GetQueueInfo( const OUString& rPrinterName, bool bStatusUpdate ); + static OUString GetDefaultPrinterName(); + + const OUString& GetName() const { return maPrinterName; } + const OUString& GetDriverName() const { return maDriver; } + bool IsDefPrinter() const { return mbDefPrinter; } + bool IsDisplayPrinter() const { return mpDisplayDev != nullptr; } + bool IsValid() const { return !IsDisplayPrinter(); } + + sal_uInt32 GetCapabilities( PrinterCapType nType ) const; + bool HasSupport( PrinterSupport eFeature ) const; + + bool SetJobSetup( const JobSetup& rSetup ); + const JobSetup& GetJobSetup() const { return maJobSetup; } + + bool Setup(weld::Window* pWindow, + PrinterSetupMode eMode = PrinterSetupMode::DocumentGlobal); + bool SetPrinterProps( const Printer* pPrinter ); + + Color GetBackgroundColor() const override { return COL_WHITE; } + Color GetReadableFontColor(const Color&, const Color&) const override { return COL_BLACK; } + + /** SetPrinterOptions is used internally only now + + in earlier times it was used only to set the options loaded directly from the configuration + in SfxPrinter::InitJob, this is now handled internally + should the need arise to set the printer options outside vcl, also a method would have to be devised + to not override these again internally + */ + VCL_DLLPRIVATE void SetPrinterOptions( const vcl::printer::Options& rOptions ); + const vcl::printer::Options& GetPrinterOptions() const { return( *mpPrinterOptions ); } + + bool SetOrientation( Orientation eOrient ); + Orientation GetOrientation() const; + void SetDuplexMode( DuplexMode ); + DuplexMode GetDuplexMode() const; + + bool SetPaperBin( sal_uInt16 nPaperBin ); + sal_uInt16 GetPaperBin() const; + void SetPaper( Paper ePaper ); + bool SetPaperSizeUser( const Size& rSize ); + /** @return The paper format of the printer's current "jobsetup". Note that if PAPER_USER the actual size can be anything. */ + Paper GetPaper() const; + /** @return Size of the paper of the printer's current "jobsetup". */ + Size GetSizeOfPaper() const; + static OUString GetPaperName( Paper ePaper ); + + /** @return Number of available paper formats */ + int GetPaperInfoCount() const; + + /** @return Info about paper format nPaper */ + const PaperInfo& GetPaperInfo( int nPaper ) const; + sal_uInt16 GetPaperBinCount() const; + OUString GetPaperBinName( sal_uInt16 nPaperBin ) const; + + bool GetPrinterSettingsPreferred() const; + void SetPrinterSettingsPreferred( bool bPaperSizeFromSetup ); + + const Size& GetPaperSizePixel() const { return maPaperSize; } + Size GetPaperSize() const { return PixelToLogic( maPaperSize ); } + Size GetPaperSize( int nPaper ) const; + const Point& GetPageOffsetPixel() const { return maPageOffset; } + Point GetPageOffset() const { return PixelToLogic( maPageOffset ); } + + void SetCopyCount( sal_uInt16 nCopy, bool bCollate ); + sal_uInt16 GetCopyCount() const { return mnCopyCount; } + bool IsCollateCopy() const { return mbCollateCopy; } + void SetSinglePrintJobs(bool bSinglePrintJobs) { mbSinglePrintJobs = bSinglePrintJobs; } + bool IsSinglePrintJobs() const { return mbSinglePrintJobs; } + + bool IsPrinting() const { return mbPrinting; } + + bool IsJobActive() const { return mbJobActive; } + + /** Checks the printer list and updates it necessary + + sends a DataChanged event of type DataChangedEventType::PRINTER if the printer list changed + */ + static void updatePrinters(); + + /** Execute a print job + + starts a print job asynchronously that is will return + */ + static void PrintJob( const std::shared_ptr<vcl::PrinterController>& i_pController, + const JobSetup& i_rInitSetup ); + + virtual bool HasMirroredGraphics() const override; + + virtual void DrawOutDev( const Point& rDestPt, const Size& rDestSize, + const Point& rSrcPt, const Size& rSrcSize ) override; + + virtual void DrawOutDev( const Point& rDestPt, const Size& rDestSize, + const Point& rSrcPt, const Size& rSrcSize, + const OutputDevice& rOutDev ) override; + + virtual void CopyArea( const Point& rDestPt, const Point& rSrcPt, + const Size& rSrcSize, bool bWindowInvalidate = false ) override; + + virtual tools::Rectangle GetBackgroundComponentBounds() const override; + + // These 3 together are more modular PrintJob(), allowing printing more documents as one print job + // by repeated calls to ExecutePrintJob(). Used by mailmerge. + static bool PreparePrintJob( std::shared_ptr<vcl::PrinterController> i_pController, + const JobSetup& i_rInitSetup ); + static bool ExecutePrintJob(const std::shared_ptr<vcl::PrinterController>& i_pController); + static void FinishPrintJob( const std::shared_ptr<vcl::PrinterController>& i_pController ); + + /** Implementation detail of PrintJob being asynchronous + + not exported, not usable outside vcl + */ + static void VCL_DLLPRIVATE ImplPrintJob( const std::shared_ptr<vcl::PrinterController>& i_pController, + const JobSetup& i_rInitSetup ); +}; + +namespace vcl +{ +class ImplPrinterControllerData; + +enum class NupOrderType +{ + LRTB, TBLR, TBRL, RLTB +}; + +class VCL_DLLPUBLIC PrinterController +{ + std::unique_ptr<ImplPrinterControllerData> + mpImplData; +protected: + PrinterController(const VclPtr<Printer>&, weld::Window* pDialogParent); +public: + struct MultiPageSetup + { + // all metrics in 100th mm + int nRows; + int nColumns; + Size aPaperSize; + tools::Long nLeftMargin; + tools::Long nTopMargin; + tools::Long nRightMargin; + tools::Long nBottomMargin; + tools::Long nHorizontalSpacing; + tools::Long nVerticalSpacing; + bool bDrawBorder; + NupOrderType nOrder; + + MultiPageSetup() + : nRows( 1 ), nColumns( 1 ), aPaperSize( 21000, 29700 ) + , nLeftMargin( 0 ), nTopMargin( 0 ) + , nRightMargin( 0 ), nBottomMargin( 0 ) + , nHorizontalSpacing( 0 ), nVerticalSpacing( 0 ) + , bDrawBorder( false ) + , nOrder( NupOrderType::LRTB ) {} + }; + + struct PageSize + { + /// In 100th mm + Size aSize; + + /// Full paper, not only imageable area is printed + bool bFullPaper; + + PageSize( const Size& i_rSize = Size( 21000, 29700 ), + bool i_bFullPaper = false) + : aSize( i_rSize ), bFullPaper( i_bFullPaper ) {} + }; + + virtual ~PrinterController(); + + const VclPtr<Printer>& getPrinter() const; + weld::Window* getWindow() const; + + /** For implementations: get current job properties as changed by e.g. print dialog + + this gets the current set of properties initially told to Printer::PrintJob + + For convenience a second sequence will be merged in to get a combined sequence. + In case of duplicate property names, the value of i_MergeList wins. + */ + css::uno::Sequence< css::beans::PropertyValue > + getJobProperties(const css::uno::Sequence< css::beans::PropertyValue >& i_rMergeList ) const; + + /// Get the PropertyValue of a Property + css::beans::PropertyValue* getValue( const OUString& i_rPropertyName ); + const css::beans::PropertyValue* getValue( const OUString& i_rPropertyName ) const; + + /** Get a bool property + + in case the property is unknown or not convertible to bool, i_bFallback is returned + */ + bool getBoolProperty( const OUString& i_rPropertyName, bool i_bFallback ) const; + + /** Get an int property + + in case the property is unknown or not convertible to bool, i_nFallback is returned + */ + sal_Int32 getIntProperty( const OUString& i_rPropertyName, sal_Int32 i_nFallback ) const; + + /// Set a property value - can also be used to add another UI property + void setValue( const OUString& i_rPropertyName, const css::uno::Any& i_rValue ); + void setValue( const css::beans::PropertyValue& i_rValue ); + + /** @return The currently active UI options. These are the same that were passed to setUIOptions. */ + const css::uno::Sequence< css::beans::PropertyValue >& + getUIOptions() const; + + /** Set possible UI options. + + should only be done once before passing the PrinterListener to Printer::PrintJob + */ + void setUIOptions( const css::uno::Sequence< css::beans::PropertyValue >& ); + + /// Enable/disable an option; this can be used to implement dialog logic. + bool isUIOptionEnabled( const OUString& rPropName ) const; + bool isUIChoiceEnabled( const OUString& rPropName, sal_Int32 nChoice ) const; + + /** MakeEnabled will change the property rPropName depends on to the value + + that makes rPropName enabled. If the dependency itself is also disabled, + no action will be performed. + + @return The property name rPropName depends on or an empty string if no change was made. + */ + OUString makeEnabled( const OUString& rPropName ); + + /// App must override this + virtual int getPageCount() const = 0; + + /** Get the page parameters + + namely the jobsetup that should be active for the page + (describing among others the physical page size) and the "page size". In writer + case this would probably be the same as the JobSetup since writer sets the page size + draw/impress for example print their page on the paper set on the printer, + possibly adjusting the page size to fit. That means the page size can be different from + the paper size. + + App must override this + + @return Page size in 1/100th mm + */ + virtual css::uno::Sequence< css::beans::PropertyValue > + getPageParameters( int i_nPage ) const = 0; + /// App must override this + virtual void printPage(int i_nPage) const = 0; + + /// Will be called after a possible dialog has been shown and the real printjob starts + virtual void jobStarted(); + virtual void jobFinished( css::view::PrintableState ); + + css::view::PrintableState getJobState() const; + + void abortJob(); + + bool isShowDialogs() const; + bool isDirectPrint() const; + + void dialogsParentClosing(); + + // implementation details, not usable outside vcl + // don't use outside vcl. Some of these are exported for + // the benefit of vcl's plugins. + // Still: DO NOT USE OUTSIDE VCL + int getFilteredPageCount() const; + VCL_DLLPRIVATE PageSize getPageFile( int i_inUnfilteredPage, GDIMetaFile& rMtf, + bool i_bMayUseCache = false ); + PageSize getFilteredPageFile( int i_nFilteredPage, GDIMetaFile& o_rMtf, + bool i_bMayUseCache = false ); + void printFilteredPage( int i_nPage ); + VCL_DLLPRIVATE void setPrinter( const VclPtr<Printer>& ); + void createProgressDialog(); + bool isProgressCanceled() const; + VCL_DLLPRIVATE void setMultipage( const MultiPageSetup& ); + VCL_DLLPRIVATE const MultiPageSetup& + getMultipage() const; + void setLastPage( bool i_bLastPage ); + VCL_DLLPRIVATE void setReversePrint( bool i_bReverse ); + VCL_DLLPRIVATE void setPapersizeFromSetup( bool i_bPapersizeFromSetup ); + VCL_DLLPRIVATE bool getPapersizeFromSetup() const; + VCL_DLLPRIVATE void setPaperSizeFromUser( Size i_aUserSize ); + VCL_DLLPRIVATE void setOrientationFromUser( Orientation eOrientation, bool set ); + void setPrinterModified( bool i_bPapersizeFromSetup ); + bool getPrinterModified() const; + VCL_DLLPRIVATE void pushPropertiesToPrinter(); + VCL_DLLPRIVATE void resetPaperToLastConfigured(); + void setJobState( css::view::PrintableState ); + VCL_DLLPRIVATE void setupPrinter( weld::Window* i_pDlgParent ); + + VCL_DLLPRIVATE int getPageCountProtected() const; + VCL_DLLPRIVATE css::uno::Sequence< css::beans::PropertyValue > + getPageParametersProtected( int i_nPage ) const; + + VCL_DLLPRIVATE DrawModeFlags removeTransparencies( GDIMetaFile const & i_rIn, GDIMetaFile& o_rOut ); + VCL_DLLPRIVATE void resetPrinterOptions( bool i_bFileOutput ); +}; + +class VCL_DLLPUBLIC PrinterOptionsHelper +{ +protected: + std::unordered_map< OUString, css::uno::Any > + m_aPropertyMap; + std::vector< css::beans::PropertyValue > + m_aUIProperties; + +public: + + /// Create without ui properties + PrinterOptionsHelper() {} + + /** Process a new set of properties + + merges changed properties and returns "true" if any occurred + */ + bool processProperties( const css::uno::Sequence< css::beans::PropertyValue >& i_rNewProp ); + + /** Append to a sequence of property values the ui property sequence passed at creation + + as the "ExtraPrintUIOptions" property. if that sequence was empty, no "ExtraPrintUIOptions" property + will be appended. + */ + void appendPrintUIOptions( css::uno::Sequence< css::beans::PropertyValue >& io_rProps ) const; + + /** @return An empty Any for not existing properties */ + css::uno::Any getValue( const OUString& i_rPropertyName ) const; + + bool getBoolValue( const OUString& i_rPropertyName, bool i_bDefault ) const; + // convenience for fixed strings + bool getBoolValue( const char* i_pPropName, bool i_bDefault = false ) const + { return getBoolValue( OUString::createFromAscii( i_pPropName ), i_bDefault ); } + + sal_Int64 getIntValue( const OUString& i_rPropertyName, sal_Int64 i_nDefault ) const; + // convenience for fixed strings + sal_Int64 getIntValue( const char* i_pPropName, sal_Int64 i_nDefault ) const + { return getIntValue( OUString::createFromAscii( i_pPropName ), i_nDefault ); } + + OUString getStringValue( const OUString& i_rPropertyName ) const; + // convenience for fixed strings + OUString getStringValue( const char* i_pPropName ) const + { return getStringValue( OUString::createFromAscii( i_pPropName ) ); } + + // helper functions for user to create a single control + struct UIControlOptions + { + OUString maDependsOnName; + OUString maGroupHint; + std::vector< css::beans::PropertyValue > + maAddProps; + sal_Int32 mnDependsOnEntry; + bool mbAttachToDependency; + bool mbInternalOnly; + bool mbEnabled; + + UIControlOptions( const OUString& i_rDependsOnName = OUString(), + sal_Int32 i_nDependsOnEntry = -1, bool i_bAttachToDependency = false) + : maDependsOnName( i_rDependsOnName ) + , mnDependsOnEntry( i_nDependsOnEntry ) + , mbAttachToDependency( i_bAttachToDependency ) + , mbInternalOnly( false ) + , mbEnabled( true ) {} + }; + + // note: in the following helper functions HelpIds are expected as an OUString + // the normal HelpId form is OString (byte string instead of UTF16 string) + // this is because the whole interface is base on UNO properties; in fact the structures + // are passed over UNO interfaces. UNO does not know a byte string, hence the string is + // transported via UTF16 strings. + + /// Show general control + static css::uno::Any setUIControlOpt( const css::uno::Sequence< OUString >& i_rIDs, const OUString& i_rTitle, + const css::uno::Sequence< OUString >& i_rHelpId, const OUString& i_rType, + const css::beans::PropertyValue* i_pValue = nullptr, + const UIControlOptions& i_rControlOptions = UIControlOptions()); + + /// Show and set the title of a TagPage of id i_rID + static css::uno::Any setGroupControlOpt( const OUString& i_rID, const OUString& i_rTitle, + const OUString& i_rHelpId); + + /// Show and set the label of a VclFrame of id i_rID + static css::uno::Any setSubgroupControlOpt( const OUString& i_rID, const OUString& i_rTitle, const OUString& i_rHelpId, + const UIControlOptions& i_rControlOptions = UIControlOptions()); + + /// Show a bool option as a checkbox + static css::uno::Any setBoolControlOpt( const OUString& i_rID, const OUString& i_rTitle, const OUString& i_rHelpId, + const OUString& i_rProperty, bool i_bValue, + const UIControlOptions& i_rControlOptions = UIControlOptions()); + + /// Show a set of choices in a list box + static css::uno::Any setChoiceListControlOpt( const OUString& i_rID, const OUString& i_rTitle, + const css::uno::Sequence< OUString >& i_rHelpId, const OUString& i_rProperty, + const css::uno::Sequence< OUString >& i_rChoices, sal_Int32 i_nValue, + const css::uno::Sequence< sal_Bool >& i_rDisabledChoices = css::uno::Sequence< sal_Bool >(), + const UIControlOptions& i_rControlOptions = UIControlOptions()); + + /// Show a set of choices as radio buttons + static css::uno::Any setChoiceRadiosControlOpt( const css::uno::Sequence< OUString >& i_rIDs, + const OUString& i_rTitle, const css::uno::Sequence< OUString >& i_rHelpId, + const OUString& i_rProperty, const css::uno::Sequence< OUString >& i_rChoices, + sal_Int32 i_nValue, + const css::uno::Sequence< sal_Bool >& i_rDisabledChoices = css::uno::Sequence< sal_Bool >(), + const UIControlOptions& i_rControlOptions = UIControlOptions()); + + /** Show an integer range (e.g. a spin field) + + note: max value < min value means do not apply min/max values + */ + static css::uno::Any setRangeControlOpt( const OUString& i_rID, const OUString& i_rTitle, const OUString& i_rHelpId, + const OUString& i_rProperty, sal_Int32 i_nValue, sal_Int32 i_nMinValue, + sal_Int32 i_nMaxValue, const UIControlOptions& i_rControlOptions); + + /** Show a string field + + note: max value < min value means do not apply min/max values + */ + static css::uno::Any setEditControlOpt( const OUString& i_rID, const OUString& i_rTitle, const OUString& i_rHelpId, + const OUString& i_rProperty, const OUString& i_rValue, + const UIControlOptions& i_rControlOptions); +}; // class PrinterOptionsHelper + +} // namespace vcl + + +#endif // INCLUDED_VCL_PRINT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/printer/Options.hxx b/include/vcl/printer/Options.hxx new file mode 100644 index 000000000..3899fd313 --- /dev/null +++ b/include/vcl/printer/Options.hxx @@ -0,0 +1,120 @@ +/* -*- 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 . + */ + +#pragma once + +#include <sal/config.h> + +#include <config_options.h> + +#include <sal/types.h> + +#include <vcl/dllapi.h> + +namespace vcl::printer +{ +enum class TransparencyMode +{ + Auto = 0, + NONE = 1 +}; + +enum class GradientMode +{ + Stripes = 0, + Color = 1 +}; + +enum class BitmapMode +{ + Optimal = 0, + Normal = 1, + Resolution = 2 +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) Options +{ +private: + bool mbReduceTransparency = false; + TransparencyMode meReducedTransparencyMode = TransparencyMode::Auto; + bool mbReduceGradients = false; + GradientMode meReducedGradientsMode = GradientMode::Stripes; + sal_uInt16 mnReducedGradientStepCount = 64; + bool mbReduceBitmaps = false; + BitmapMode meReducedBitmapMode = BitmapMode::Normal; + sal_uInt16 mnReducedBitmapResolution = 200; + bool mbReducedBitmapsIncludeTransparency = true; + bool mbConvertToGreyscales = false; + bool mbPDFAsStandardPrintJobFormat = false; + +public: + Options() = default; + + bool IsReduceTransparency() const { return mbReduceTransparency; } + void SetReduceTransparency(bool bSet) { mbReduceTransparency = bSet; } + + TransparencyMode GetReducedTransparencyMode() const { return meReducedTransparencyMode; } + void SetReducedTransparencyMode(TransparencyMode eMode) { meReducedTransparencyMode = eMode; } + + bool IsReduceGradients() const { return mbReduceGradients; } + void SetReduceGradients(bool bSet) { mbReduceGradients = bSet; } + + GradientMode GetReducedGradientMode() const { return meReducedGradientsMode; } + void SetReducedGradientMode(GradientMode eMode) { meReducedGradientsMode = eMode; } + + sal_uInt16 GetReducedGradientStepCount() const { return mnReducedGradientStepCount; } + void SetReducedGradientStepCount(sal_uInt16 nStepCount) + { + mnReducedGradientStepCount = nStepCount; + } + + bool IsReduceBitmaps() const { return mbReduceBitmaps; } + void SetReduceBitmaps(bool bSet) { mbReduceBitmaps = bSet; } + + BitmapMode GetReducedBitmapMode() const { return meReducedBitmapMode; } + void SetReducedBitmapMode(BitmapMode eMode) { meReducedBitmapMode = eMode; } + + sal_uInt16 GetReducedBitmapResolution() const { return mnReducedBitmapResolution; } + void SetReducedBitmapResolution(sal_uInt16 nResolution) + { + mnReducedBitmapResolution = nResolution; + } + + bool IsReducedBitmapIncludesTransparency() const { return mbReducedBitmapsIncludeTransparency; } + void SetReducedBitmapIncludesTransparency(bool bSet) + { + mbReducedBitmapsIncludeTransparency = bSet; + } + + bool IsConvertToGreyscales() const { return mbConvertToGreyscales; } + void SetConvertToGreyscales(bool bSet) { mbConvertToGreyscales = bSet; } + + bool IsPDFAsStandardPrintJobFormat() const { return mbPDFAsStandardPrintJobFormat; } + void SetPDFAsStandardPrintJobFormat(bool bSet) { mbPDFAsStandardPrintJobFormat = bSet; } + + /** Read printer options from configuration + + parameter decides whether the set for + print "to printer" or "to file" should be read. + */ + void ReadFromConfig(bool bFile); +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/prntypes.hxx b/include/vcl/prntypes.hxx new file mode 100644 index 000000000..fab6a1bf6 --- /dev/null +++ b/include/vcl/prntypes.hxx @@ -0,0 +1,93 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_PRNTYPES_HXX +#define INCLUDED_VCL_PRNTYPES_HXX + +#include <sal/types.h> +#include <o3tl/typed_flags_set.hxx> + + +// appears to be a copy of css::view::DuplexMode +enum class DuplexMode { Unknown, Off, LongEdge, ShortEdge }; + + +enum class Orientation { Portrait, Landscape }; + + +enum class PrintQueueFlags +{ + NONE = 0x00000000, + Ready = 0x00000001, + Paused = 0x00000002, + PendingDeletion = 0x00000004, + Busy = 0x00000008, + Initializing = 0x00000010, + Waiting = 0x00000020, + WarmingUp = 0x00000040, + Processing = 0x00000080, + Printing = 0x00000100, + Offline = 0x00000200, + Error = 0x00000400, + StatusUnknown = 0x00000800, + PaperJam = 0x00001000, + PaperOut = 0x00002000, + ManualFeed = 0x00004000, + PaperProblem = 0x00008000, + IOActive = 0x00010000, + OutputBinFull = 0x00020000, + TonerLow = 0x00040000, + NoToner = 0x00080000, + PagePunt = 0x00100000, + UserIntervention = 0x00200000, + OutOfMemory = 0x00400000, + DoorOpen = 0x00800000, + PowerSave = 0x01000000, +}; +namespace o3tl +{ + template<> struct typed_flags<PrintQueueFlags> : is_typed_flags<PrintQueueFlags, 0x01ffffff> {}; +} + +constexpr inline sal_uInt32 QUEUE_JOBS_DONTKNOW = 0xFFFFFFFF; + + +enum class PrinterCapType +{ + SupportDialog = 1, + Copies = 2, + CollateCopies = 3, + SetOrientation = 4, + SetPaperSize = 6, + SetPaper = 7, + Fax = 8, + PDF = 9, + ExternalDialog = 10, + UsePullModel = 12, +}; + +enum class PrinterSetupMode +{ + SingleJob = 0, + DocumentGlobal = 1 +}; + +#endif // INCLUDED_VCL_PRNTYPES_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/ptrstyle.hxx b/include/vcl/ptrstyle.hxx new file mode 100644 index 000000000..fa45246a8 --- /dev/null +++ b/include/vcl/ptrstyle.hxx @@ -0,0 +1,125 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_PTRSTYLE_HXX +#define INCLUDED_VCL_PTRSTYLE_HXX + +#include <com/sun/star/awt/SystemPointer.hpp> + +enum class PointerStyle +{ + Arrow = css::awt::SystemPointer::ARROW, + Null = css::awt::SystemPointer::INVISIBLE, + Wait = css::awt::SystemPointer::WAIT, + Text = css::awt::SystemPointer::TEXT, + Help = css::awt::SystemPointer::HELP, + Cross = css::awt::SystemPointer::CROSS, + Move = css::awt::SystemPointer::MOVE, + NSize = css::awt::SystemPointer::NSIZE, + SSize = css::awt::SystemPointer::SSIZE, + WSize = css::awt::SystemPointer::WSIZE, + ESize = css::awt::SystemPointer::ESIZE, + NWSize = css::awt::SystemPointer::NWSIZE, + NESize = css::awt::SystemPointer::NESIZE, + SWSize = css::awt::SystemPointer::SWSIZE, + SESize = css::awt::SystemPointer::SESIZE, + WindowNSize = css::awt::SystemPointer::WINDOW_NSIZE, + WindowSSize = css::awt::SystemPointer::WINDOW_SSIZE, + WindowWSize = css::awt::SystemPointer::WINDOW_WSIZE, + WindowESize = css::awt::SystemPointer::WINDOW_ESIZE, + WindowNWSize = css::awt::SystemPointer::WINDOW_NWSIZE, + WindowNESize = css::awt::SystemPointer::WINDOW_NESIZE, + WindowSWSize = css::awt::SystemPointer::WINDOW_SWSIZE, + WindowSESize = css::awt::SystemPointer::WINDOW_SESIZE, + HSplit = css::awt::SystemPointer::HSPLIT, + VSplit = css::awt::SystemPointer::VSPLIT, + HSizeBar = css::awt::SystemPointer::HSIZEBAR, + VSizeBar = css::awt::SystemPointer::VSIZEBAR, + Hand = css::awt::SystemPointer::HAND, + RefHand = css::awt::SystemPointer::REFHAND, + Pen = css::awt::SystemPointer::PEN, + Magnify = css::awt::SystemPointer::MAGNIFY, + Fill = css::awt::SystemPointer::FILL, + Rotate = css::awt::SystemPointer::ROTATE, + HShear = css::awt::SystemPointer::HSHEAR, + VShear = css::awt::SystemPointer::VSHEAR, + Mirror = css::awt::SystemPointer::MIRROR, + Crook = css::awt::SystemPointer::CROOK, + Crop = css::awt::SystemPointer::CROP, + MovePoint = css::awt::SystemPointer::MOVEPOINT, + MoveBezierWeight = css::awt::SystemPointer::MOVEBEZIERWEIGHT, + MoveData = css::awt::SystemPointer::MOVEDATA, + CopyData = css::awt::SystemPointer::COPYDATA, + LinkData = css::awt::SystemPointer::LINKDATA, + MoveDataLink = css::awt::SystemPointer::MOVEDATALINK, + CopyDataLink = css::awt::SystemPointer::COPYDATALINK, + MoveFile = css::awt::SystemPointer::MOVEFILE, + CopyFile = css::awt::SystemPointer::COPYFILE, + LinkFile = css::awt::SystemPointer::LINKFILE, + MoveFileLink = css::awt::SystemPointer::MOVEFILELINK, + CopyFileLink = css::awt::SystemPointer::COPYFILELINK, + MoveFiles = css::awt::SystemPointer::MOVEFILES, + CopyFiles = css::awt::SystemPointer::COPYFILES, + NotAllowed = css::awt::SystemPointer::NOTALLOWED, + DrawLine = css::awt::SystemPointer::DRAW_LINE, + DrawRect = css::awt::SystemPointer::DRAW_RECT, + DrawPolygon = css::awt::SystemPointer::DRAW_POLYGON, + DrawBezier = css::awt::SystemPointer::DRAW_BEZIER, + DrawArc = css::awt::SystemPointer::DRAW_ARC, + DrawPie = css::awt::SystemPointer::DRAW_PIE, + DrawCircleCut = css::awt::SystemPointer::DRAW_CIRCLECUT, + DrawEllipse = css::awt::SystemPointer::DRAW_ELLIPSE, + DrawFreehand = css::awt::SystemPointer::DRAW_FREEHAND, + DrawConnect = css::awt::SystemPointer::DRAW_CONNECT, + DrawText = css::awt::SystemPointer::DRAW_TEXT, + DrawCaption = css::awt::SystemPointer::DRAW_CAPTION, + Chart = css::awt::SystemPointer::CHART, + Detective = css::awt::SystemPointer::DETECTIVE, + PivotCol = css::awt::SystemPointer::PIVOT_COL, + PivotRow = css::awt::SystemPointer::PIVOT_ROW, + PivotField = css::awt::SystemPointer::PIVOT_FIELD, + Chain = css::awt::SystemPointer::CHAIN, + ChainNotAllowed = css::awt::SystemPointer::CHAIN_NOTALLOWED, + AutoScrollN, + AutoScrollS, + AutoScrollW, + AutoScrollE, + AutoScrollNW, + AutoScrollNE, + AutoScrollSW, + AutoScrollSE, + AutoScrollNS, + AutoScrollWE, + AutoScrollNSWE, + TextVertical, + PivotDelete, + TabSelectS, + TabSelectE, + TabSelectSE, + TabSelectW, + TabSelectSW, + HideWhitespace, + ShowWhitespace, + FatCross, + LAST = FatCross, +}; + +#endif // INCLUDED_VCL_PTRSTYLE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/quickselectionengine.hxx b/include/vcl/quickselectionengine.hxx new file mode 100644 index 000000000..87e1d09a9 --- /dev/null +++ b/include/vcl/quickselectionengine.hxx @@ -0,0 +1,91 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_QUICKSELECTIONENGINE_HXX +#define INCLUDED_VCL_QUICKSELECTIONENGINE_HXX + +#include <rtl/ustring.hxx> +#include <vcl/dllapi.h> +#include <memory> + +class KeyEvent; + + +namespace vcl +{ + + + typedef const void* StringEntryIdentifier; + + + //= ISearchableStringList + + // TODO: consolidate this with vcl::IMnemonicEntryList + class SAL_NO_VTABLE VCL_DLLPUBLIC ISearchableStringList + { + public: + /** returns the current entry in the list of searchable strings. + + Search operations will start with this entry. + */ + virtual StringEntryIdentifier CurrentEntry( OUString& _out_entryText ) const = 0; + + /** returns the next entry in the list. + + The implementation is expected to wrap around. That is, if the given entry denotes the last + entry in the list, then NextEntry should return the first entry. + */ + virtual StringEntryIdentifier NextEntry( StringEntryIdentifier _currentEntry, OUString& _out_entryText ) const = 0; + + /** selects a given entry + */ + virtual void SelectEntry( StringEntryIdentifier _entry ) = 0; + + protected: + ~ISearchableStringList() {} + }; + + + //= QuickSelectionEngine + + struct QuickSelectionEngine_Data; + class VCL_DLLPUBLIC QuickSelectionEngine + { + public: + QuickSelectionEngine( ISearchableStringList& _entryList ); + ~QuickSelectionEngine(); + + bool HandleKeyEvent( const KeyEvent& _rKEvt ); + void Reset(); + + private: + ::std::unique_ptr< QuickSelectionEngine_Data > m_pData; + + private: + QuickSelectionEngine( const QuickSelectionEngine& ) = delete; + QuickSelectionEngine& operator=( const QuickSelectionEngine& ) = delete; + }; + + +} // namespace vcl + + +#endif // INCLUDED_VCL_QUICKSELECTIONENGINE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/region.hxx b/include/vcl/region.hxx new file mode 100644 index 000000000..8d5004c18 --- /dev/null +++ b/include/vcl/region.hxx @@ -0,0 +1,167 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_REGION_HXX +#define INCLUDED_VCL_REGION_HXX + +#include <tools/gen.hxx> +#include <tools/poly.hxx> +#include <vcl/dllapi.h> +#include <basegfx/polygon/b2dpolypolygon.hxx> +#include <memory> +#include <optional> + +class RegionBand; + +namespace vcl { class Window; } +class OutputDevice; +class Bitmap; + +typedef std::vector< tools::Rectangle > RectangleVector; + +namespace vcl { + +class SAL_WARN_UNUSED VCL_DLLPUBLIC Region +{ +private: + friend class ::OutputDevice; + friend class ::vcl::Window; + friend class ::Bitmap; + + // possible contents + std::optional< basegfx::B2DPolyPolygon > + mpB2DPolyPolygon; + std::optional< tools::PolyPolygon > + mpPolyPolygon; + std::shared_ptr< RegionBand > + mpRegionBand; + + bool mbIsNull : 1; + + // helpers + SAL_DLLPRIVATE void ImplCreatePolyPolyRegion( const tools::PolyPolygon& rPolyPoly ); + SAL_DLLPRIVATE void ImplCreatePolyPolyRegion( const basegfx::B2DPolyPolygon& rPolyPoly ); + + SAL_DLLPRIVATE tools::PolyPolygon ImplCreatePolyPolygonFromRegionBand() const; + SAL_DLLPRIVATE basegfx::B2DPolyPolygon ImplCreateB2DPolyPolygonFromRegionBand() const; + +public: + + explicit Region(bool bIsNull = false); // default creates empty region, with true a null region is created + explicit Region(const tools::Rectangle& rRect); + explicit Region(const tools::Polygon& rPolygon); + explicit Region(const tools::PolyPolygon& rPolyPoly); + explicit Region(const basegfx::B2DPolyPolygon&); + Region(const vcl::Region& rRegion); + Region(vcl::Region&& rRegion) noexcept; + ~Region(); + + // direct access to contents + const std::optional<basegfx::B2DPolyPolygon>& getB2DPolyPolygon() const { return mpB2DPolyPolygon; } + const std::optional<tools::PolyPolygon>& getPolyPolygon() const { return mpPolyPolygon; } + const RegionBand* getRegionBand() const { return mpRegionBand.get(); } + + // access with converters, the asked data will be created from the most + // valuable data, buffered and returned + tools::PolyPolygon GetAsPolyPolygon() const; + basegfx::B2DPolyPolygon GetAsB2DPolyPolygon() const; + const RegionBand* GetAsRegionBand() const; + + // manipulators + void Move( tools::Long nHorzMove, tools::Long nVertMove ); + void Scale( double fScaleX, double fScaleY ); + void Union( const tools::Rectangle& rRegion ); + void Intersect( const tools::Rectangle& rRegion ); + void Exclude( const tools::Rectangle& rRegion ); + void XOr( const tools::Rectangle& rRegion ); + void Union( const vcl::Region& rRegion ); + void Intersect( const vcl::Region& rRegion ); + void Exclude( const vcl::Region& rRegion ); + bool XOr( const vcl::Region& rRegion ); + + bool IsEmpty() const; + bool IsNull() const { return mbIsNull;} + + void SetEmpty(); + void SetNull(); + + bool IsRectangle() const; + + tools::Rectangle GetBoundRect() const; + bool HasPolyPolygonOrB2DPolyPolygon() const { return (getB2DPolyPolygon() || getPolyPolygon()); } + void GetRegionRectangles(RectangleVector& rTarget) const; + + bool Contains( const Point& rPoint ) const; + bool Overlaps( const tools::Rectangle& rRect ) const; + + vcl::Region& operator=( const vcl::Region& rRegion ); + vcl::Region& operator=( vcl::Region&& rRegion ) noexcept; + vcl::Region& operator=( const tools::Rectangle& rRect ); + + bool operator==( const vcl::Region& rRegion ) const; + bool operator!=( const vcl::Region& rRegion ) const { return !(Region::operator==( rRegion )); } + + friend VCL_DLLPUBLIC SvStream& ReadRegion( SvStream& rIStm, vcl::Region& rRegion ); + friend VCL_DLLPUBLIC SvStream& WriteRegion( SvStream& rOStm, const vcl::Region& rRegion ); + + /* workaround: faster conversion for PolyPolygons + * if half of the Polygons contained in rPolyPoly are actually + * rectangles, then the returned vcl::Region will be constructed by + * XOr'ing the contained Polygons together; in the case of + * only Rectangles this can be up to eight times faster than + * Region( const tools::PolyPolygon& ). + * Caution: this is only useful if the vcl::Region is known to be + * changed to rectangles; e.g. if being set as clip region + */ + static vcl::Region GetRegionFromPolyPolygon( const tools::PolyPolygon& rPolyPoly ); +}; + +template< typename charT, typename traits > +inline std::basic_ostream<charT, traits> & operator <<( + std::basic_ostream<charT, traits> & stream, const Region& rRegion) +{ + if (rRegion.IsEmpty()) + return stream << "EMPTY"; + if (rRegion.getB2DPolyPolygon()) + return stream << "B2DPolyPolygon(" + << *rRegion.getB2DPolyPolygon() + << ")"; + if (rRegion.getPolyPolygon()) + return stream << "PolyPolygon(" + << *rRegion.getPolyPolygon() + << ")"; + if (rRegion.getRegionBand()) + { // inlined because RegionBand is private to vcl + stream << "RegionBand("; + RectangleVector rects; + rRegion.GetRegionRectangles(rects); + if (rects.empty()) + stream << "EMPTY"; + for (size_t i = 0; i < rects.size(); ++i) + stream << "[" << i << "] " << rects[i]; + stream << ")"; + } + return stream; +} + +} /* namespace vcl */ + +#endif // INCLUDED_VCL_REGION_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/rendercontext/AddFontSubstituteFlags.hxx b/include/vcl/rendercontext/AddFontSubstituteFlags.hxx new file mode 100644 index 000000000..d2cb90a28 --- /dev/null +++ b/include/vcl/rendercontext/AddFontSubstituteFlags.hxx @@ -0,0 +1,38 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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 . + */ + +#pragma once + +#include <o3tl/typed_flags_set.hxx> + +enum class AddFontSubstituteFlags +{ + NONE = 0x00, + ALWAYS = 0x01, + ScreenOnly = 0x02, +}; +namespace o3tl +{ +template <> +struct typed_flags<AddFontSubstituteFlags> : is_typed_flags<AddFontSubstituteFlags, 0x03> +{ +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/rendercontext/AntialiasingFlags.hxx b/include/vcl/rendercontext/AntialiasingFlags.hxx new file mode 100644 index 000000000..98ce2e882 --- /dev/null +++ b/include/vcl/rendercontext/AntialiasingFlags.hxx @@ -0,0 +1,38 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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 . + */ + +#pragma once + +#include <o3tl/typed_flags_set.hxx> + +enum class AntialiasingFlags +{ + NONE = 0x0000, + DisableText = 0x0001, + Enable = 0x0002, + PixelSnapHairline = 0x0004, +}; +namespace o3tl +{ +template <> struct typed_flags<AntialiasingFlags> : is_typed_flags<AntialiasingFlags, 0x07> +{ +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/rendercontext/DrawGridFlags.hxx b/include/vcl/rendercontext/DrawGridFlags.hxx new file mode 100644 index 000000000..4d783e780 --- /dev/null +++ b/include/vcl/rendercontext/DrawGridFlags.hxx @@ -0,0 +1,38 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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 . + */ + +#pragma once + +#include <o3tl/typed_flags_set.hxx> + +enum class DrawGridFlags +{ + NONE = 0x0000, + Dots = 0x0001, + HorzLines = 0x0002, + VertLines = 0x0004 +}; +namespace o3tl +{ +template <> struct typed_flags<DrawGridFlags> : is_typed_flags<DrawGridFlags, 0x0007> +{ +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/rendercontext/DrawImageFlags.hxx b/include/vcl/rendercontext/DrawImageFlags.hxx new file mode 100644 index 000000000..014b552de --- /dev/null +++ b/include/vcl/rendercontext/DrawImageFlags.hxx @@ -0,0 +1,41 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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 . + */ + +#pragma once + +#include <o3tl/typed_flags_set.hxx> + +// Flags for DrawImage(), these must match the definitions in css::awt::ImageDrawMode +enum class DrawImageFlags +{ + NONE = 0x0000, + Disable = 0x0001, + Highlight = 0x0002, + Deactive = 0x0004, + ColorTransform = 0x0008, + SemiTransparent = 0x0010, +}; +namespace o3tl +{ +template <> struct typed_flags<DrawImageFlags> : is_typed_flags<DrawImageFlags, 0x001f> +{ +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/rendercontext/DrawModeFlags.hxx b/include/vcl/rendercontext/DrawModeFlags.hxx new file mode 100644 index 000000000..edfa27626 --- /dev/null +++ b/include/vcl/rendercontext/DrawModeFlags.hxx @@ -0,0 +1,57 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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 . + */ + +#pragma once + +#include <sal/types.h> +#include <o3tl/typed_flags_set.hxx> + +enum class DrawModeFlags : sal_uInt32 +{ + Default = 0x00000000, + BlackLine = 0x00000001, + BlackFill = 0x00000002, + BlackText = 0x00000004, + BlackBitmap = 0x00000008, + BlackGradient = 0x00000010, + GrayLine = 0x00000020, + GrayFill = 0x00000040, + GrayText = 0x00000080, + GrayBitmap = 0x00000100, + GrayGradient = 0x00000200, + NoFill = 0x00000400, + WhiteLine = 0x00000800, + WhiteFill = 0x00001000, + WhiteText = 0x00002000, + WhiteBitmap = 0x00004000, + WhiteGradient = 0x00008000, + SettingsLine = 0x00010000, + SettingsFill = 0x00020000, + SettingsText = 0x00040000, + SettingsGradient = 0x00080000, + NoTransparency = 0x00100000, +}; +namespace o3tl +{ +template <> struct typed_flags<DrawModeFlags> : is_typed_flags<DrawModeFlags, 0x1fffff> +{ +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/rendercontext/DrawTextFlags.hxx b/include/vcl/rendercontext/DrawTextFlags.hxx new file mode 100644 index 000000000..e393bcd2c --- /dev/null +++ b/include/vcl/rendercontext/DrawTextFlags.hxx @@ -0,0 +1,53 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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 . + */ + +#pragma once + +#include <o3tl/typed_flags_set.hxx> + +enum class DrawTextFlags +{ + NONE = 0x00000000, + Disable = 0x00000001, + Mnemonic = 0x00000002, + Mono = 0x00000004, + Clip = 0x00000008, + Left = 0x00000010, + Center = 0x00000020, + Right = 0x00000040, + Top = 0x00000080, + VCenter = 0x00000100, + Bottom = 0x00000200, + EndEllipsis = 0x00000400, + PathEllipsis = 0x00000800, + MultiLine = 0x00001000, + WordBreak = 0x00002000, + NewsEllipsis = 0x00004000, + WordBreakHyphenation = 0x00008000 | WordBreak, + CenterEllipsis = 0x00010000, + HideMnemonic = 0x00020000, +}; +namespace o3tl +{ +template <> struct typed_flags<DrawTextFlags> : is_typed_flags<DrawTextFlags, 0x3ffff> +{ +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/rendercontext/GetDefaultFontFlags.hxx b/include/vcl/rendercontext/GetDefaultFontFlags.hxx new file mode 100644 index 000000000..a100e2f2f --- /dev/null +++ b/include/vcl/rendercontext/GetDefaultFontFlags.hxx @@ -0,0 +1,36 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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 . + */ + +#pragma once + +#include <o3tl/typed_flags_set.hxx> + +enum class GetDefaultFontFlags +{ + NONE = 0x0000, + OnlyOne = 0x0001, +}; +namespace o3tl +{ +template <> struct typed_flags<GetDefaultFontFlags> : is_typed_flags<GetDefaultFontFlags, 0x01> +{ +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/rendercontext/ImplMapRes.hxx b/include/vcl/rendercontext/ImplMapRes.hxx new file mode 100644 index 000000000..7a88a15af --- /dev/null +++ b/include/vcl/rendercontext/ImplMapRes.hxx @@ -0,0 +1,36 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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 . + */ + +#pragma once + +#include <tools/long.hxx> + +struct ImplMapRes +{ + ImplMapRes() = default; + + tools::Long mnMapOfsX = 0; ///< Offset in X direction + tools::Long mnMapOfsY = 0; ///< Offset in Y direction + tools::Long mnMapScNumX = 1; ///< Scaling factor - numerator in X direction + tools::Long mnMapScNumY = 1; ///< Scaling factor - numerator in Y direction + tools::Long mnMapScDenomX = 1; ///< Scaling factor - denominator in X direction + tools::Long mnMapScDenomY = 1; ///< Scaling factor - denominator in Y direction +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/rendercontext/InvertFlags.hxx b/include/vcl/rendercontext/InvertFlags.hxx new file mode 100644 index 000000000..86fe96fd4 --- /dev/null +++ b/include/vcl/rendercontext/InvertFlags.hxx @@ -0,0 +1,37 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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 . + */ + +#pragma once + +#include <o3tl/typed_flags_set.hxx> + +enum class InvertFlags +{ + NONE = 0x0000, + N50 = 0x0001, + TrackFrame = 0x0002 +}; +namespace o3tl +{ +template <> struct typed_flags<InvertFlags> : is_typed_flags<InvertFlags, 0x0003> +{ +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/rendercontext/RasterOp.hxx b/include/vcl/rendercontext/RasterOp.hxx new file mode 100644 index 000000000..44b2a6c03 --- /dev/null +++ b/include/vcl/rendercontext/RasterOp.hxx @@ -0,0 +1,31 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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 . + */ + +#pragma once + +enum class RasterOp +{ + OverPaint, + Xor, + N0, + N1, + Invert +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/rendercontext/SalLayoutFlags.hxx b/include/vcl/rendercontext/SalLayoutFlags.hxx new file mode 100644 index 000000000..68c26cadb --- /dev/null +++ b/include/vcl/rendercontext/SalLayoutFlags.hxx @@ -0,0 +1,44 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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 . + */ + +#pragma once + +#include <o3tl/typed_flags_set.hxx> + +enum class SalLayoutFlags +{ + NONE = 0x0000, + BiDiRtl = 0x0001, + BiDiStrong = 0x0002, + RightAlign = 0x0004, + DisableKerning = 0x0010, + KerningAsian = 0x0020, + Vertical = 0x0040, + KashidaJustification = 0x0800, + ForFallback = 0x2000, + GlyphItemsOnly = 0x4000, +}; +namespace o3tl +{ +template <> struct typed_flags<SalLayoutFlags> : is_typed_flags<SalLayoutFlags, 0x6877> +{ +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/rendercontext/State.hxx b/include/vcl/rendercontext/State.hxx new file mode 100644 index 000000000..a433dbd8f --- /dev/null +++ b/include/vcl/rendercontext/State.hxx @@ -0,0 +1,120 @@ +/* -*- 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 . + */ + +#pragma once + +#include <tools/color.hxx> +#include <tools/gen.hxx> +#include <tools/fontenum.hxx> +#include <i18nlangtag/lang.h> +#include <o3tl/typed_flags_set.hxx> + +#include <vcl/rendercontext/RasterOp.hxx> +#include <vcl/font.hxx> +#include <vcl/mapmod.hxx> +#include <vcl/region.hxx> + +#include <memory> +#include <optional> + +namespace vcl +{ +// Flags for OutputDevice::Push() and State +enum class PushFlags +{ + NONE = 0x0000, + LINECOLOR = 0x0001, + FILLCOLOR = 0x0002, + FONT = 0x0004, + TEXTCOLOR = 0x0008, + MAPMODE = 0x0010, + CLIPREGION = 0x0020, + RASTEROP = 0x0040, + TEXTFILLCOLOR = 0x0080, + TEXTALIGN = 0x0100, + REFPOINT = 0x0200, + TEXTLINECOLOR = 0x0400, + TEXTLAYOUTMODE = 0x0800, + TEXTLANGUAGE = 0x1000, + OVERLINECOLOR = 0x2000, + ALL = 0xFFFF +}; +} + +namespace o3tl +{ +template <> struct typed_flags<vcl::PushFlags> : is_typed_flags<vcl::PushFlags, 0xFFFF> +{ +}; +} +#define PUSH_ALLFONT \ + (vcl::PushFlags::TEXTCOLOR | vcl::PushFlags::TEXTFILLCOLOR | vcl::PushFlags::TEXTLINECOLOR \ + | vcl::PushFlags::OVERLINECOLOR | vcl::PushFlags::TEXTALIGN | vcl::PushFlags::TEXTLAYOUTMODE \ + | vcl::PushFlags::TEXTLANGUAGE | vcl::PushFlags::FONT) + +namespace vcl::text +{ +// Layout flags for Complex Text Layout +// These are flag values, i.e they can be combined +enum class ComplexTextLayoutFlags +{ + Default = 0x0000, + BiDiRtl = 0x0001, + BiDiStrong = 0x0002, + TextOriginLeft = 0x0004, + TextOriginRight = 0x0008 +}; +} + +namespace o3tl +{ +template <> +struct typed_flags<vcl::text::ComplexTextLayoutFlags> + : is_typed_flags<vcl::text::ComplexTextLayoutFlags, 0x000f> +{ +}; +} + +namespace vcl +{ +struct State +{ + State() = default; + State(State&&) = default; + + std::unique_ptr<vcl::Region> mpClipRegion; + std::optional<MapMode> mpMapMode; + std::optional<vcl::Font> mpFont; + std::optional<Point> mpRefPoint; + std::optional<Color> mpLineColor; + std::optional<Color> mpFillColor; + std::optional<Color> mpTextColor; + std::optional<Color> mpTextFillColor; + std::optional<Color> mpTextLineColor; + std::optional<Color> mpOverlineColor; + TextAlign meTextAlign = ALIGN_TOP; + RasterOp meRasterOp = RasterOp::OverPaint; + text::ComplexTextLayoutFlags mnTextLayoutMode = text::ComplexTextLayoutFlags::Default; + LanguageType meTextLanguage = LANGUAGE_SYSTEM; + PushFlags mnFlags = PushFlags::NONE; + bool mbMapActive = false; +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/rendercontext/SystemTextColorFlags.hxx b/include/vcl/rendercontext/SystemTextColorFlags.hxx new file mode 100644 index 000000000..459c21945 --- /dev/null +++ b/include/vcl/rendercontext/SystemTextColorFlags.hxx @@ -0,0 +1,37 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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 . + */ + +#pragma once + +#include <o3tl/typed_flags_set.hxx> + +enum class SystemTextColorFlags +{ + NONE = 0x0000, + Mono = 0x0001, + NoControls = 0x0004, +}; +namespace o3tl +{ +template <> struct typed_flags<SystemTextColorFlags> : is_typed_flags<SystemTextColorFlags, 0x0005> +{ +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/roadmapwizard.hxx b/include/vcl/roadmapwizard.hxx new file mode 100644 index 000000000..6a55bacad --- /dev/null +++ b/include/vcl/roadmapwizard.hxx @@ -0,0 +1,189 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_ROADMAPWIZARD_HXX +#define INCLUDED_VCL_ROADMAPWIZARD_HXX + +#include <memory> +#include <vcl/dllapi.h> +#include <vcl/wizardmachine.hxx> + +namespace vcl +{ + struct RoadmapWizardImpl; + + namespace RoadmapWizardTypes + { + typedef sal_Int16 PathId; + typedef ::std::vector< WizardTypes::WizardState > WizardPath; + }; + + //= RoadmapWizard + + /** is - no, not a wizard for a roadmap, but the base class for wizards + <em>supporting</em> a roadmap. + + The basic new concept introduced is a <em>path</em>:<br/> + A <em>path</em> is a sequence of states, which are to be executed in a linear order. + Elements in the path can be skipped, depending on choices the user makes. + + In the most simple wizards, you will have only one path consisting of <code>n</code> elements, + which are to be visited successively. + + In a slightly more complex wizard, you will have one linear path, were certain + steps might be skipped due to user input. For instance, the user may decide to not specify + certain aspects of the to-be-created object (e.g. by unchecking a check box), + and the wizard then will simply disable the step which corresponds to this step. + + In a yet more advanced wizards, you will have several paths of length <code>n1</code> and + <code>n2</code>, which share at least the first <code>k</code> states (where <code>k</code> + is at least 1), and an arbitrary number of other states. + */ + class VCL_DLLPUBLIC RoadmapWizardMachine : public vcl::WizardMachine + { + private: + std::unique_ptr<RoadmapWizardImpl> m_pImpl; + + public: + RoadmapWizardMachine(weld::Window* _pParent); + virtual ~RoadmapWizardMachine( ) override; + + void SetRoadmapHelpId( const OString& _rId ); + + // returns whether a given state is enabled + bool isStateEnabled(WizardTypes::WizardState nState) const; + + // WizardDialog overridables + virtual bool canAdvance() const override; + virtual void updateTravelUI() override; + + protected: + /** declares a valid path in the wizard + + The very first path which is declared is automatically activated. + + Note that all paths which are declared must have the very first state in + common. Also note that due to a restriction of the very base class (WizardDialog), + this common first state must be 0. + + You cannot declare new paths once the wizard started, so it's recommended that + you do all declarations within your derivee's constructor. + + @see activatePath + + @param _nId + the unique id you wish to give this path. This id can later on be used + to refer to the path which you just declared + */ + void declarePath( RoadmapWizardTypes::PathId _nPathId, const RoadmapWizardTypes::WizardPath& _lWizardStates); + + /** activates a path which has previously been declared with <member>declarePath</member> + + You can only activate paths which share the first <code>k</code> states with the path + which is previously active (if any), where <code>k</code> is the index of the + current state within the current path. + + <example> + Say you have paths, <code>(0,1,2,5)</code> and <code>(0,1,4,5)</code>. This means that after + step <code>1</code>, you either continue with state <code>2</code> or state <code>4</code>, + and after this, you finish in state <code>5</code>.<br/> + Now if the first path is active, and your current state is <code>1</code>, then you can + easily switch to the second path, since both paths start with <code>(0,1)</code>.<br/> + However, if your current state is <code>2</code>, then you can not switch to the second + path anymore. + </example> + + @param _nPathId + the id of the path. The path must have been declared (under this id) with + <member>declarePath</member> before it can be activated. + + @param _bDecideForIt + If <TRUE/>, the path will be completely activated, even if it is a conflicting path + (i.e. there is another path which shares the first <code>k</code> states with + the to-be-activated path.)<br/> + If <FALSE/>, then the new path is checked for conflicts with other paths. If such + conflicts exists, the path is not completely activated, but only up to the point + where it does <em>not</em> conflict.<br/> + With the paths in the example above, if you activate the second path (when both are + already declared), then only steps <code>0</code> and <code>1</code> are activated, + since they are common to both paths. + */ + void activatePath( RoadmapWizardTypes::PathId _nPathId, bool _bDecideForIt = false ); + + /** determine the next state to travel from the given one + + This method (which is declared in WizardMachine and overwritten here) + ensures that traveling happens along the active path. + + @see activatePath + */ + virtual WizardTypes::WizardState determineNextState(WizardTypes::WizardState nCurrentState) const override; + + /** en- or disables a state + + In the wizard's roadmap, states to travel to can be freely chosen. To prevent + users from selecting a state which is currently not available, you can declare this + state as being disabled. + + A situation where you need this may be when you have a checkbox which, when checked + by the user, enables a page with additional settings. As long as this checkbox is + not checked, the respective state would be disabled. + + Note that in theory, you can declare multiple paths, instead of disabling states. + For instance, if you have a path where one state can be potentially disabled, then + you could declare a second path, which does not contain this state. However, the + disadvantage is that then, not the complete path would be visible in the roadmap, + but only all steps up to the point where the both paths diverge.<br/> + Another disadvantage is that the number of needed paths grows exponentially with + the number of states which can be potentially disabled. + + @see declarePath + */ + void enableState(WizardTypes::WizardState nState, bool _bEnable = true); + + /** returns true if and only if the given state is known in at least one declared path + */ + bool knowsState(WizardTypes::WizardState nState) const; + + // WizardMachine overriables + virtual void enterState(WizardTypes::WizardState nState) override; + + /** returns a human readable name for a given state + + There is a default implementation for this method, which returns the display name + as given in a call to describeState. If there is no description for the given state, + this is worth an assertion in a non-product build, and then an empty string is + returned. + */ + virtual OUString getStateDisplayName(WizardTypes::WizardState nState) const; + + private: + DECL_DLLPRIVATE_LINK( OnRoadmapItemSelected, const OString&, bool ); + + /** updates the roadmap control to show the given path, as far as possible + (modulo conflicts with other paths) + */ + VCL_DLLPRIVATE void implUpdateRoadmap( ); + }; +} // namespace vcl + + +#endif // OOO_ INCLUDED_VCL_ROADMAPWIZARD_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/salctype.hxx b/include/vcl/salctype.hxx new file mode 100644 index 000000000..71f256b19 --- /dev/null +++ b/include/vcl/salctype.hxx @@ -0,0 +1,64 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_SALCTYPE_HXX +#define INCLUDED_VCL_SALCTYPE_HXX + +#include <sal/config.h> + +#include <vcl/graph.hxx> + +enum class ConvertDataFormat +{ + Unknown, + BMP, + GIF, + JPG, + MET, + PCT, + PNG, + SVM, + TIF, + WMF, + EMF, + SVG, + WEBP +}; + +class SvStream; + +struct ConvertData +{ +public: + + Graphic maGraphic; + SvStream& mrStm; + ConvertDataFormat mnFormat; + + ConvertData( const Graphic& rGraphic, SvStream& rStm, ConvertDataFormat nFormat ) : + maGraphic( rGraphic ), mrStm( rStm ), mnFormat( nFormat ) {} +}; + +typedef sal_uLong (*SALGRFCVTPROC)( void* pInst, + ConvertDataFormat nInFormat, void* pInBuffer, sal_uLong nInBufSize, + ConvertDataFormat nOutFormat, void** ppOutBuffer ); + +#endif // INCLUDED_VCL_SALCTYPE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/salgtype.hxx b/include/vcl/salgtype.hxx new file mode 100644 index 000000000..a6559d68d --- /dev/null +++ b/include/vcl/salgtype.hxx @@ -0,0 +1,86 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_SALGTYPE_HXX +#define INCLUDED_VCL_SALGTYPE_HXX + +#include <o3tl/typed_flags_set.hxx> +#include <tools/color.hxx> +#include <tools/gen.hxx> +#include <ostream> + +enum class DeviceFormat { + NONE = -1, + DEFAULT = 0, +#ifdef IOS + GRAYSCALE = 8 +#endif + }; + +constexpr ::Color SALCOLOR_NONE ( ColorTransparency, 0xFF, 0xFF, 0xFF, 0xFF ); + +struct SalTwoRect +{ + tools::Long mnSrcX; + tools::Long mnSrcY; + tools::Long mnSrcWidth; + tools::Long mnSrcHeight; + tools::Long mnDestX; + tools::Long mnDestY; + tools::Long mnDestWidth; + tools::Long mnDestHeight; + + SalTwoRect(tools::Long nSrcX, tools::Long nSrcY, tools::Long nSrcWidth, tools::Long nSrcHeight, + tools::Long nDestX, tools::Long nDestY, tools::Long nDestWidth, tools::Long nDestHeight) + : mnSrcX(nSrcX), mnSrcY(nSrcY), mnSrcWidth(nSrcWidth), mnSrcHeight(nSrcHeight) + , mnDestX(nDestX), mnDestY(nDestY), mnDestWidth(nDestWidth), mnDestHeight(nDestHeight) + { + } +}; + +template <typename charT, typename traits> +inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& stream, + const SalTwoRect& rPosAry) +{ + tools::Rectangle aSrcRect(rPosAry.mnSrcX, rPosAry.mnSrcY, rPosAry.mnSrcX + rPosAry.mnSrcWidth, + rPosAry.mnSrcY + rPosAry.mnSrcHeight); + tools::Rectangle aDestRect(rPosAry.mnDestX, rPosAry.mnDestY, + rPosAry.mnDestX + rPosAry.mnDestWidth, + rPosAry.mnDestY + rPosAry.mnDestHeight); + stream << aSrcRect << " => " << aDestRect; + return stream; +} + +enum class SalROPColor { + N0, N1, Invert +}; + +enum class SalInvert { + NONE = 0x00, + N50 = 0x01, + TrackFrame = 0x02 +}; +namespace o3tl +{ + template<> struct typed_flags<SalInvert> : is_typed_flags<SalInvert, 0x03> {}; +} + +#endif // INCLUDED_VCL_SALGTYPE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/salnativewidgets.hxx b/include/vcl/salnativewidgets.hxx new file mode 100644 index 000000000..057e05aac --- /dev/null +++ b/include/vcl/salnativewidgets.hxx @@ -0,0 +1,520 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_SALNATIVEWIDGETS_HXX +#define INCLUDED_VCL_SALNATIVEWIDGETS_HXX + +#include <vcl/dllapi.h> +#include <tools/gen.hxx> +#include <o3tl/typed_flags_set.hxx> + +/* Control Types: + * + * Specify the overall, whole control + * type (as opposed to parts of the + * control if it were composite). + */ + +enum class ControlType { +// for use in general purpose ImplControlValue + Generic = 0, +// Normal PushButton/Command Button + Pushbutton = 1, +// Normal single radio button + Radiobutton = 2, +// Normal single checkbox + Checkbox = 10, +// Combobox, i.e. a ListBox +// that allows data entry by user + Combobox = 20, +// Control that allows text entry + Editbox = 30, +// Control that allows text entry, but without the usual border +// Has to be handled separately, because this one cannot handle +// ControlPart::HasBackgroundTexture, which is drawn in the edit box'es +// border window. + EditboxNoBorder = 31, +// Control that allows text entry +// ( some systems distinguish between single and multi line edit boxes ) + MultilineEditbox = 32, +// Control that pops up a menu, +// but does NOT allow data entry + Listbox = 35, +// An edit field together with two little +// buttons on the side (aka spin field) + Spinbox = 40, +// Two standalone spin buttons +// without an edit field + SpinButtons = 45, +// A single tab + TabItem = 50, +// The border around a tab area, +// but without the tabs themselves. +// May have a gap at the top for +// the active tab + TabPane = 55, +// The background to the tab area + TabHeader = 56, +// Background of a Tab Pane + TabBody = 57, +// Normal scrollbar, including +// all parts like slider, buttons + Scrollbar = 60, + Slider = 65, +// A separator line + Fixedline = 80, +// A toolbar control with buttons and a grip + Toolbar = 100, +// The menubar + Menubar = 120, +// popup menu + MenuPopup = 121, + Progress = 131, +// Progress bar for the intro window +// (aka splash screen), in case some +// wants native progress bar in the +// application but not for the splash +// screen (used in desktop/) + IntroProgress = 132, +// tool tips + Tooltip = 140, +// to draw the implemented theme + WindowBackground = 150, +//to draw border of frames natively + Frame = 160, +// for nodes in listviews +// used in svtools/source/contnr/svtreebx.cxx + ListNode = 170, +// nets between elements of listviews +// with nodes + ListNet = 171, +// for list headers + ListHeader = 172, +}; + + +/* Control Parts: + * + * Uniquely identify a part of a control, + * for example the slider of a scroll bar. + */ + +enum class ControlPart +{ + NONE = 0, + Entire = 1, + ListboxWindow = 5, // the static listbox window containing the list + Button = 100, + ButtonUp = 101, + ButtonDown = 102, // Also for ComboBoxes/ListBoxes + ButtonLeft = 103, + ButtonRight = 104, + AllButtons = 105, + SeparatorHorz = 106, + SeparatorVert = 107, + TrackHorzLeft = 200, + TrackVertUpper = 201, + TrackHorzRight = 202, + TrackVertLower = 203, + TrackHorzArea = 204, + TrackVertArea = 205, + Arrow = 220, + ThumbHorz = 210, // Also used as toolbar grip + ThumbVert = 211, // Also used as toolbar grip + MenuItem = 250, + MenuItemCheckMark = 251, + MenuItemRadioMark = 252, + Separator = 253, + SubmenuArrow = 254, + +/* #i77549# + HACK: for scrollbars in case of thumb rect, page up and page down rect we + abuse the HitTestNativeScrollbar interface. All theming engines but aqua + are actually able to draw the thumb according to our internal representation. + However aqua draws a little outside. The canonical way would be to enhance the + HitTestNativeScrollbar passing a ScrollbarValue additionally so all necessary + information is available in the call. + . + However since there is only this one small exception we will deviate a little and + instead pass the respective rect as control region to allow for a small correction. + + So all places using HitTestNativeScrollbar on ControlPart::ThumbHorz, ControlPart::ThumbVert, + ControlPart::TrackHorzLeft, ControlPart::TrackHorzRight, ControlPart::TrackVertUpper, ControlPart::TrackVertLower + do not use the control rectangle as region but the actual part rectangle, making + only small deviations feasible. +*/ + +/** The edit field part of a control, e.g. of the combo box. + + Currently used just for combo boxes and just for GetNativeControlRegion(). + It is valid only if GetNativeControlRegion() supports ControlPart::ButtonDown as + well. +*/ + SubEdit = 300, + +// For controls that require the entire background +// to be drawn first, and then other pieces over top. +// (GTK+ scrollbars for example). Control region passed +// in to draw this part is expected to be the entire +// area of the control. +// A control may respond to one or both. + DrawBackgroundHorz = 1000, + DrawBackgroundVert = 1001, + +// GTK+ also draws tabs right->left since there is a +// hardcoded 2 pixel overlap between adjacent tabs + TabsDrawRtl = 3000, + +// Qt doesn't have a separate header to draw + TabPaneWithHeader = 3001, + +// For themes that do not want to have the focus +// rectangle part drawn by VCL but take care of the +// whole inner control part by themselves +// eg, listboxes or comboboxes or spinbuttons + HasBackgroundTexture = 4000, + +// For scrollbars that have 3 buttons (most KDE themes) + HasThreeButtons = 5000, + + BackgroundWindow = 6000, + BackgroundDialog = 6001, + +//to draw natively the border of frames + Border = 7000, + +//to draw natively the focus rects + Focus = 8000 +}; + +/* Control State: + * + * Specify how a particular part of the control + * is to be drawn. Constants are bitwise OR-ed + * together to compose a final drawing state. + * A _disabled_ state is assumed by the drawing + * functions until an ENABLED or HIDDEN is passed + * in the ControlState. + */ +enum class ControlState { + NONE = 0, + ENABLED = 0x0001, + FOCUSED = 0x0002, + PRESSED = 0x0004, + ROLLOVER = 0x0008, + DEFAULT = 0x0020, + SELECTED = 0x0040 +}; +namespace o3tl +{ + template<> struct typed_flags<ControlState> : is_typed_flags<ControlState, 0x006f> {}; +} + +/* ButtonValue: + * + * Identifies the tri-state value options + * that buttons allow + */ + +enum class ButtonValue { + DontKnow, + On, + Off, + Mixed +}; + +/* ImplControlValue: + * + * Generic value container for all control parts. + */ + +class VCL_DLLPUBLIC ImplControlValue +{ + friend class SalFrame; + + private: + ControlType mType; + ButtonValue mTristate; // Tristate value: on, off, mixed + tools::Long mNumber; // numeric value + protected: + ImplControlValue( ControlType i_eType, tools::Long i_nNumber ) + : mType( i_eType ) + , mTristate( ButtonValue::DontKnow ) + , mNumber( i_nNumber ) + {} + + public: + explicit ImplControlValue( ButtonValue nTristate ) + : mType( ControlType::Generic ), mTristate(nTristate), mNumber(0) {} + explicit ImplControlValue( tools::Long nNumeric ) + : mType( ControlType::Generic ), mTristate(ButtonValue::DontKnow), mNumber( nNumeric) {} + ImplControlValue() + : mType( ControlType::Generic ), mTristate(ButtonValue::DontKnow), mNumber(0) {} + + virtual ~ImplControlValue(); + + ImplControlValue(ImplControlValue const &) = default; + ImplControlValue(ImplControlValue &&) = default; + ImplControlValue & operator =(ImplControlValue const &) = delete; // due to const mType + ImplControlValue & operator =(ImplControlValue &&) = delete; // due to const mType + + virtual ImplControlValue* clone() const; + + ControlType getType() const { return mType; } + + ButtonValue getTristateVal() const { return mTristate; } + void setTristateVal( ButtonValue nTristate ) { mTristate = nTristate; } + + tools::Long getNumericVal() const { return mNumber; } + void setNumericVal( tools::Long nNumeric ) { mNumber = nNumeric; } +}; + +/* ScrollbarValue: + * + * Value container for scrollbars. + */ +class SAL_DLLPUBLIC_RTTI ScrollbarValue final : public ImplControlValue +{ + public: + tools::Long mnMin; + tools::Long mnMax; + tools::Long mnCur; + tools::Long mnVisibleSize; + tools::Rectangle maThumbRect; + tools::Rectangle maButton1Rect; + tools::Rectangle maButton2Rect; + ControlState mnButton1State; + ControlState mnButton2State; + ControlState mnThumbState; + + ScrollbarValue() + : ImplControlValue( ControlType::Scrollbar, 0 ) + { + mnMin = 0; mnMax = 0; mnCur = 0; mnVisibleSize = 0; + mnButton1State = ControlState::NONE; mnButton2State = ControlState::NONE; + mnThumbState = ControlState::NONE; + }; + virtual ~ScrollbarValue() override; + virtual ScrollbarValue* clone() const override; + + ScrollbarValue(ScrollbarValue const &) = default; + ScrollbarValue(ScrollbarValue &&) = default; + ScrollbarValue & operator =(ScrollbarValue const &) = delete; // due to ImplControlValue + ScrollbarValue & operator =(ScrollbarValue &&) = delete; // due to ImplControlValue +}; + +class SAL_DLLPUBLIC_RTTI SliderValue final : public ImplControlValue +{ + public: + tools::Long mnMin; + tools::Long mnMax; + tools::Long mnCur; + tools::Rectangle maThumbRect; + ControlState mnThumbState; + + SliderValue() + : ImplControlValue( ControlType::Slider, 0 ) + , mnMin( 0 ), mnMax( 0 ), mnCur( 0 ), mnThumbState( ControlState::NONE ) + {} + virtual ~SliderValue() override; + virtual SliderValue* clone() const override; + + SliderValue(SliderValue const &) = default; + SliderValue(SliderValue &&) = default; + SliderValue & operator =(SliderValue const &) = delete; // due to ImplControlValue + SliderValue & operator =(SliderValue &&) = delete; // due to ImplControlValue +}; + +class VCL_DLLPUBLIC TabPaneValue final : public ImplControlValue +{ +public: + tools::Rectangle m_aTabHeaderRect; + tools::Rectangle m_aSelectedTabRect; + // increased tab size, so it'll overlab the frame rect when drawing + // static value, as there is currently no sane way to return additional data + static int m_nOverlap; + + TabPaneValue(const tools::Rectangle &rTabHeaderRect, const tools::Rectangle &rSelectedTabRect) + : ImplControlValue(ControlType::TabPane, 0) + , m_aTabHeaderRect(rTabHeaderRect) + , m_aSelectedTabRect(rSelectedTabRect) + { + } + TabPaneValue* clone() const override; + + TabPaneValue(TabPaneValue const &) = default; + TabPaneValue(TabPaneValue &&) = default; + TabPaneValue & operator =(TabPaneValue const &) = delete; + TabPaneValue & operator =(TabPaneValue &&) = delete; +}; + +/* TabitemValue: + * + * Value container for tabitems. + */ + +/* TABITEM constants are OR-ed together */ +enum class TabitemFlags +{ + NONE = 0x00, + LeftAligned = 0x01, // the tabitem is aligned with the left border of the TabControl + RightAligned = 0x02, // the tabitem is aligned with the right border of the TabControl + FirstInGroup = 0x04, // the tabitem is the first in group of tabitems + LastInGroup = 0x08, // the tabitem is the last in group of tabitems +}; +namespace o3tl +{ + template<> struct typed_flags<TabitemFlags> : is_typed_flags<TabitemFlags, 0x0f> {}; +} + +class SAL_DLLPUBLIC_RTTI TabitemValue final : public ImplControlValue +{ + public: + TabitemFlags mnAlignment; + tools::Rectangle maContentRect; + + TabitemValue(const tools::Rectangle &rContentRect) + : ImplControlValue( ControlType::TabItem, 0 ) + , mnAlignment(TabitemFlags::NONE) + , maContentRect(rContentRect) + { + } + virtual ~TabitemValue() override; + virtual TabitemValue* clone() const override; + + TabitemValue(TabitemValue const &) = default; + TabitemValue(TabitemValue &&) = default; + TabitemValue & operator =(TabitemValue const &) = delete; // due to ImplControlValue + TabitemValue & operator =(TabitemValue &&) = delete; // due to ImplControlValue + + bool isLeftAligned() const { return bool(mnAlignment & TabitemFlags::LeftAligned); } + bool isRightAligned() const { return bool(mnAlignment & TabitemFlags::RightAligned); } + bool isBothAligned() const { return isLeftAligned() && isRightAligned(); } + bool isNotAligned() const { return !(mnAlignment & (TabitemFlags::LeftAligned | TabitemFlags::RightAligned)); } + bool isFirst() const { return bool(mnAlignment & TabitemFlags::FirstInGroup); } + bool isLast() const { return bool(mnAlignment & TabitemFlags::LastInGroup); } + const tools::Rectangle& getContentRect() const { return maContentRect; } +}; + +/* SpinbuttonValue: + * + * Value container for spinbuttons to paint both buttons at once. + * Note: the other parameters of DrawNativeControl will have no meaning + * all parameters for spinbuttons are carried here + */ +class SAL_DLLPUBLIC_RTTI SpinbuttonValue final : public ImplControlValue +{ + public: + tools::Rectangle maUpperRect; + tools::Rectangle maLowerRect; + ControlState mnUpperState; + ControlState mnLowerState; + ControlPart mnUpperPart; + ControlPart mnLowerPart; + + SpinbuttonValue() + : ImplControlValue( ControlType::SpinButtons, 0 ) + , mnUpperState(ControlState::NONE) + , mnLowerState(ControlState::NONE) + , mnUpperPart(ControlPart::NONE) + , mnLowerPart(ControlPart::NONE) + { + } + + virtual ~SpinbuttonValue() override; + virtual SpinbuttonValue* clone() const override; + + SpinbuttonValue(SpinbuttonValue const &) = default; + SpinbuttonValue(SpinbuttonValue &&) = default; + SpinbuttonValue & operator =(SpinbuttonValue const &) = delete; // due to ImplControlValue + SpinbuttonValue & operator =(SpinbuttonValue &&) = delete; // due to ImplControlValue +}; + +/* MenubarValue: + * + * Value container for menubars specifying height of adjacent docking area + */ +class MenubarValue final : public ImplControlValue +{ +public: + MenubarValue() : ImplControlValue( ControlType::Menubar, 0 ) + { maTopDockingAreaHeight=0; } + virtual ~MenubarValue() override; + virtual MenubarValue* clone() const override; + MenubarValue(MenubarValue const &) = default; + MenubarValue(MenubarValue &&) = default; + MenubarValue & operator =(MenubarValue const &) = delete; // due to ImplControlValue + MenubarValue & operator =(MenubarValue &&) = delete; // due to ImplControlValue + int maTopDockingAreaHeight; +}; + +/* MenupopupValue: + * + * Value container for menu items; specifies the rectangle for the whole item which + * may be useful when drawing parts with a smaller rectangle. + */ +class SAL_DLLPUBLIC_RTTI MenupopupValue final : public ImplControlValue +{ +public: + MenupopupValue( tools::Long i_nGutterWidth, const tools::Rectangle& i_rItemRect ) + : ImplControlValue( ControlType::MenuPopup, i_nGutterWidth ) + , maItemRect( i_rItemRect ) + {} + virtual ~MenupopupValue() override; + virtual MenupopupValue* clone() const override; + MenupopupValue(MenupopupValue const &) = default; + MenupopupValue(MenupopupValue &&) = default; + MenupopupValue & operator =(MenupopupValue const &) = delete; // due to ImplControlValue + MenupopupValue & operator =(MenupopupValue &&) = delete; // due to ImplControlValue + tools::Rectangle maItemRect; +}; + +/* PushButtonValue: + * + * Value container for pushbuttons specifying additional drawing hints + */ +class VCL_DLLPUBLIC PushButtonValue final : public ImplControlValue +{ +public: + PushButtonValue() + : ImplControlValue( ControlType::Pushbutton, 0 ) + , mbBevelButton(false) + , mbSingleLine(true) + , mbIsAction(false) + , m_bFlatButton(false) + {} + + virtual ~PushButtonValue() override; + virtual PushButtonValue* clone() const override; + + PushButtonValue(PushButtonValue const &) = default; + PushButtonValue(PushButtonValue &&) = default; + PushButtonValue & operator =(PushButtonValue const &) = delete; // due to ImplControlValue + PushButtonValue & operator =(PushButtonValue &&) = delete; // due to ImplControlValue + + bool mbBevelButton:1; // only used on OSX + bool mbSingleLine:1; // only used on OSX + bool mbIsAction:1; + bool m_bFlatButton:1; +}; + + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/scheduler.hxx b/include/vcl/scheduler.hxx new file mode 100644 index 000000000..1b6340413 --- /dev/null +++ b/include/vcl/scheduler.hxx @@ -0,0 +1,88 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_SCHEDULER_HXX +#define INCLUDED_VCL_SCHEDULER_HXX + +#include <vcl/dllapi.h> + +struct ImplSchedulerContext; + +class VCL_DLLPUBLIC Scheduler final +{ + friend class SchedulerGuard; + friend class Task; + Scheduler() = delete; + + static inline void UpdateSystemTimer( ImplSchedulerContext &rSchedCtx, + sal_uInt64 nMinPeriod, + bool bForce, sal_uInt64 nTime ); + + static void ImplStartTimer ( sal_uInt64 nMS, bool bForce, sal_uInt64 nTime ); + + static void Lock(); + static void Unlock(); + +public: + static constexpr sal_uInt64 ImmediateTimeoutMs = 0; + static constexpr sal_uInt64 InfiniteTimeoutMs = SAL_MAX_UINT64; + + static void ImplDeInitScheduler(); + + /** + * System timer callback function, which processes one LO task + * + * Will restart the system timer, so it will process further tasks at the right time. + **/ + static void CallbackTaskScheduling(); + + /** + * Process all events until none is pending + * + * This can busy-lock, if some task or system event always generates new + * events when being processed. Most time it's called in unit tests to + * process all pending events. Internally it just calls + * Application::Reschedule( true ) until it fails. + * + * @see Application::Reschedule + */ + static void ProcessEventsToIdle(); + + /** + * Wakes up the scheduler + * + * This doesn't handle any events! It just ensures the Scheduler is run as + * soon as possible by forcing the Scheduler timer to fire. + * + * Can be used for complex UpdateMinPeriod function, where the task is + * actually active but not ready and we want to skip the Task::Start() + * queue append for faster reaction. + */ + static void Wakeup(); + + /// Control the deterministic mode. In this mode, two subsequent runs of + /// LibreOffice fire about the same amount idles. + static void SetDeterministicMode(bool bDeterministic); + /// Return the current state of deterministic mode. + static bool GetDeterministicMode(); +}; + +#endif // INCLUDED_VCL_SCHEDULER_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/scopedbitmapaccess.hxx b/include/vcl/scopedbitmapaccess.hxx new file mode 100644 index 000000000..b06618091 --- /dev/null +++ b/include/vcl/scopedbitmapaccess.hxx @@ -0,0 +1,123 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_SCOPEDBITMAPACCESS_HXX +#define INCLUDED_VCL_SCOPEDBITMAPACCESS_HXX + +#include <sal/types.h> + +namespace vcl +{ + +/** This template handles BitmapAccess the RAII way. + + Please don't use directly, but through the ready-made typedefs + ScopedReadAccess and ScopedWriteAccess in classes Bitmap and + AlphaMask. + + Use as follows: + Bitmap aBitmap; + Bitmap::ScopedReadAccess pReadAccess( aBitmap ); + pReadAccess->SetPixel()... + + Bitmap aBitmap2; + BitmapScopedWriteAccess pWriteAccess( bCond ? aBitmap2.AcquireWriteAccess() : 0, aBitmap2 ); + if ( pWriteAccess )... + + @attention for practical reasons, ScopedBitmapAccess stores a + reference to the provided bitmap, thus, make sure that the bitmap + specified at construction time lives at least as long as the + ScopedBitmapAccess. + */ +template < class Access, class Bitmap, Access* (Bitmap::* Acquire)() > class ScopedBitmapAccess +{ +public: + explicit ScopedBitmapAccess( Bitmap& rBitmap ) : + mpAccess( nullptr ), + mpBitmap( &rBitmap ) + { + mpAccess = (mpBitmap->*Acquire)(); + } + + ScopedBitmapAccess( Access* pAccess, Bitmap& rBitmap ) : + mpAccess( pAccess ), + mpBitmap( &rBitmap ) + { + } + + ScopedBitmapAccess( ) : + mpAccess( nullptr ), + mpBitmap( nullptr ) + { + } + + // Move semantics + ScopedBitmapAccess &operator=(ScopedBitmapAccess&&other) + { + mpAccess=other.mpAccess; + mpBitmap=other.mpBitmap; + other.mpAccess = nullptr; + other.mpBitmap = nullptr; + return *this; + } + + // Disable copy from lvalue. + ScopedBitmapAccess(const ScopedBitmapAccess&) = delete; + ScopedBitmapAccess &operator=(const ScopedBitmapAccess&) = delete; + + ~ScopedBitmapAccess() COVERITY_NOEXCEPT_FALSE + { + if (mpAccess) + mpBitmap->ReleaseAccess( mpAccess ); + } + + void reset() + { + if (mpAccess) + { + mpBitmap->ReleaseAccess( mpAccess ); + mpAccess = nullptr; + } + } + + bool operator!() const { return !mpAccess; } + explicit operator bool() const + { + return mpAccess; + } + + Access* get() { return mpAccess; } + const Access* get() const { return mpAccess; } + + Access* operator->() { return mpAccess; } + const Access* operator->() const { return mpAccess; } + + Access& operator*() { return *mpAccess; } + const Access& operator*() const { return *mpAccess; } + +private: + Access* mpAccess; + Bitmap* mpBitmap; +}; + +} + +#endif // INCLUDED_VCL_SCOPEDBITMAPACCESS_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/scrbar.hxx b/include/vcl/scrbar.hxx new file mode 100644 index 000000000..77cbbb657 --- /dev/null +++ b/include/vcl/scrbar.hxx @@ -0,0 +1,158 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_SCRBAR_HXX +#define INCLUDED_VCL_SCRBAR_HXX + +#include <vcl/dllapi.h> +#include <vcl/ctrl.hxx> +#include <memory> + + +enum class ScrollType +{ + DontKnow, + LineUp, LineDown, + PageUp, PageDown, + Drag +}; + + +struct ImplScrollBarData; + +class VCL_DLLPUBLIC ScrollBar : public Control +{ +private: + tools::Rectangle maBtn1Rect; + tools::Rectangle maBtn2Rect; + tools::Rectangle maPage1Rect; + tools::Rectangle maPage2Rect; + tools::Rectangle maThumbRect; + tools::Rectangle maTrackRect; + std::unique_ptr<ImplScrollBarData> mpData; + tools::Long mnStartPos; + tools::Long mnMouseOff; + tools::Long mnThumbPixRange; + tools::Long mnThumbPixPos; + tools::Long mnThumbPixSize; + tools::Long mnMinRange; + tools::Long mnMaxRange; + tools::Long mnThumbPos; + tools::Long mnVisibleSize; + tools::Long mnLineSize; + tools::Long mnPageSize; + tools::Long mnDelta; + sal_uInt16 mnStateFlags; + ScrollType meScrollType; + bool mbCalcSize; + bool mbFullDrag; + Link<ScrollBar*,void> maScrollHdl; + Link<ScrollBar*,void> maEndScrollHdl; + + SAL_DLLPRIVATE tools::Rectangle* ImplFindPartRect( const Point& rPt ); + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + SAL_DLLPRIVATE void ImplInitStyle( WinBits nStyle ); + SAL_DLLPRIVATE void ImplUpdateRects( bool bUpdate = true ); + SAL_DLLPRIVATE tools::Long ImplCalcThumbPos( tools::Long nPixPos ) const; + SAL_DLLPRIVATE tools::Long ImplCalcThumbPosPix( tools::Long nPos ) const; + SAL_DLLPRIVATE void ImplCalc( bool bUpdate = true ); + SAL_DLLPRIVATE void ImplDraw(vcl::RenderContext& rRenderContext); + using Window::ImplScroll; + SAL_DLLPRIVATE tools::Long ImplScroll( tools::Long nNewPos, bool bCallEndScroll ); + SAL_DLLPRIVATE tools::Long ImplDoAction( bool bCallEndScroll ); + SAL_DLLPRIVATE void ImplDoMouseAction( const Point& rPos, bool bCallAction = true ); + SAL_DLLPRIVATE void ImplInvert(); + SAL_DLLPRIVATE bool ImplDrawNative(vcl::RenderContext& rRenderContext, sal_uInt16 SystemTextColorFlags); + SAL_DLLPRIVATE void ImplDragThumb( const Point& rMousePos ); + SAL_DLLPRIVATE Size getCurrentCalcSize() const; + DECL_DLLPRIVATE_LINK( ImplAutoTimerHdl, Timer*, void ); + +public: + explicit ScrollBar( vcl::Window* pParent, WinBits nStyle = WB_VERT ); + virtual ~ScrollBar() override; + virtual void dispose() override; + + virtual void MouseButtonDown(const MouseEvent& rMEvt) override; + virtual void Tracking(const TrackingEvent& rTEvt) override; + virtual void KeyInput(const KeyEvent& rKEvt) override; + virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override; + virtual void Draw(OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags) override; + virtual void Move() override; + virtual void Resize() override; + virtual void StateChanged(StateChangedType nType) override; + virtual void DataChanged(const DataChangedEvent& rDCEvt) override; + virtual bool PreNotify(NotifyEvent& rNEvt) override; + virtual void GetFocus() override; + virtual void LoseFocus() override; + virtual void ApplySettings(vcl::RenderContext& rRenderContext) override; + + using Window::Scroll; + void Scroll(); + virtual void EndScroll(); + + tools::Long DoScroll( tools::Long nNewPos ); + tools::Long DoScrollAction( ScrollType eScrollType ); + + void EnableDrag() { mbFullDrag = true; } + + void SetRangeMin( tools::Long nNewRange ); + tools::Long GetRangeMin() const { return mnMinRange; } + void SetRangeMax( tools::Long nNewRange ); + tools::Long GetRangeMax() const { return mnMaxRange; } + void SetRange( const Range& rRange ); + Range GetRange() const { return Range( GetRangeMin(), GetRangeMax() ); } + void SetThumbPos( tools::Long nThumbPos ); + tools::Long GetThumbPos() const { return mnThumbPos; } + void SetLineSize( tools::Long nNewSize ) { mnLineSize = nNewSize; } + tools::Long GetLineSize() const { return mnLineSize; } + void SetPageSize( tools::Long nNewSize ) { mnPageSize = nNewSize; } + tools::Long GetPageSize() const { return mnPageSize; } + void SetVisibleSize( tools::Long nNewSize ); + tools::Long GetVisibleSize() const { return mnVisibleSize; } + + tools::Long GetDelta() const { return mnDelta; } + ScrollType GetType() const { return meScrollType; } + + void SetScrollHdl( const Link<ScrollBar*,void>& rLink ) { maScrollHdl = rLink; } + const Link<ScrollBar*,void>& GetScrollHdl() const { return maScrollHdl; } + void SetEndScrollHdl( const Link<ScrollBar*,void>& rLink ) { maEndScrollHdl = rLink; } + + virtual Size GetOptimalSize() const override; +}; + + +class VCL_DLLPUBLIC ScrollBarBox final : public vcl::Window +{ +private: + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + + virtual void ApplySettings(vcl::RenderContext& rRenderContext) override; + +public: + explicit ScrollBarBox( vcl::Window* pParent, WinBits nStyle = 0 ); + + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; +}; + +#endif // INCLUDED_VCL_SCRBAR_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/seleng.hxx b/include/vcl/seleng.hxx new file mode 100644 index 000000000..580ae7417 --- /dev/null +++ b/include/vcl/seleng.hxx @@ -0,0 +1,240 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_SELENG_HXX +#define INCLUDED_VCL_SELENG_HXX + +#include <vcl/dllapi.h> +#include <vcl/timer.hxx> +#include <vcl/event.hxx> +#include <vcl/vclenum.hxx> +#include <o3tl/typed_flags_set.hxx> + +class CommandEvent; + +namespace vcl { + class Window; +} + +// Timerticks +#define SELENG_DRAGDROP_TIMEOUT 400 +#define SELENG_AUTOREPEAT_INTERVAL 50 +#define SELENG_AUTOREPEAT_INTERVAL_MIN 25 +#define SELENG_AUTOREPEAT_INTERVAL_MAX 300 + +class VCL_DLLPUBLIC FunctionSet +{ +public: + virtual ~FunctionSet() = 0; + + virtual void BeginDrag() = 0; + + virtual void CreateAnchor() = 0; // Anker-Pos := Cursor-Pos + virtual void DestroyAnchor() = 0; + + // move cursor, at the same time match cursor position to the selection + // starting at anchor. true == Ok + virtual void SetCursorAtPoint( const Point& rPointPixel, + bool bDontSelectAtCursor = false ) = 0; + + virtual bool IsSelectionAtPoint( const Point& rPointPixel ) = 0; + virtual void DeselectAtPoint( const Point& rPointPixel ) = 0; + // delete anchor & deselect all + virtual void DeselectAll() = 0; +}; + + +enum class SelectionEngineFlags { + DRG_ENAB = 0x0001, + IN_SEL = 0x0002, + IN_ADD = 0x0004, + ADD_ALW = 0x0008, + HAS_ANCH = 0x0020, + CMDEVT = 0x0040, + WAIT_UPEVT = 0x0080, + EXPANDONMOVE = 0x0100, +}; +namespace o3tl +{ + template<> struct typed_flags<SelectionEngineFlags> : is_typed_flags<SelectionEngineFlags, 0x01ef> {}; +} + +class VCL_DLLPUBLIC SelectionEngine +{ +private: + FunctionSet* pFunctionSet; + VclPtr<vcl::Window> pWin; + tools::Rectangle aArea; + Timer aWTimer; // generate fake mouse moves + MouseEvent aLastMove; + SelectionMode eSelMode; + sal_uLong nUpdateInterval; + sal_uInt16 nLockedMods; + SelectionEngineFlags nFlags; + DECL_DLLPRIVATE_LINK( ImpWatchDog, Timer*, void ); + + inline bool ShouldDeselect( bool bModifierKey1 ) const; + // determines to deselect or not when Ctrl-key is pressed on CursorPosChanging +public: + + SelectionEngine( vcl::Window* pWindow, + FunctionSet* pFunctions = nullptr ); + ~SelectionEngine(); + // Avoid implicitly defined copy constructors/assignments for the + // DLLPUBLIC class (they may require forward-declared classes used + // internally to be defined in places using SelectionEngine) + SelectionEngine(const SelectionEngine&) = delete; + SelectionEngine(SelectionEngine&&) = delete; + SelectionEngine& operator=(const SelectionEngine&) = delete; + SelectionEngine& operator=(SelectionEngine&&) = delete; + + // true: Event was processed by Selection Engine + bool SelMouseButtonDown( const MouseEvent& rMEvt ); + bool SelMouseButtonUp( const MouseEvent& rMEvt ); + bool SelMouseMove( const MouseEvent& rMEvt ); + //SelMouseButtonDown captures mouse events, SelMouseButtonUp + //releases the capture. If you need to release the mouse + //capture after SelMouseButtonDown but before + //SelMouseButtonUp, e.g. to allow events to go to a + //context menu via "Command" which is delivered after + //mouse down but before mouse up, then use this + void ReleaseMouse(); + void CaptureMouse(); + + // Keyboard + void CursorPosChanging( bool bShift, bool bMod1 ); + + // is needed to generate a Move event via a Timer + // when the mouse is outside the area + void SetVisibleArea( const tools::Rectangle& rNewArea ) + { aArea = rNewArea; } + + void SetAddMode( bool); + bool IsAddMode() const; + + void AddAlways( bool bOn ); + bool IsAlwaysAdding() const; + + void EnableDrag( bool bOn ); + + void SetSelectionMode( SelectionMode eMode ); + SelectionMode GetSelectionMode() const { return eSelMode; } + + void SetFunctionSet( FunctionSet* pFuncs ) + { pFunctionSet = pFuncs; } + const FunctionSet* GetFunctionSet() const { return pFunctionSet; } + + const Point& GetMousePosPixel() const + { return aLastMove.GetPosPixel(); } + const MouseEvent& GetMouseEvent() const { return aLastMove; } + + void SetWindow( vcl::Window*); + vcl::Window* GetWindow() const { return pWin; } + + void LockModifiers( sal_uInt16 nModifiers ) + { nLockedMods = nModifiers; } + sal_uInt16 GetLockedModifiers() const { return nLockedMods; } + + bool IsInSelection() const; + void Reset(); + + bool Command(const CommandEvent& rCEvt); + + bool HasAnchor() const; + void SetAnchor( bool bAnchor ); + + void SetUpdateInterval( sal_uLong nInterval ); + + // is switched on in the Ctor + void ExpandSelectionOnMouseMove( bool bExpand = true ) + { + if( bExpand ) + nFlags |= SelectionEngineFlags::EXPANDONMOVE; + else + nFlags &= ~SelectionEngineFlags::EXPANDONMOVE; + } +}; + +inline bool SelectionEngine::IsAddMode() const +{ + if ( nFlags & (SelectionEngineFlags::IN_ADD | SelectionEngineFlags::ADD_ALW) ) + return true; + else + return false; +} + +inline void SelectionEngine::SetAddMode( bool bNewMode ) +{ + if ( bNewMode ) + nFlags |= SelectionEngineFlags::IN_ADD; + else + nFlags &= ~SelectionEngineFlags::IN_ADD; +} + +inline void SelectionEngine::EnableDrag( bool bOn ) +{ + if ( bOn ) + nFlags |= SelectionEngineFlags::DRG_ENAB; + else + nFlags &= ~SelectionEngineFlags::DRG_ENAB; +} + +inline void SelectionEngine::AddAlways( bool bOn ) +{ + if( bOn ) + nFlags |= SelectionEngineFlags::ADD_ALW; + else + nFlags &= ~SelectionEngineFlags::ADD_ALW; +} + +inline bool SelectionEngine::IsAlwaysAdding() const +{ + if ( nFlags & SelectionEngineFlags::ADD_ALW ) + return true; + else + return false; +} + +inline bool SelectionEngine::IsInSelection() const +{ + if ( nFlags & SelectionEngineFlags::IN_SEL ) + return true; + else + return false; +} + +inline bool SelectionEngine::HasAnchor() const +{ + if ( nFlags & SelectionEngineFlags::HAS_ANCH ) + return true; + else + return false; +} + +inline void SelectionEngine::SetAnchor( bool bAnchor ) +{ + if ( bAnchor ) + nFlags |= SelectionEngineFlags::HAS_ANCH; + else + nFlags &= ~SelectionEngineFlags::HAS_ANCH; +} + +#endif // INCLUDED_VCL_SELENG_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/settings.hxx b/include/vcl/settings.hxx new file mode 100644 index 000000000..679515081 --- /dev/null +++ b/include/vcl/settings.hxx @@ -0,0 +1,726 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_SETTINGS_HXX +#define INCLUDED_VCL_SETTINGS_HXX + +#include <vcl/dllapi.h> +#include <tools/color.hxx> +#include <tools/gen.hxx> +#include <o3tl/typed_flags_set.hxx> + +#include <memory> +#include <vector> + +#include <optional> + +class BitmapEx; +class LanguageTag; +class SvtSysLocale; + +class LocaleDataWrapper; +struct ImplMouseData; +struct ImplMiscData; +struct ImplHelpData; +struct ImplStyleData; +struct ImplAllSettingsData; +enum class ConfigurationHints; + +namespace vcl { + class Font; + class I18nHelper; + class IconThemeInfo; +} + + +enum class MouseSettingsOptions +{ + NONE = 0x00, + AutoCenterPos = 0x02, + AutoDefBtnPos = 0x04, +}; +namespace o3tl +{ + template<> struct typed_flags<MouseSettingsOptions> : is_typed_flags<MouseSettingsOptions, 0x06> {}; +} + +enum class MouseFollowFlags +{ + Menu = 0x0001, +}; +namespace o3tl +{ + template<> struct typed_flags<MouseFollowFlags> : is_typed_flags<MouseFollowFlags, 0x01> {}; +} + +enum class MouseMiddleButtonAction +{ + Nothing, AutoScroll, PasteSelection +}; + +enum class MouseWheelBehaviour +{ + Disable, FocusOnly, ALWAYS +}; + +class VCL_DLLPUBLIC MouseSettings +{ +private: + void CopyData(); + std::shared_ptr<ImplMouseData> mxData; + +public: + MouseSettings(); + + void SetOptions( MouseSettingsOptions nOptions ); + MouseSettingsOptions GetOptions() const; + + void SetDoubleClickTime( sal_uInt64 nDoubleClkTime ); + sal_uInt64 GetDoubleClickTime() const; + + void SetDoubleClickWidth( sal_Int32 nDoubleClkWidth ); + sal_Int32 GetDoubleClickWidth() const; + + void SetDoubleClickHeight( sal_Int32 nDoubleClkHeight ); + sal_Int32 GetDoubleClickHeight() const; + + void SetStartDragWidth( sal_Int32 nDragWidth ); + sal_Int32 GetStartDragWidth() const; + + void SetStartDragHeight( sal_Int32 nDragHeight ); + sal_Int32 GetStartDragHeight() const; + + static sal_uInt16 GetStartDragCode(); + + static sal_uInt16 GetContextMenuCode(); + + static sal_uInt16 GetContextMenuClicks(); + + static sal_Int32 GetScrollRepeat(); + + static sal_Int32 GetButtonStartRepeat(); + + void SetButtonRepeat( sal_Int32 nRepeat ); + sal_Int32 GetButtonRepeat() const; + + static sal_Int32 GetActionDelay(); + + void SetMenuDelay( sal_Int32 nDelay ); + sal_Int32 GetMenuDelay() const; + + void SetFollow( MouseFollowFlags nFollow ); + MouseFollowFlags GetFollow() const; + + void SetMiddleButtonAction( MouseMiddleButtonAction nAction ); + MouseMiddleButtonAction GetMiddleButtonAction() const; + + void SetWheelBehavior( MouseWheelBehaviour nBehavior ); + MouseWheelBehaviour GetWheelBehavior() const; + + bool operator ==( const MouseSettings& rSet ) const; + bool operator !=( const MouseSettings& rSet ) const; +}; + +struct DialogStyle +{ + int content_area_border; + int button_spacing; + int action_area_border; + DialogStyle() + : content_area_border(2) + , button_spacing(6) + , action_area_border(5) + {} +}; + +enum class StyleSettingsOptions +{ + NONE = 0x0000, + Mono = 0x0001, + NoMnemonics = 0x0002, +}; +namespace o3tl +{ + template<> struct typed_flags<StyleSettingsOptions> : is_typed_flags<StyleSettingsOptions, 0x0003> {}; +} + +enum class DragFullOptions +{ + NONE = 0x0000, + WindowMove = 0x0001, + WindowSize = 0x0002, + Docking = 0x0010, + Split = 0x0020, + Scroll = 0x0040, + All = WindowMove | WindowSize | Docking | Split | Scroll, +}; +namespace o3tl +{ + template<> struct typed_flags<DragFullOptions> : is_typed_flags<DragFullOptions, 0x0073> {}; +} + +enum class SelectionOptions +{ + NONE = 0x0000, + ShowFirst = 0x0004, +}; +namespace o3tl +{ + template<> struct typed_flags<SelectionOptions> : is_typed_flags<SelectionOptions, 0x0004> {}; +} + +enum class DisplayOptions +{ + NONE = 0x0000, + AADisable = 0x0001, +}; +namespace o3tl +{ + template<> struct typed_flags<DisplayOptions> : is_typed_flags<DisplayOptions, 0x0001> {}; +} + +enum class ToolbarIconSize +{ + Unknown = 0, + Small = 1, // unused + Large = 2, + Size32 = 3, +}; + +#define STYLE_CURSOR_NOBLINKTIME SAL_MAX_UINT64 + +class VCL_DLLPUBLIC StyleSettings +{ + void CopyData(); + +private: + std::shared_ptr<ImplStyleData> mxData; + +public: + StyleSettings(); + + void Set3DColors( const Color& rColor ); + + void SetFaceColor( const Color& rColor ); + const Color& GetFaceColor() const; + + Color GetFaceGradientColor() const; + + Color GetSeparatorColor() const; + + void SetCheckedColor( const Color& rColor ); + void SetCheckedColorSpecialCase( ); + const Color& GetCheckedColor() const; + + void SetLightColor( const Color& rColor ); + const Color& GetLightColor() const; + + void SetLightBorderColor( const Color& rColor ); + const Color& GetLightBorderColor() const; + + void SetShadowColor( const Color& rColor ); + const Color& GetShadowColor() const; + + void SetDarkShadowColor( const Color& rColor ); + const Color& GetDarkShadowColor() const; + + void SetDefaultButtonTextColor( const Color& rColor ); + const Color& GetDefaultButtonTextColor() const; + + void SetButtonTextColor( const Color& rColor ); + const Color& GetButtonTextColor() const; + + void SetDefaultActionButtonTextColor( const Color& rColor ); + const Color& GetDefaultActionButtonTextColor() const; + + void SetActionButtonTextColor( const Color& rColor ); + const Color& GetActionButtonTextColor() const; + + void SetFlatButtonTextColor( const Color& rColor ); + const Color& GetFlatButtonTextColor() const; + + void SetDefaultButtonRolloverTextColor( const Color& rColor ); + const Color& GetDefaultButtonRolloverTextColor() const; + + void SetButtonRolloverTextColor( const Color& rColor ); + const Color& GetButtonRolloverTextColor() const; + + void SetDefaultActionButtonRolloverTextColor( const Color& rColor ); + const Color& GetDefaultActionButtonRolloverTextColor() const; + + void SetActionButtonRolloverTextColor( const Color& rColor ); + const Color& GetActionButtonRolloverTextColor() const; + + void SetFlatButtonRolloverTextColor( const Color& rColor ); + const Color& GetFlatButtonRolloverTextColor() const; + + void SetDefaultButtonPressedRolloverTextColor( const Color& rColor ); + const Color& GetDefaultButtonPressedRolloverTextColor() const; + + void SetButtonPressedRolloverTextColor( const Color& rColor ); + const Color& GetButtonPressedRolloverTextColor() const; + + void SetDefaultActionButtonPressedRolloverTextColor( const Color& rColor ); + const Color& GetDefaultActionButtonPressedRolloverTextColor() const; + + void SetActionButtonPressedRolloverTextColor( const Color& rColor ); + const Color& GetActionButtonPressedRolloverTextColor() const; + + void SetFlatButtonPressedRolloverTextColor( const Color& rColor ); + const Color& GetFlatButtonPressedRolloverTextColor() const; + + void SetRadioCheckTextColor( const Color& rColor ); + const Color& GetRadioCheckTextColor() const; + + void SetGroupTextColor( const Color& rColor ); + const Color& GetGroupTextColor() const; + + void SetLabelTextColor( const Color& rColor ); + const Color& GetLabelTextColor() const; + + void SetWindowColor( const Color& rColor ); + const Color& GetWindowColor() const; + + void SetWindowTextColor( const Color& rColor ); + const Color& GetWindowTextColor() const; + + void SetDialogColor( const Color& rColor ); + const Color& GetDialogColor() const; + + void SetDialogTextColor( const Color& rColor ); + const Color& GetDialogTextColor() const; + + void SetWorkspaceColor( const Color& rColor ); + const Color& GetWorkspaceColor() const; + + void SetFieldColor( const Color& rColor ); + const Color& GetFieldColor() const; + + void SetFieldTextColor( const Color& rColor ); + const Color& GetFieldTextColor() const; + + void SetFieldRolloverTextColor( const Color& rColor ); + const Color& GetFieldRolloverTextColor() const; + + void SetActiveColor( const Color& rColor ); + const Color& GetActiveColor() const; + + void SetActiveTextColor( const Color& rColor ); + const Color& GetActiveTextColor() const; + + void SetActiveBorderColor( const Color& rColor ); + const Color& GetActiveBorderColor() const; + + void SetDeactiveColor( const Color& rColor ); + const Color& GetDeactiveColor() const; + + void SetDeactiveTextColor( const Color& rColor ); + const Color& GetDeactiveTextColor() const; + + void SetDeactiveBorderColor( const Color& rColor ); + const Color& GetDeactiveBorderColor() const; + + void SetHighlightColor( const Color& rColor ); + const Color& GetHighlightColor() const; + + void SetHighlightTextColor( const Color& rColor ); + const Color& GetHighlightTextColor() const; + + void SetDisableColor( const Color& rColor ); + const Color& GetDisableColor() const; + + void SetWarningColor( const Color& rColor ); + const Color& GetWarningColor() const; + + void SetHelpColor( const Color& rColor ); + const Color& GetHelpColor() const; + + void SetHelpTextColor( const Color& rColor ); + const Color& GetHelpTextColor() const; + + void SetMenuColor( const Color& rColor ); + const Color& GetMenuColor() const; + + void SetMenuBarColor( const Color& rColor ); + const Color& GetMenuBarColor() const; + + void SetMenuBarRolloverColor( const Color& rColor ); + const Color& GetMenuBarRolloverColor() const; + + void SetMenuBorderColor( const Color& rColor ); + const Color& GetMenuBorderColor() const; + + void SetMenuTextColor( const Color& rColor ); + const Color& GetMenuTextColor() const; + + void SetMenuBarTextColor( const Color& rColor ); + const Color& GetMenuBarTextColor() const; + + void SetMenuBarRolloverTextColor( const Color& rColor ); + const Color& GetMenuBarRolloverTextColor() const; + + void SetMenuBarHighlightTextColor( const Color& rColor ); + const Color& GetMenuBarHighlightTextColor() const; + + void SetMenuHighlightColor( const Color& rColor ); + const Color& GetMenuHighlightColor() const; + + void SetMenuHighlightTextColor( const Color& rColor ); + const Color& GetMenuHighlightTextColor() const; + + void SetTabTextColor( const Color& rColor ); + const Color& GetTabTextColor() const; + + void SetTabRolloverTextColor( const Color& rColor ); + const Color& GetTabRolloverTextColor() const; + + void SetTabHighlightTextColor( const Color& rColor ); + const Color& GetTabHighlightTextColor() const; + + void SetToolTextColor( const Color& rColor ); + const Color& GetToolTextColor() const; + + void SetLinkColor( const Color& rColor ); + const Color& GetLinkColor() const; + + void SetVisitedLinkColor( const Color& rColor ); + const Color& GetVisitedLinkColor() const; + + void SetMonoColor( const Color& rColor ); + const Color& GetMonoColor() const; + + void SetActiveTabColor( const Color& rColor ); + const Color& GetActiveTabColor() const; + + void SetInactiveTabColor( const Color& rColor ); + const Color& GetInactiveTabColor() const; + + void SetAlternatingRowColor(const Color& rColor); + const Color& GetAlternatingRowColor() const; + + void SetHighContrastMode(bool bHighContrast ); + bool GetHighContrastMode() const; + + void SetUseSystemUIFonts( bool bUseSystemUIFonts ); + bool GetUseSystemUIFonts() const; + + void SetUseFontAAFromSystem(bool bUseFontAAFromSystem); + bool GetUseFontAAFromSystem() const; + + void SetUseFlatBorders( bool bUseFlatBorders ); + bool GetUseFlatBorders() const; + + void SetUseFlatMenus( bool bUseFlatMenus ); + bool GetUseFlatMenus() const; + + void SetUseImagesInMenus( TriState eUseImagesInMenus ); + bool GetUseImagesInMenus() const; + + void SetPreferredUseImagesInMenus( bool bPreferredUseImagesInMenus ); + bool GetPreferredUseImagesInMenus() const; + + void SetSkipDisabledInMenus( bool bSkipDisabledInMenus ); + bool GetSkipDisabledInMenus() const; + + void SetHideDisabledMenuItems( bool bHideDisabledMenuItems ); + bool GetHideDisabledMenuItems() const; + + void SetContextMenuShortcuts( TriState eContextMenuShortcuts ); + bool GetContextMenuShortcuts() const; + + void SetPreferredContextMenuShortcuts( bool bContextMenuShortcuts ); + bool GetPreferredContextMenuShortcuts() const; + + void SetPrimaryButtonWarpsSlider( bool bPrimaryButtonWarpsSlider ); + bool GetPrimaryButtonWarpsSlider() const; + + void SetAppFont( const vcl::Font& rFont ); + const vcl::Font& GetAppFont() const; + + void SetHelpFont( const vcl::Font& rFont ); + const vcl::Font& GetHelpFont() const; + + void SetTitleFont( const vcl::Font& rFont ); + const vcl::Font& GetTitleFont() const; + + void SetFloatTitleFont( const vcl::Font& rFont ); + const vcl::Font& GetFloatTitleFont() const; + + void SetMenuFont( const vcl::Font& rFont ); + const vcl::Font& GetMenuFont() const; + + void SetToolFont( const vcl::Font& rFont ); + const vcl::Font& GetToolFont() const; + + void SetGroupFont( const vcl::Font& rFont ); + const vcl::Font& GetGroupFont() const; + + void SetLabelFont( const vcl::Font& rFont ); + const vcl::Font& GetLabelFont() const; + + void SetRadioCheckFont( const vcl::Font& rFont ); + const vcl::Font& GetRadioCheckFont() const; + + void SetPushButtonFont( const vcl::Font& rFont ); + const vcl::Font& GetPushButtonFont() const; + + void SetFieldFont( const vcl::Font& rFont ); + const vcl::Font& GetFieldFont() const; + + void SetIconFont( const vcl::Font& rFont ); + const vcl::Font& GetIconFont() const; + + void SetTabFont( const vcl::Font& rFont ); + const vcl::Font& GetTabFont() const; + + static sal_Int32 GetBorderSize(); + + void SetTitleHeight( sal_Int32 nSize ); + sal_Int32 GetTitleHeight() const; + + void SetFloatTitleHeight( sal_Int32 nSize ); + sal_Int32 GetFloatTitleHeight() const; + + void SetScrollBarSize( sal_Int32 nSize ); + sal_Int32 GetScrollBarSize() const; + + void SetMinThumbSize( sal_Int32 nSize ); + sal_Int32 GetMinThumbSize() const; + + void SetSpinSize( sal_Int32 nSize ); + sal_Int32 GetSpinSize() const; + + static sal_Int32 GetSplitSize(); + + void SetCursorSize( sal_Int32 nSize ); + sal_Int32 GetCursorSize() const; + + void SetCursorBlinkTime( sal_uInt64 nBlinkTime ); + sal_uInt64 GetCursorBlinkTime() const; + + void SetDragFullOptions( DragFullOptions nOptions ); + DragFullOptions GetDragFullOptions() const; + + void SetSelectionOptions( SelectionOptions nOptions ); + SelectionOptions GetSelectionOptions() const; + + void SetDisplayOptions( DisplayOptions nOptions ); + DisplayOptions GetDisplayOptions() const; + + void SetAntialiasingMinPixelHeight( sal_Int32 nMinPixel ); + sal_Int32 GetAntialiasingMinPixelHeight() const; + + void SetOptions( StyleSettingsOptions nOptions ); + StyleSettingsOptions GetOptions() const; + + void SetAutoMnemonic( bool bAutoMnemonic ); + bool GetAutoMnemonic() const; + + static bool GetDockingFloatsSupported(); + + void SetFontColor( const Color& rColor ); + const Color& GetFontColor() const; + + void SetToolbarIconSize( ToolbarIconSize nSize ); + ToolbarIconSize GetToolbarIconSize() const; + Size GetToolbarIconSizePixel() const; + + /** Set the icon theme to use. */ + void SetIconTheme(const OUString&); + + /** Determine which icon theme should be used. + * + * This might not be the same as the one which has been set with SetIconTheme(), + * e.g., if high contrast mode is enabled. + * + * (for the detailed logic @see vcl::IconThemeSelector) + */ + OUString DetermineIconTheme() const; + + /** Obtain the list of icon themes which were found in the config folder + * @see vcl::IconThemeScanner for more details. + */ + std::vector<vcl::IconThemeInfo> const & GetInstalledIconThemes() const; + + /** Obtain the name of the icon theme which will be chosen automatically for the desktop environment. + * This method will only return icon themes which were actually found on the system. + */ + OUString GetAutomaticallyChosenIconTheme() const; + + /** Set a preferred icon theme. + * This theme will be preferred in GetAutomaticallyChosenIconTheme() + */ + void SetPreferredIconTheme(const OUString&, bool bDarkIconTheme = false); + + const DialogStyle& GetDialogStyle() const; + + BitmapEx const & GetPersonaHeader() const; + + BitmapEx const & GetPersonaFooter() const; + + const std::optional<Color>& GetPersonaMenuBarTextColor() const; + + // global switch to allow EdgeBlenging; currently possible for ValueSet and ListBox + // when activated there using Get/SetEdgeBlending; default is true + void SetEdgeBlending(sal_uInt16 nCount); + sal_uInt16 GetEdgeBlending() const; + + // TopLeft (default Color(0xC0, 0xC0, 0xC0)) and BottomRight (default Color(0x40, 0x40, 0x40)) + // default colors for EdgeBlending + const Color& GetEdgeBlendingTopLeftColor() const; + const Color& GetEdgeBlendingBottomRightColor() const; + + // maximum line count for ListBox control; to use this, call AdaptDropDownLineCountToMaximum() at the + // ListBox after it's ItemCount has changed/got filled. Default is 25. If more Items exist, a scrollbar + // will be used + void SetListBoxMaximumLineCount(sal_uInt16 nCount); + sal_uInt16 GetListBoxMaximumLineCount() const; + + // maximum column count for the ColorValueSet control. Default is 12 and this is optimized for the + // color scheme which has 12-color aligned layout for the part taken over from Symphony. Do + // only change this if you know what you are doing. + void SetColorValueSetColumnCount(sal_uInt16 nCount); + sal_uInt16 GetColorValueSetColumnCount() const; + + void SetListBoxPreviewDefaultLogicSize(Size const & rSize); + const Size& GetListBoxPreviewDefaultPixelSize() const; + + // the default LineWidth for ListBox UI previews (LineStyle, LineDash, LineStartEnd). Default is 1. + static sal_uInt16 GetListBoxPreviewDefaultLineWidth(); + + // defines if previews which contain potentially transparent objects (e.g. the dash/line/LineStartEnd previews and others) + // use the default transparent visualization background (checkered background) as it has got standard in graphic programs nowadays + void SetPreviewUsesCheckeredBackground(bool bNew); + bool GetPreviewUsesCheckeredBackground() const; + + void SetStandardStyles(); + + bool operator ==( const StyleSettings& rSet ) const; + bool operator !=( const StyleSettings& rSet ) const; + + // Batch setters used by various backends + void BatchSetBackgrounds( const Color &aBackColor, + bool bCheckedColorSpecialCase = true ); + void BatchSetFonts( const vcl::Font& aAppFont, + const vcl::Font& aLabelFont ); +}; + + +class VCL_DLLPUBLIC MiscSettings +{ + std::shared_ptr<ImplMiscData> mxData; + +public: + MiscSettings(); + +#ifdef _WIN32 + void SetEnableATToolSupport( bool bEnable ); +#endif + bool GetEnableATToolSupport() const; + bool GetDisablePrinting() const; + void SetEnableLocalizedDecimalSep( bool bEnable ); + bool GetEnableLocalizedDecimalSep() const; + + bool operator ==( const MiscSettings& rSet ) const; + bool operator !=( const MiscSettings& rSet ) const; +}; + + +class VCL_DLLPUBLIC HelpSettings +{ + std::shared_ptr<ImplHelpData> mxData; + +public: + HelpSettings(); + + static sal_Int32 GetTipDelay(); + void SetTipTimeout( sal_Int32 nTipTimeout ); + sal_Int32 GetTipTimeout() const; + static sal_Int32 GetBalloonDelay(); + + bool operator ==( const HelpSettings& rSet ) const; + bool operator !=( const HelpSettings& rSet ) const; +}; + + +enum class AllSettingsFlags { + NONE = 0x0000, + MOUSE = 0x0001, + STYLE = 0x0002, + MISC = 0x0004, + LOCALE = 0x0020, +}; +namespace o3tl +{ + template<> struct typed_flags<AllSettingsFlags> : is_typed_flags<AllSettingsFlags, 0x0027> {}; +} + +class VCL_DLLPUBLIC AllSettings +{ +private: + void CopyData(); + + std::shared_ptr<ImplAllSettingsData> mxData; + +public: + AllSettings(); + + void SetMouseSettings( const MouseSettings& rSet ); + const MouseSettings& GetMouseSettings() const; + + void SetStyleSettings( const StyleSettings& rSet ); + const StyleSettings& GetStyleSettings() const; + + void SetMiscSettings( const MiscSettings& rSet ); + const MiscSettings& GetMiscSettings() const; + + IF_MERGELIBS(SAL_DLLPRIVATE) + void SetHelpSettings( const HelpSettings& rSet ); + IF_MERGELIBS(SAL_DLLPRIVATE) + const HelpSettings& GetHelpSettings() const; + + void SetLanguageTag(const OUString& rLanguage, bool bCanonicalize); + void SetLanguageTag( const LanguageTag& rLanguageTag ); + const LanguageTag& GetLanguageTag() const; + const LanguageTag& GetUILanguageTag() const; + static bool GetLayoutRTL(); // returns true if UI language requires right-to-left Text Layout + static bool GetMathLayoutRTL(); // returns true if UI language requires right-to-left Math Layout + static OUString GetUIRootDir(); + const LocaleDataWrapper& GetLocaleDataWrapper() const; + const LocaleDataWrapper& GetUILocaleDataWrapper() const; + IF_MERGELIBS(SAL_DLLPRIVATE) + const LocaleDataWrapper& GetNeutralLocaleDataWrapper() const; + const vcl::I18nHelper& GetLocaleI18nHelper() const; + const vcl::I18nHelper& GetUILocaleI18nHelper() const; + + SAL_DLLPRIVATE static AllSettingsFlags GetWindowUpdate() + { return AllSettingsFlags::MOUSE | AllSettingsFlags::STYLE | AllSettingsFlags::MISC | AllSettingsFlags::LOCALE; } + + AllSettingsFlags Update( AllSettingsFlags nFlags, const AllSettings& rSettings ); + SAL_DLLPRIVATE AllSettingsFlags GetChangeFlags( const AllSettings& rSettings ) const; + + bool operator ==( const AllSettings& rSet ) const; + bool operator !=( const AllSettings& rSet ) const; + SAL_DLLPRIVATE static void LocaleSettingsChanged( ConfigurationHints nHint ); + SAL_DLLPRIVATE SvtSysLocale& GetSysLocale(); +}; + +#endif // INCLUDED_VCL_SETTINGS_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/skia/SkiaHelper.hxx b/include/vcl/skia/SkiaHelper.hxx new file mode 100644 index 000000000..128c758fa --- /dev/null +++ b/include/vcl/skia/SkiaHelper.hxx @@ -0,0 +1,42 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_SKIA_SKIAHELPER_HXX +#define INCLUDED_VCL_SKIA_SKIAHELPER_HXX + +#include <vcl/dllapi.h> + +#include <config_features.h> + +namespace SkiaHelper +{ +VCL_DLLPUBLIC bool isVCLSkiaEnabled(); + +#if HAVE_FEATURE_SKIA + +// Which Skia backend to use. +enum RenderMethod +{ + RenderRaster, + RenderVulkan, + RenderMetal +}; + +VCL_DLLPUBLIC RenderMethod renderMethodToUse(); + +// Clean up before exit. +VCL_DLLPUBLIC void cleanup(); + +#endif // HAVE_FEATURE_SKIA + +} // namespace + +#endif // INCLUDED_VCL_SKIA_SKIAHELPER_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/sound.hxx b/include/vcl/sound.hxx new file mode 100644 index 000000000..77398a3ef --- /dev/null +++ b/include/vcl/sound.hxx @@ -0,0 +1,30 @@ +/* -*- 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 . + */ + +#pragma once + +#include <vcl/dllapi.h> + +class VCL_DLLPUBLIC Sound +{ +public: + static void Beep(); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/specialchars.hxx b/include/vcl/specialchars.hxx new file mode 100644 index 000000000..5a7fe8cd3 --- /dev/null +++ b/include/vcl/specialchars.hxx @@ -0,0 +1,46 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_SPECIAL_CHARS_HXX +#define INCLUDED_VCL_SPECIAL_CHARS_HXX + +#include <vcl/dllapi.h> +#include <rtl/ustring.hxx> + +namespace vcl +{ +class Font; +} + +namespace weld +{ +class Widget; +} + +typedef OUString (*FncGetSpecialChars)(weld::Widget* pWin, const vcl::Font& rFont); + +namespace vcl +{ +void VCL_DLLPUBLIC SetGetSpecialCharsFunction(FncGetSpecialChars fn); +FncGetSpecialChars VCL_DLLPUBLIC GetGetSpecialCharsFunction(); +}; + +#endif // INCLUDED_VCL_SPECIAL_CHARS_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/split.hxx b/include/vcl/split.hxx new file mode 100644 index 000000000..4d8624c49 --- /dev/null +++ b/include/vcl/split.hxx @@ -0,0 +1,105 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_SPLIT_HXX +#define INCLUDED_VCL_SPLIT_HXX + +#include <vcl/dllapi.h> +#include <vcl/keycod.hxx> +#include <vcl/window.hxx> + +#define SPLITTER_DEFAULTSTEPSIZE 0xFFFF + +class VCL_DLLPUBLIC Splitter : public vcl::Window +{ +private: + VclPtr<vcl::Window> mpRefWin; + tools::Long mnSplitPos; + tools::Long mnLastSplitPos; + tools::Long mnStartSplitPos; + Point maDragPos; + tools::Rectangle maDragRect; + bool mbHorzSplit; + bool mbDragFull; + bool mbKbdSplitting; + bool mbInKeyEvent; + tools::Long mnKeyboardStepSize; + Link<Splitter*,void> maStartSplitHdl; + Link<Splitter*,void> maSplitHdl; + Link<Splitter*,void> maEndSplitHdl; + + SAL_DLLPRIVATE void ImplDrawSplitter(); + SAL_DLLPRIVATE void ImplSplitMousePos( Point& rPos ); + SAL_DLLPRIVATE void ImplStartKbdSplitting(); + SAL_DLLPRIVATE void ImplKbdTracking( vcl::KeyCode aKeyCode ); + SAL_DLLPRIVATE bool ImplSplitterActive(); + SAL_DLLPRIVATE Splitter* ImplFindSibling(); + SAL_DLLPRIVATE void ImplRestoreSplitter(); + SAL_DLLPRIVATE void ImplInitHorVer(bool bNew); + + Splitter (const Splitter &) = delete; + Splitter& operator= (const Splitter &) = delete; + +protected: + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nWinStyle ); + +public: + explicit Splitter( vcl::Window* pParent, WinBits nStyle = WB_VSCROLL ); + virtual ~Splitter() override; + virtual void dispose() override; + + void StartSplit(); + void EndSplit(); + void Split(); + + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void Tracking( const TrackingEvent& rTEvt ) override; + + virtual void GetFocus() override; + virtual void LoseFocus() override; + virtual void KeyInput( const KeyEvent& rKEvt ) override; + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rPaintRect ) override; + virtual Size GetOptimalSize() const override; + + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + void StartDrag(); + + void SetDragRectPixel( const tools::Rectangle& rDragRect, + vcl::Window* pRefWin = nullptr ); + + void SetSplitPosPixel( tools::Long nPos ); + tools::Long GetSplitPosPixel() const { return mnSplitPos; } + + bool IsHorizontal() const { return mbHorzSplit; } + void SetHorizontal(bool bNew); + + // set the stepsize of the splitter for cursor movement + // the default is 10% of the reference window's width/height + void SetKeyboardStepSize( tools::Long nStepSize ); + + void SetStartSplitHdl( const Link<Splitter*,void>& rLink ) { maStartSplitHdl = rLink; } + void SetSplitHdl( const Link<Splitter*,void>& rLink ) { maSplitHdl = rLink; } + void SetEndSplitHdl( const Link<Splitter*,void>& rLink ) { maEndSplitHdl = rLink; } +}; + +#endif // INCLUDED_VCL_SPLIT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/splitwin.hxx b/include/vcl/splitwin.hxx new file mode 100644 index 000000000..903bd56e7 --- /dev/null +++ b/include/vcl/splitwin.hxx @@ -0,0 +1,187 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_SPLITWIN_HXX +#define INCLUDED_VCL_SPLITWIN_HXX + +#include <vcl/dllapi.h> +#include <vcl/dockwin.hxx> +#include <o3tl/typed_flags_set.hxx> + +class ImplSplitSet; + +enum class SplitWindowItemFlags +{ + NONE = 0x0000, + Fixed = 0x0001, + RelativeSize = 0x0002, + PercentSize = 0x0004, + ColSet = 0x0008, +}; +namespace o3tl +{ + template<> struct typed_flags<SplitWindowItemFlags> : is_typed_flags<SplitWindowItemFlags, 0x0f> {}; +} + +#define SPLITWINDOW_APPEND (sal_uInt16(0xFFFF)) +#define SPLITWINDOW_ITEM_NOTFOUND (sal_uInt16(0xFFFF)) + +#define SPLITWIN_SPLITSIZE 4 +#define SPLITWIN_SPLITSIZEEXLN 7 + +class VCL_DLLPUBLIC SplitWindow : public DockingWindow +{ +private: + std::unique_ptr<ImplSplitSet> mpMainSet; + ImplSplitSet* mpBaseSet; + ImplSplitSet* mpSplitSet; + std::unique_ptr<tools::Long[]> mpLastSizes; + tools::Rectangle maDragRect; + tools::Long mnDX; + tools::Long mnDY; + tools::Long mnLeftBorder; + tools::Long mnTopBorder; + tools::Long mnRightBorder; + tools::Long mnBottomBorder; + tools::Long mnMaxSize; + tools::Long mnMouseOff; + tools::Long mnMStartPos; + tools::Long mnMSplitPos; + WinBits mnWinStyle; + WindowAlign meAlign; + sal_uInt16 mnSplitTest; + sal_uInt16 mnSplitPos; + sal_uInt16 mnMouseModifier; + bool mbDragFull:1, + mbHorz:1, + mbBottomRight:1, + mbCalc:1, + mbRecalc:1, + mbInvalidate:1, + mbFadeIn:1, + mbFadeOut:1, + mbFadeInDown:1, + mbFadeOutDown:1, + mbFadeInPressed:1, + mbFadeOutPressed:1, + mbFadeNoButtonMode:1; + Link<SplitWindow*,void> maSplitHdl; + + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + SAL_DLLPRIVATE void ImplInitSettings(); + SAL_DLLPRIVATE void ImplCalcLayout(); + SAL_DLLPRIVATE void ImplUpdate(); + SAL_DLLPRIVATE void ImplSetWindowSize( tools::Long nDelta ); + SAL_DLLPRIVATE void ImplSplitMousePos( Point& rMousePos ); + SAL_DLLPRIVATE void ImplGetButtonRect( tools::Rectangle& rRect, bool bTest ) const; + SAL_DLLPRIVATE void ImplGetFadeInRect( tools::Rectangle& rRect, bool bTest = false ) const; + SAL_DLLPRIVATE void ImplGetFadeOutRect( tools::Rectangle& rRect ) const; + SAL_DLLPRIVATE void ImplDrawFadeIn(vcl::RenderContext& rRenderContext); + SAL_DLLPRIVATE void ImplDrawFadeOut(vcl::RenderContext& rRenderContext); + SAL_DLLPRIVATE void ImplNewAlign(); + SAL_DLLPRIVATE void ImplDrawGrip(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect, bool bHorz, bool bLeft); + SAL_DLLPRIVATE void ImplStartSplit( const MouseEvent& rMEvt ); + + SAL_DLLPRIVATE void ImplDrawBorder(vcl::RenderContext& rRenderContext); + SAL_DLLPRIVATE void ImplDrawBorderLine(vcl::RenderContext& rRenderContext); + static SAL_DLLPRIVATE void ImplCalcSet2( SplitWindow* pWindow, ImplSplitSet* pSet, bool bHide, + bool bRows ); + static SAL_DLLPRIVATE sal_uInt16 ImplTestSplit( ImplSplitSet* pSet, const Point& rPos, + tools::Long& rMouseOff, ImplSplitSet** ppFoundSet, sal_uInt16& rFoundPos, + bool bRows ); + static SAL_DLLPRIVATE sal_uInt16 ImplTestSplit( const SplitWindow* pWindow, const Point& rPos, + tools::Long& rMouseOff, ImplSplitSet** ppFoundSet, sal_uInt16& rFoundPos ); + SAL_DLLPRIVATE void ImplDrawSplitTracking(const Point& rPos); + + SplitWindow (const SplitWindow &) = delete; + SplitWindow & operator= (const SplitWindow &) = delete; +public: + SplitWindow( vcl::Window* pParent, WinBits nStyle = 0 ); + virtual ~SplitWindow() override; + virtual void dispose() override; + + virtual void StartSplit(); + virtual void Split(); + virtual void SplitResize(); + virtual void FadeIn(); + virtual void FadeOut(); + + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void MouseMove( const MouseEvent& rMEvt ) override; + virtual void Tracking( const TrackingEvent& rTEvt ) override; + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Resize() override; + virtual void RequestHelp( const HelpEvent& rHEvt ) override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + + void InsertItem( sal_uInt16 nId, vcl::Window* pWindow, tools::Long nSize, + sal_uInt16 nPos, sal_uInt16 nIntoSetId, + SplitWindowItemFlags nBits ); + void InsertItem( sal_uInt16 nId, tools::Long nSize, + sal_uInt16 nPos, sal_uInt16 nIntoSetId, + SplitWindowItemFlags nBits ); + void RemoveItem( sal_uInt16 nId ); + + void SplitItem( sal_uInt16 nId, tools::Long nNewSize, + bool bPropSmall, + bool bPropGreat ); + void SetItemSize( sal_uInt16 nId, tools::Long nNewSize ); + tools::Long GetItemSize( sal_uInt16 nId ) const; + /** Set a range that limits the (variable part of the) size with an + upper and a lower bound (both are valid values themselves.) + @param nId + Id of the item for which the size limits are set. + @param rRange + Values of -1 define missing bounds, thus setting a range (-1,-1) + (the default) removes the size limit. + */ + void SetItemSizeRange (sal_uInt16 nId, const Range& rRange); + /** Return the current size limits for the specified item. + */ + tools::Long GetItemSize( sal_uInt16 nId, SplitWindowItemFlags nBits ) const; + sal_uInt16 GetSet( sal_uInt16 nId ) const; + sal_uInt16 GetItemId( vcl::Window* pWindow ) const; + sal_uInt16 GetItemId( const Point& rPos ) const; + sal_uInt16 GetItemPos( sal_uInt16 nId, sal_uInt16 nSetId = 0 ) const; + sal_uInt16 GetItemId( sal_uInt16 nPos ) const; + sal_uInt16 GetItemCount( sal_uInt16 nSetId = 0 ) const; + bool IsItemValid( sal_uInt16 nId ) const; + + void SetAlign( WindowAlign eNewAlign ); + WindowAlign GetAlign() const { return meAlign; } + bool IsHorizontal() const { return mbHorz; } + + void SetMaxSizePixel( tools::Long nNewMaxSize ) { mnMaxSize = nNewMaxSize; } + + Size CalcLayoutSizePixel( const Size& aNewSize ); + + void ShowFadeInHideButton(); + void ShowFadeOutButton(); + tools::Long GetFadeInSize() const; + bool IsFadeNoButtonMode() const { return mbFadeNoButtonMode; } + + void SetSplitHdl( const Link<SplitWindow*,void>& rLink ) { maSplitHdl = rLink; } +}; + +#endif // INCLUDED_VCL_SPLITWIN_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/status.hxx b/include/vcl/status.hxx new file mode 100644 index 000000000..91a6ed643 --- /dev/null +++ b/include/vcl/status.hxx @@ -0,0 +1,193 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_STATUS_HXX +#define INCLUDED_VCL_STATUS_HXX + +#include <tools/solar.h> +#include <vcl/dllapi.h> +#include <vcl/window.hxx> +#include <o3tl/typed_flags_set.hxx> +#include <memory> +#include <vector> + +class DataChangedEvent; +class HelpEvent; +class MouseEvent; +class UserDrawEvent; +struct ImplStatusItem; + +void DrawProgress(vcl::Window* pWindow, vcl::RenderContext& rRenderContext, const Point& rPos, + tools::Long nOffset, tools::Long nPrgsWidth, tools::Long nPrgsHeight, + sal_uInt16 nPercent1, sal_uInt16 nPercent2, sal_uInt16 nPercentCount, + const tools::Rectangle& rFramePosSize); + + +enum class StatusBarItemBits { + NONE = 0x0000, + Left = 0x0001, + Center = 0x0002, + Right = 0x0004, + In = 0x0008, + Out = 0x0010, + Flat = 0x0020, + AutoSize = 0x0040, + UserDraw = 0x0080, + Mandatory = 0x0100, +}; +namespace o3tl +{ + template<> struct typed_flags<StatusBarItemBits> : is_typed_flags<StatusBarItemBits, 0x01ff> {}; +} + +#define STATUSBAR_APPEND (sal_uInt16(0xFFFF)) +#define STATUSBAR_ITEM_NOTFOUND (sal_uInt16(0xFFFF)) +#define STATUSBAR_OFFSET (tools::Long(5)) + + +class VCL_DLLPUBLIC StatusBar : public vcl::Window +{ + class SAL_DLLPRIVATE ImplData; +private: + std::vector<std::unique_ptr<ImplStatusItem>> mvItemList; + std::unique_ptr<ImplData> mpImplData; + OUString maPrgsTxt; + Point maPrgsTxtPos; + tools::Rectangle maPrgsFrameRect; + tools::Long mnPrgsSize; + tools::Long mnItemsWidth; + tools::Long mnDX; + tools::Long mnDY; + tools::Long mnCalcHeight; + tools::Long mnTextY; + sal_uInt16 mnCurItemId; + sal_uInt16 mnPercent; + sal_uInt16 mnPercentCount; + sal_uInt32 mnLastProgressPaint_ms; + bool mbFormat; + bool mbProgressMode; + bool mbInUserDraw; + bool mbAdjustHiDPI; + Link<StatusBar*,void> maClickHdl; + Link<StatusBar*,void> maDoubleClickHdl; + + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + SAL_DLLPRIVATE void ImplInitSettings(); + SAL_DLLPRIVATE void ImplFormat(); + SAL_DLLPRIVATE bool ImplIsItemUpdate() const; + + SAL_DLLPRIVATE void ImplDrawText(vcl::RenderContext& rRenderContext); + SAL_DLLPRIVATE void ImplDrawItem(vcl::RenderContext& rRenderContext, bool bOffScreen, + sal_uInt16 nPos); + SAL_DLLPRIVATE void ImplDrawProgress(vcl::RenderContext& rRenderContext, sal_uInt16 nNewPerc); + SAL_DLLPRIVATE void ImplCalcProgressRect(); + SAL_DLLPRIVATE tools::Rectangle ImplGetItemRectPos( sal_uInt16 nPos ) const; + SAL_DLLPRIVATE sal_uInt16 ImplGetFirstVisiblePos() const; + +protected: + virtual void ApplySettings(vcl::RenderContext& rRenderContext) override; + +public: + StatusBar( vcl::Window* pParent, + WinBits nWinStyle = WB_BORDER | WB_RIGHT ); + virtual ~StatusBar() override; + virtual void dispose() override; + + void AdjustItemWidthsForHiDPI(); + + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Resize() override; + virtual void RequestHelp( const HelpEvent& rHEvt ) override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + void Click(); + void DoubleClick(); + virtual void UserDraw( const UserDrawEvent& rUDEvt ); + + void InsertItem( sal_uInt16 nItemId, sal_uLong nWidth, + StatusBarItemBits nBits = StatusBarItemBits::Center | StatusBarItemBits::In, + tools::Long nOffset = STATUSBAR_OFFSET, + sal_uInt16 nPos = STATUSBAR_APPEND ); + void RemoveItem( sal_uInt16 nItemId ); + + void ShowItem( sal_uInt16 nItemId ); + void HideItem( sal_uInt16 nItemId ); + bool IsItemVisible( sal_uInt16 nItemId ) const; + + void RedrawItem( sal_uInt16 nItemId ); + + void Clear(); + + sal_uInt16 GetItemCount() const; + sal_uInt16 GetItemId( sal_uInt16 nPos ) const; + sal_uInt16 GetItemId( const Point& rPos ) const; + sal_uInt16 GetItemPos( sal_uInt16 nItemId ) const; + tools::Rectangle GetItemRect( sal_uInt16 nItemId ) const; + Point GetItemTextPos( sal_uInt16 nItemId ) const; + sal_uInt16 GetCurItemId() const { return mnCurItemId; } + + sal_uLong GetItemWidth( sal_uInt16 nItemId ) const; + StatusBarItemBits GetItemBits( sal_uInt16 nItemId ) const; + + tools::Long GetItemOffset( sal_uInt16 nItemId ) const; + + /// @param nCharsWidth, if not -1, overrides the normal width calculation + void SetItemText( sal_uInt16 nItemId, const OUString& rText, int nCharsWidth = -1 ); + const OUString& GetItemText( sal_uInt16 nItemId ) const; + + void SetItemData( sal_uInt16 nItemId, void* pNewData ); + void* GetItemData( sal_uInt16 nItemId ) const; + + void SetItemCommand( sal_uInt16 nItemId, const OUString& rCommand ); + OUString GetItemCommand( sal_uInt16 nItemId ); + + void SetHelpText( sal_uInt16 nItemId, const OUString& rText ); + const OUString& GetHelpText( sal_uInt16 nItemId ) const; + + using Window::SetQuickHelpText; + void SetQuickHelpText( sal_uInt16 nItemId, const OUString& rText ); + using Window::GetQuickHelpText; + const OUString& GetQuickHelpText( sal_uInt16 nItemId ) const; + + void SetHelpId( sal_uInt16 nItemId, const OString& rHelpId ); + + void StartProgressMode( const OUString& rText ); + void SetProgressValue( sal_uInt16 nPercent ); + void EndProgressMode(); + bool IsProgressMode() const { return mbProgressMode; } + + void SetText( const OUString& rText ) override; + + Size CalcWindowSizePixel() const; + + void SetClickHdl( const Link<StatusBar*,void>& rLink ) { maClickHdl = rLink; } + void SetDoubleClickHdl( const Link<StatusBar*,void>& rLink ) { maDoubleClickHdl = rLink; } + + using Window::SetAccessibleName; + void SetAccessibleName( sal_uInt16 nItemId, const OUString& rName ); + using Window::GetAccessibleName; + const OUString& GetAccessibleName( sal_uInt16 nItemId ) const; +}; + +#endif // INCLUDED_VCL_STATUS_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/stdtext.hxx b/include/vcl/stdtext.hxx new file mode 100644 index 000000000..c77e5ebfc --- /dev/null +++ b/include/vcl/stdtext.hxx @@ -0,0 +1,53 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_STDTEXT_HXX +#define INCLUDED_VCL_STDTEXT_HXX + +#include <sal/config.h> + +#include <string_view> + +#include <rtl/ustring.hxx> +#include <tools/wintypes.hxx> +#include <vcl/dllapi.h> + +class Image; +namespace weld { class Widget; } + +void VCL_DLLPUBLIC ShowServiceNotAvailableError(weld::Widget* pParent, std::u16string_view rServiceName, bool bError); + +OUString VCL_DLLPUBLIC GetStandardText(StandardButtonType eButton); + +VCL_DLLPUBLIC Image const & GetStandardInfoBoxImage(); +VCL_DLLPUBLIC OUString GetStandardInfoBoxText(); + +VCL_DLLPUBLIC Image const & GetStandardWarningBoxImage(); +VCL_DLLPUBLIC OUString GetStandardWarningBoxText(); + +VCL_DLLPUBLIC Image const & GetStandardErrorBoxImage(); +VCL_DLLPUBLIC OUString GetStandardErrorBoxText(); + +VCL_DLLPUBLIC Image const & GetStandardQueryBoxImage(); +VCL_DLLPUBLIC OUString GetStandardQueryBoxText(); + + +#endif // INCLUDED_VCL_STDTEXT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/svapp.hxx b/include/vcl/svapp.hxx new file mode 100644 index 000000000..22164ed78 --- /dev/null +++ b/include/vcl/svapp.hxx @@ -0,0 +1,1482 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_SVAPP_HXX +#define INCLUDED_VCL_SVAPP_HXX + +#include <sal/config.h> +#include <sal/types.h> + +#include <cassert> +#include <vector> + +#include <comphelper/solarmutex.hxx> +#include <LibreOfficeKit/LibreOfficeKitTypes.h> +#include <osl/mutex.hxx> +#include <rtl/ustring.hxx> +#include <osl/thread.h> +#include <tools/gen.hxx> +#include <tools/link.hxx> +#include <vcl/dllapi.h> +#include <vcl/IDialogRenderable.hxx> +#include <vcl/inputtypes.hxx> +#include <vcl/exceptiontypes.hxx> +#include <vcl/vclevent.hxx> +#include <vcl/vclenum.hxx> +#include <i18nlangtag/lang.h> +#include <o3tl/typed_flags_set.hxx> +#include <com/sun/star/uno/Reference.h> + + +class BitmapEx; +namespace weld +{ + class Builder; + class MessageDialog; + class Widget; + class Window; +} +class LocaleDataWrapper; +class AllSettings; +class DataChangedEvent; +class Accelerator; +class Help; +class OutputDevice; +namespace vcl { class Window; } +namespace vcl { class KeyCode; } +class NotifyEvent; +class KeyEvent; +class MouseEvent; +class GestureEvent; +struct ImplSVEvent; +struct ConvertData; + +namespace com::sun::star::uno { + class XComponentContext; +} +namespace com::sun::star::ui::dialogs { + class XFilePicker2; + class XFolderPicker2; +} +namespace com::sun::star::awt { + class XToolkit; + class XDisplayConnection; + class XWindow; +} + +// helper needed by SalLayout implementations as well as svx/source/dialog/svxbmpnumbalueset.cxx +VCL_DLLPUBLIC sal_UCS4 GetMirroredChar( sal_UCS4 ); +VCL_DLLPUBLIC sal_UCS4 GetLocalizedChar( sal_UCS4, LanguageType ); + +enum class SystemWindowFlags { + NOAUTOMODE = 0x0001, + DIALOG = 0x0002 +}; +namespace o3tl +{ + template<> struct typed_flags<SystemWindowFlags> : is_typed_flags<SystemWindowFlags, 0x03> {}; +} + +typedef long (*VCLEventHookProc)( NotifyEvent& rEvt, void* pData ); + +/** An application can be notified of a number of different events: + - Type::Accept - listen for connection to the application (a connection + string is passed via the event) + - Type::Unaccept - stops listening for a connection to the app (determined by + a connection string passed via the event) + - Type::Appear - brings the app to the front (i.e. makes it "appear") + - Type::Version - display the app version + - Type::Help - opens a help topic (help topic passed as string) + - Type::OpenHELP_URL - opens a help URL (URL passed as a string) + - Type::ShowDialog - shows a dialog (dialog passed as a string) + - Type::Open - opens a document or group of documents (documents passed + as an array of strings) + - Type::Print - print a document or group of documents (documents passed + as an array of strings + - Type::PrivateDoShutdown - shutdown the app +*/ + +class VCL_DLLPUBLIC ApplicationEvent +{ +public: + enum class Type { + Accept, ///< Listen for connections + Appear, ///< Make application appear + Open, ///< Open a document + OpenHelpUrl, ///< Open a help URL + Print, ///< Print document + PrivateDoShutdown, ///< Shutdown application + QuickStart, ///< Start QuickStart + ShowDialog, ///< Show a dialog + Unaccept ///< Stop listening for connections + }; + + /** Explicit constructor for ApplicationEvent. + + @attention Type::Appear, Type::PrivateDoShutdown and + Type::QuickStart are the \em only events that don't need to include + a data string with the event. No other events should use this + constructor! + */ + explicit ApplicationEvent(Type type): aEvent(type) + { + assert(type == Type::Appear || type == Type::PrivateDoShutdown || type == Type::QuickStart); + } + + /** Constructor for ApplicationEvent, accepts a string for the data + associated with the event. + + @attention Type::Accept, Type::OpenHelpUrl, Type::ShowDialog + and Type::Unaccept are the \em only events that accept a single + string as event data. No other events should use this constructor! + */ + ApplicationEvent(Type type, OUString const & data): aEvent(type) + { + assert( + type == Type::Accept || type == Type::OpenHelpUrl + || type == Type::ShowDialog || type == Type::Unaccept); + aData.push_back(data); + } + + /** Constructor for ApplicationEvent, accepts an array of strings for + the data associated with the event. + + @attention Type::Open and Type::Print can apply to multiple documents, + and are the \em only events that accept an array of strings. No other + events should use this constructor. + */ + ApplicationEvent(Type type, std::vector<OUString>&& data): + aEvent(type), aData(std::move(data)) + { + assert(type == Type::Open || type == Type::Print); + } + + /** Get the type of event. + + @returns The type of event. + */ + Type GetEvent() const + { + return aEvent; + } + + /** Gets the application event's data string. + + @attention The \em only events that need a single string Type::Accept, + Type::OpenHelpUrl, Type::ShowDialog and Type::Unaccept + + @returns The event's data string. + */ + OUString const & GetStringData() const + { + assert( + aEvent == Type::Accept + || aEvent == Type::OpenHelpUrl || aEvent == Type::ShowDialog + || aEvent == Type::Unaccept); + assert(aData.size() == 1); + return aData[0]; + } + + /** Gets the event's array of strings. + + @attention The \em only events that need an array of strings + are Type::Open and Type::Print. + */ + std::vector<OUString> const & GetStringsData() const + { + assert(aEvent == Type::Open || aEvent == Type::Print); + return aData; + } + +private: + Type aEvent; + std::vector<OUString> aData; +}; + +enum class DialogCancelMode { + Off, ///< do not automatically cancel dialogs + Silent, ///< silently cancel any dialogs + LOKSilent, ///< silently cancel any dialogs (LOK case) + Fatal ///< cancel any dialogs by std::abort +}; + +/** + @brief Base class used mainly for the LibreOffice Desktop class. + + The Application class is a base class mainly used by the Desktop + class. It is really meant to be subclassed, and the Main() function + should be overridden. Many of the ImplSVData members should be + moved to this class. + + The reason Application exists is because the VCL used to be a + standalone framework, long since abandoned by anything other than + our application. + + @see Desktop, ImplSVData + */ +class VCL_DLLPUBLIC Application : public vcl::ILibreOfficeKitNotifier +{ +public: + /** @name Initialization + The following functions perform initialization and deinitialization + of the application. + */ + ///@{ + + /** Default constructor for Application class. + + Initializes the LibreOffice global instance data structure if needed, + and then sets itself to be the Application class. Also initializes any + platform specific data structures. + + @attention The initialization of the application itself is done in Init() + */ + Application(); + + /** Virtual destructor for Application class. + + Deinitializes the LibreOffice global instance data structure, then + deinitializes any platform specific data structures. + */ + virtual ~Application(); + + /** Initialize the application itself. + + @attention Note that the global data structures and platform specific + initialization is done in the constructor. + + @see InitFinished, DeInit + */ + virtual void Init(); + + /** Finish initialization of the application. + + @see Init, DeInit + */ + virtual void InitFinished(); + + /** Deinitialized the application itself. + + @attention Note that the global data structures and platform specific + deinitialization is done in the destructor. + + @see Init, InitFinished + */ + virtual void DeInit(); + + ///@} + + /** @brief Pure virtual entrypoint to the application. + + Main() is the pure virtual entrypoint to your application. You + inherit your class from Application and subclass this function to + implement an application. + + The Main() function does not pass in command line parameters, + you must use the functions GetCommandLineParamCount() and + GetCommandLineParam() to get these values as these are platform + independent ways of getting the command line (use GetAppFileName() + to get the invoked executable filename). + + Once in this function, you create windows, etc. then call on + Execute() to start the application's main event loop. + + An example code snippet follows (it won't compile, this just gives the + general flavour of the framework and is adapted from an old HelloWorld + example program that Star Division used to provide as part of their + library). + + \code{.cpp} + class TheApplication : public Application + { + public: + virtual void Main(); + }; + + class TheWindow : public WorkWindow + { + public: + TheWindow(vcl::Window *parent, WinBits windowStyle) : + WorkWindow(parent, windowStyle) {} + + virtual void Paint(const Rectangle &); + }; + + void TheWindow::Paint(const Rectangle&) + { + DrawText(Point(100,100), String("Hello World!")); + } + + void TheApplication::Main() + { + TheWindow aWindow(NULL, WB_APP | WB_STDWORK); + aWindow.Show(); + Execute(); + } + + TheApplication anApplication; + \endcode + + Some examples in the source tree can be found here: + + vcl/workben/svdem.cxx + + This is an example of how to use the Application and WorkWindow. Unfortunately, it + no longer compiles. + + vcl/fpicker/test/svdem.cxx + */ + virtual int Main(); + + /** Exit from the application + + @returns true if exited successfully, false if not able to fully exit + */ + virtual bool QueryExit(); + + virtual void Shutdown(); + + /** @name Change Notification Functions + + Functions that notify when changes occur in the application. + */ + ///@{ + + /** Notify all windows that the application has changed data. + + @param rDCEvt Reference to a DataChangedEvent object + + @see DataChanged + */ + static void NotifyAllWindows( DataChangedEvent& rDCEvt ); + + ///@} + + /** @name Command Line Processing + + Command line processing is done via the following functions. They + give the number of parameters, the parameters themselves and a way + to get the name of the invoking application. + */ + + ///@{ + + /** Gets the number of command line parameters passed to the application + + @return sal_uInt16 - the number of parameters + + @see GetCommandLineParam, GetAppFileName + */ + static sal_uInt16 GetCommandLineParamCount(); + + /** Gets a particular command line parameter + + @param nParam The index of the parameter to return. + + @return The command line parameter as an OUString + + @see GetCommandLineParamCount, GetAppFileName + */ + static OUString GetCommandLineParam( sal_uInt16 nParam ); + + /** Get the name of the file used to start the application + + @return The filename as an OUString + + @see GetCommandLineParamCount, GetCommandLineParam + */ + static OUString GetAppFileName(); + + ///@} + + /** @name Error Handling + + \em Very rudimentary error handling is done by these + functions. + + @{ + */ + + /** Handles an error. + + @param nCategory The error category, see include/vcl/exceptiontypes.hxx + + @see Abort + */ + virtual void Exception( ExceptionCategory nCategory ); + + /** Ends the program prematurely with an error message. + + If the \code --norestore \endcode command line argument is given (assuming + this process is run by developers who are interested in cores, + vs. end users who are not) then it does a coredump. + + @param rErrorText The error message to report. + + @see Exception + */ + static void Abort( const OUString& rErrorText ); + + ///@} + + /** @name Event Loop Functions + + Functions that handle the LibreOffice main event loop are here, + including a global lock called the Solar Mutex. + */ + ///@{ + + /** Run the main event processing loop until it is quit by Quit(). + + @see Quit, Reschedule, Yield, EndYield, GetSolarMutex, + IsMainThread, ReleaseSolarMutex, AcquireSolarMutex, + */ + static void Execute(); + + /** Quit the program + + @see Execute, Reschedule, Yield, EndYield, GetSolarMutex, + IsMainThread, ReleaseSolarMutex, AcquireSolarMutex, + */ + static void Quit(); + + /** Has Quit() been called? + */ + static bool IsQuit(); + + /** Attempt to process current pending event(s) + + It doesn't sleep if no events are available for processing. + This doesn't process any events generated after invoking the function. + So in contrast to Scheduler::ProcessEventsToIdle, this cannot become + busy-locked by an event-generating event in the event queue. + + @param bHandleAllCurrentEvents If set to true, then try to process all + the current events. If set to false, then only process one event. + Defaults to false. + + @returns true if any event was processed. + + @see Yield, Scheduler::ProcessEventsToIdle + */ + static bool Reschedule( bool bHandleAllCurrentEvents = false ); + + /** Process the next event. + + It sleeps if no event is available for processing and just returns + if an event was processed. + + @see Execute, Quit, Reschedule, EndYield, GetSolarMutex, + IsMainThread, ReleaseSolarMutex, AcquireSolarMutex, + */ + static void Yield(); + + /** + + @see Execute, Quit, Reschedule, Yield, GetSolarMutex, + IsMainThread, ReleaseSolarMutex, AcquireSolarMutex, + */ + static void EndYield(); + + /** @brief Get the Solar Mutex for this thread. + + Get the Solar Mutex that prevents other threads from accessing VCL + concurrently. + + @returns SolarMutex reference + + @see Execute, Quit, Reschedule, Yield, EndYield, + IsMainThread, ReleaseSolarMutex, AcquireSolarMutex, + */ + static comphelper::SolarMutex& GetSolarMutex(); + + /** Queries whether we are in main thread. + + @returns true if we are in main thread, false if not + + @see Execute, Quit, Reschedule, Yield, EndYield, GetSolarMutex, + ReleaseSolarMutex, AcquireSolarMutex, + */ + static bool IsMainThread(); + + /** @brief Release Solar Mutex(es) for this thread + + Release the Solar Mutex(es) that prevents other threads from accessing + VCL concurrently. + + @returns The number of mutexes that were acquired by this thread. + + @see Execute, Quit, Reschedule, Yield, EndYield, GetSolarMutex, + IsMainThread, AcquireSolarMutex, + */ + static sal_uInt32 ReleaseSolarMutex(); + + /** @brief Acquire Solar Mutex(es) for this thread. + + Acquire the Solar Mutex(es) that prevents other threads from accessing + VCL concurrently. + + @see Execute, Quit, Reschedule, Yield, EndYield, GetSolarMutex, + IsMainThread, ReleaseSolarMutex, + */ + static void AcquireSolarMutex( sal_uInt32 nCount ); + + /** Queries whether the application is in "main", i.e. not yet in + the event loop + + @returns true if in main, false if not in main + + @see IsInExecute, IsInModalMode + */ + static bool IsInMain(); + + /** Queries whether the application is in the event loop + + @returns true if in the event loop, false if not + + @see IsInMain, IsInModalMode + */ + static bool IsInExecute(); + + /** Queries whether application has a modal dialog active. + + @returns true if a modal dialog is active, false if not + + @see IsInMain, IsInExecute + */ + static bool IsInModalMode(); + + /** Return how many events are being dispatched. + + @returns the number of events currently being dispatched + */ + static sal_uInt16 GetDispatchLevel(); + + /** Determine if there are any pending input events. + + @param nType input identifier, defined in include/vcl/inputtypes.hxx + The default is VCL_INPUT_ANY. + + @returns true if there are pending events, false if not. + + @see GetLastInputInterval + */ + static bool AnyInput( VclInputFlags nType = VCL_INPUT_ANY ); + + /** The interval from the last time that input was received. + + @returns system ticks - last input time + + @see AnyInput + */ + static sal_uInt64 GetLastInputInterval(); + + ///@} + + /* Determines if the UI is captured. + + The UI is considered captured if a system dialog is open (e.g. printer setup), + a floating window, menu or toolbox dropdown is open, or a window has been + captured by the mouse. + + @returns true if UI is captured, false if not + */ + static bool IsUICaptured(); + + /** @name Settings + + The following functions set system settings (e.g. tab color, etc.). There are functions + that set settings objects, and functions that set and get the actual system settings for + the application. + */ + ///@{ + + /** Sets user settings in settings object to override system settings + + The system settings that can be overridden are: + - window dragging options (on or off, including live scrolling!) + - style settings (e.g. checkbox color, border color, 3D colors, + button rollover colors, etc.) + - mouse settings + - menu options, including the mouse follows the menu and whether menu + icons are used + + @param rSettings Reference to the settings object to change. + + @see MergeSystemSettings, SetSettings, GetSettings + */ + virtual void OverrideSystemSettings( AllSettings& rSettings ); + + /** Set the settings object to the platform/desktop environment system + settings. + + @param rSettings Reference to the settings object to change. + + @see OverrideSystemSettings, SetSettings, GetSettings + */ + static void MergeSystemSettings( AllSettings& rSettings ); + + /** Sets the application's settings and notifies all windows of the + change. + + @param rSettings const reference to settings object used to + change the application's settings. + + @see OverrideSystemSettings, MergeSystemSettings, GetSettings + */ + static void SetSettings( const AllSettings& rSettings ); + + /** Gets the application's settings. If the application hasn't initialized + it's settings, then it does so (lazy initialization). + + @returns AllSettings instance that contains the current settings of the + application. + + @see OverrideSystemSettings, MergeSystemSettings, SetSettings + */ + static const AllSettings& GetSettings(); + + /** Get the application's locale data wrapper. + + @returns reference to a LocaleDataWrapper object + */ + static const LocaleDataWrapper& GetAppLocaleDataWrapper(); + + ///@} + + /** @name Event Listeners/Handlers + + A set of event listeners and callers. Note that in this code there is + platform specific functions - namely for zoom and scroll events. + */ + ///@{ + + + /** Add a VCL event listener to the application. If no event listener exists, + then initialize the application's event listener with a new one, then add + the event listener. + + @param rEventListener Const reference to the event listener to add. + + @see RemoveEventListener, AddKeyListener, RemoveKeyListener + */ + static void AddEventListener( const Link<VclSimpleEvent&,void>& rEventListener ); + + /** Remove a VCL event listener from the application. + + @param rEventListener Const reference to the event listener to be removed + + @see AddEventListener, AddKeyListener, RemoveKeyListener + */ + static void RemoveEventListener( const Link<VclSimpleEvent&,void>& rEventListener ); + + /** Add a keypress listener to the application. If keypress listener exists, + then initialize the application's keypress event listener with a new one, then + add the keypress listener. + + @param rKeyListener Const reference to the keypress event listener to add + + @see AddEventListener, RemoveEventListener, RemoveKeyListener + */ + static void AddKeyListener( const Link<VclWindowEvent&,bool>& rKeyListener ); + + /** Remove a keypress listener from the application. + + @param rKeyListener Const reference to the keypress event listener to be removed + + @see AddEventListener, RemoveEventListener, AddKeyListener + */ + static void RemoveKeyListener( const Link<VclWindowEvent&,bool>& rKeyListener ); + + /** Send event to all VCL application event listeners + + @param pWin Pointer to window to send event + @param pData Pointer to data to send with event + + @see ImplCallEventListeners(VclSimpleEvent* pEvent) + */ + static void ImplCallEventListenersApplicationDataChanged( void* pData ); + + /** Send event to all VCL application event listeners + + @param rEvent Reference to VclSimpleEvent + + @see ImplCallEventListeners(sal_uLong nEvent, Windows* pWin, void* pData); + */ + static void ImplCallEventListeners( VclSimpleEvent& rEvent ); + + /** Handle keypress event + + @param nEvent Event ID for keypress + @param pWin Pointer to window that receives the event + @param pKeyEvent Received key event + + @see PostKeyEvent + */ + static bool HandleKey( VclEventId nEvent, vcl::Window *pWin, KeyEvent* pKeyEvent ); + + /** Send keypress event + + @param nEvent Event ID for keypress + @param pWin Pointer to window to which the event is sent + @param pKeyEvent Key event to send + + @see HandleKey + */ + static ImplSVEvent * PostKeyEvent( VclEventId nEvent, vcl::Window *pWin, KeyEvent const * pKeyEvent ); + + + static bool LOKHandleMouseEvent( VclEventId nEvent, vcl::Window *pWin, const MouseEvent* pEvent ); + + /** Send mouse event + + @param nEvent Event ID for mouse event + @param pWin Pointer to window to which the event is sent + @param pMouseEvent Mouse event to send + */ + static ImplSVEvent * PostMouseEvent( VclEventId nEvent, vcl::Window *pWin, MouseEvent const * pMouseEvent ); + + static ImplSVEvent* PostGestureEvent(VclEventId nEvent, vcl::Window* pWin, GestureEvent const * pGestureEvent); + + /** Remove mouse and keypress events from a window... any also zoom and scroll events + if the platform supports it. + + @param pWin Window to remove events from + + @see HandleKey, PostKeyEvent, PostMouseEvent + */ + static void RemoveMouseAndKeyEvents( vcl::Window *pWin ); + + /** Post a user event to the default window. + + User events allow for the deferral of work to later in the main-loop - at idle. + + Execution of the deferred work is thread-safe which means all the tasks are executed + serially, so no thread-safety locks between tasks are necessary. + + @param rLink Link to event callback function + @param pCaller Pointer to data sent to the event by the caller. Optional. + @param bReferenceLink If true - hold a VclPtr<> reference on the Link's instance. + Taking the reference is guarded by a SolarMutexGuard. + + @return the event ID used to post the event. + */ + static ImplSVEvent * PostUserEvent( const Link<void*,void>& rLink, void* pCaller = nullptr, + bool bReferenceLink = false ); + + /** Remove user event based on event ID + + @param nUserEvent User event to remove + */ + static void RemoveUserEvent( ImplSVEvent * nUserEvent ); + + /*** Get the DisplayConnection. + + It is a reference to XDisplayConnection, which allows toolkits to send display + events to the application. + + @returns UNO reference to an object that implements the css:awt:XDisplayConnection + interface. + */ + static css::uno::Reference< css::awt::XDisplayConnection > GetDisplayConnection(); + + /** @deprecated AppEvent is used only in the Desktop class now. However, it is + intended to notify the application that an event has occurred. It was in oldsv.cxx, + but is still needed by a number of functions. + + @param rAppEvent const reference to ApplicationEvent event + */ + virtual void AppEvent( const ApplicationEvent& rAppEvent ); + + ///@} + + /** @name Application Window Functions + + Functions that deal with the application's windows + */ + ///@{ + + /** Get the currently focused window. + + @returns Pointer to focused window. + + @see GetDefaultDevice + */ + static vcl::Window* GetFocusWindow(); + + /** Get the default "device" (in this case the default window). + + @returns Pointer to an OutputDevice. However, it is a Window object - + Window class subclasses OutputDevice. + + @see GetFocusWindow + */ + static OutputDevice* GetDefaultDevice(); + + /** Get the first top-level window of the application. + + @returns Pointer to top-level window (a Window object) + + @see GetNextTopLevelWindow, GetTopWindowCount, GetTopWindow, + GetActiveTopWindow + */ + static vcl::Window* GetFirstTopLevelWindow(); + + /** Get the next top level window. + + @param pWindow Pointer to Window object you wish to get the next + window from. + + @returns Pointer to next top window. + */ + static vcl::Window* GetNextTopLevelWindow( vcl::Window const * pWindow ); + + /** Return the number of top-level windows being used by the application + + @returns the number of top-level windows + + @see GetFirstTopLevelWindow, GetNextTopLevelWindow, GetTopWindow, + GetActiveTopWindow + + */ + static tools::Long GetTopWindowCount(); + + /** Get the nth top window. + + @remark Top windows are actually implemented in a one-way linked list. + This iterates through top level windows n times. + + @param nIndex The index of the top-level window + + @returns The nth top-level window of the application + + @see GetFirstTopLevelWindow, GetNextTopLevelWindow, GetTopWindowCount, + GetActiveTopWindow + */ + static vcl::Window* GetTopWindow( tools::Long nIndex ); + + /** Get the "active" top window. + + An "active" top window is one that has a child window that has the + application's focus. + + @returns the active top window + + @see GetFirstTopLevelWindow, GetNextTopLevelWindow, GetTopWindowCount, + GetTopWindow + */ + static vcl::Window* GetActiveTopWindow(); + + ///@} + + /** Set the application's name. + + @param rUniqueName What to set the application name to + + @see GetAppName + */ + static void SetAppName( const OUString& rUniqueName ); + + + /** @name Application Name, Branding + */ + ///@{ + + /** Get the application's name. + + @returns The application name. + */ + static OUString GetAppName(); + + /** + * Get the OS version based on the OS specific implementation. + * + * @return OUString version string or "-" in case of problems + */ + static OUString GetOSVersion(); + + /** Get useful OS, Hardware and configuration information, + * cf. Help->About, and User-Agent + * bSelection = 0 to return all info, 1 for environment only, + * and 2 for VCL/render related infos + */ + static OUString GetHWOSConfInfo(const int bSelection = 0, bool bLocalize = true); + + /** Load a localized branding PNG file as a bitmap. + + @param pName Name of the bitmap to load. + @param rBitmap Reference to BitmapEx object to load PNG into + + @returns true if the PNG could be loaded, otherwise returns false. + */ + static bool LoadBrandBitmap (const char* pName, BitmapEx &rBitmap); + + ///@} + + /** @name Display and Screen + */ + ///@{ + + /** Set the default name of the application for message dialogs and printing. + + @param rDisplayName const reference to string to set the Display name to. + + @see GetDisplayName + */ + static void SetDisplayName( const OUString& rDisplayName ); + + /** Get the default name of the application for message dialogs and printing. + + @returns The display name of the application. + */ + static OUString GetDisplayName(); + + /** Get the toolkit's name. e.g. gtk3 + + @returns The toolkit name. + */ + static OUString GetToolkitName(); + + /** Get the number of screens available for the display. + + @returns The number of screens available. + + @see GetScreenPosSizePixel + */ + static unsigned int GetScreenCount(); + + /** Get a screen's rectangular area. + + @param nScreen The number of the screen requested. + + @returns The area of the screen in a Rectangle object. + + @see GetScreenCount + */ + static tools::Rectangle GetScreenPosSizePixel( unsigned int nScreen ); + + /** Determines if the screens that make up a display are separate or + form one large display area. + + @returns true when screens form up one large display area windows can be + moved between single screens (e.g. Xserver with Xinerama, Windows) + and false when different screens are separate and windows cannot be moved + between them (e.g. Xserver with multiple screens) + + @see GetBestScreen, GetDisplayBuiltInScreen + */ + static bool IsUnifiedDisplay(); + + /** Get the "best" screen. + + @returns If IsUnifiedDisplay() == true the return value will be + nearest screen of the target rectangle. + + In case of IsUnifiedDisplay() == false the return value + will always be GetDisplayDefaultScreen(). + + @see IsUnifiedDisplay, GetDisplayBuiltInScreen + */ + SAL_DLLPRIVATE static unsigned int GetBestScreen( const tools::Rectangle& ); + + /** Get the built-in screen. + + @return + This returns the LCD screen number for a laptop, or the primary + external VGA display for a desktop machine - it is where a presenter + console should be rendered if there are other (non-built-in) screens + present. + + @see IsUnifiedDisplay, GetBestScreen + */ + static unsigned int GetDisplayBuiltInScreen(); + + /** Get the display's external screen. + + Practically, this means - Get the screen we should run a presentation on. + + @returns 0 or 1 currently, will fallback to the first available screen if + there are more than one external screens. May be changed in the future. + */ + static unsigned int GetDisplayExternalScreen(); + + ///@} + + /** @name Accelerators and Mnemonics + + Accelerators allow a user to hold down Ctrl+key (or CMD+key on macOS) + combination to gain quick access to functionality. + + Mnemonics are underline letters in things like menus and dialog boxes + that allow a user to type in the letter to activate the menu or option. + */ + ///@{ + + /** Insert accelerator + + @param pAccel Pointer to an Accelerator object to insert + + @returns true if successful, false if otherwise + + @see RemoveAccel + */ + static bool InsertAccel( Accelerator* pAccel ); + + /** Remove accelerator + + @param pAccel Pointer to Accelerator object to remove + + @see InsertAccel + */ + static void RemoveAccel( Accelerator const * pAccel ); + + /** Get the number of reserved key codes used by the application. + + @returns number of reserved key codes + + @see GetReservedKeyCode + */ + static size_t GetReservedKeyCodeCount(); + + /** Get the reserved key code. + + @param i The keycode number to retrieve + + @returns Const pointer to a KeyCode object + + @see GetReservedKeyCodeCount + */ + static const vcl::KeyCode* GetReservedKeyCode( size_t i ); + + ///@} + + /** @name Application Help + + Deals with the help system, and "auto-help", where a user hovers a mouse above + a UI element and a tooltip with an explanation pops up. + */ + ///@{ + + /** Sets up help + + @param pHelp Pointer to a Help object (optional, can by NULL) + + @see GetHelp + */ + static void SetHelp( Help* pHelp = nullptr ); + + /** Gets the application's help + + @returns Pointer to application's help object. Note that the application may + not have a help object, so it might return NULL. + + @see SetHelp + */ + static Help* GetHelp(); + + ///@} + + /** @name Dialogs + + @remark "Dialog cancel mode" tells a headless install whether to + cancel dialogs when they appear. See the DialogCancelMode + enumerator. + */ + ///@{ + + /** Get the default parent window for dialog boxes. + + @remark This is almost always a terrible method to use to get a parent + for a dialog, try hard to instead pass a specific parent window + to dialogs. + + GetDefDialogParent does all sorts of things to try and find a useful + parent window for dialogs. It first uses the topmost parent of the + active window to avoid using floating windows or other dialog boxes. + If there are no active windows, then it will take a random stab and + choose the first visible top window. Otherwise, it defaults to + the desktop. + + @returns Pointer to the default window. + */ + static weld::Window* GetDefDialogParent(); + + + /** Gets the dialog cancel mode for headless environments. + + @return DialogCancelMode value + + @see SetDialogCancelMode, IsDialogCancelEnabled + */ + static DialogCancelMode GetDialogCancelMode(); + + /** Sets the dialog cancel mode for headless environments. + + This should be private, but XFrameImpl needs to access it and current + baseline gcc doesn't support forward definition of anonymous classes. + You probably should use EnableHeadlessMode instead. + + @param mode DialogCancel mode value + + @see GetDialogCancelMode, IsDialogCancelEnabled, EnableHeadlessMode + */ + static void SetDialogCancelMode( DialogCancelMode mode ); + + /** Determines if dialog cancel mode is enabled. + + @returns True if dialog cancel mode is enabled, false if disabled. + + @see GetDialogCancelMode, SetDialogCancelMode + */ + static bool IsDialogCancelEnabled(); + + + /** Make a dialog box a system window or not. + + @param nMode Can be either: SystemWindowFlags::NOAUTOMODE (0x0001) or + SystemWindowFlags::DIALOG (0x0002) + + @see GetSystemWindowMode + */ + static void SetSystemWindowMode( SystemWindowFlags nMode ); + + /** Get the system window mode of dialogs. + + @returns SystemWindowFlags::NOAUTOMODE (0x0001) or SystemWindowFlags::DIALOG (0x0002) + + @see SetSystemWindowMode + */ + static SystemWindowFlags GetSystemWindowMode(); + + ///@} + + /** @name VCL Toolkit and UNO Wrapper + + The VCL Toolkit implements the UNO XToolkit interface, which specifies a + factory interface for the window toolkit. It is similar to the abstract window + toolkit (AWT) in Java. + + */ + ///@{ + + /** Gets the VCL toolkit. + + @attention The global service manager has to be created before getting the toolkit! + + @returns UNO reference to VCL toolkit + */ + static css::uno::Reference< css::awt::XToolkit > GetVCLToolkit(); + + ///@} + + + /*** @name Graphic Filters + */ + ///@{ + + /** Setup a new graphics filter + + @param rLink Const reference to a Link object, which the filter calls upon. + + @see GetFilterHdl + */ + static void SetFilterHdl( const Link<ConvertData&,bool>& rLink ); + + ///@} + + /** @name Headless Mode + */ + + /** Enables headless mode. + + @param dialogsAreFatal Set to true if a dialog ends the session, false if not. + */ + static void EnableHeadlessMode( bool dialogsAreFatal ); + + /** Determines if headless mode is enabled + + @return True if headless mode is enabled, false if not. + */ + static bool IsHeadlessModeEnabled(); + + /** Enable Console Only mode + + Convenience function to enable headless and bitmap rendering. + */ + static void EnableConsoleOnly(); + + /** Enable software-only bitmap rendering + */ + static void EnableBitmapRendering(); + + /** Determines if bitmap rendering is enabled + + @return True if bitmap rendering is enabled. + */ + static bool IsBitmapRendering(); + + ///@} + + /** @name Event Testing Mode + */ + + /** Enables event testing mode. + + */ + static void EnableEventTestingMode(); + + /** Determines if event testing mode is enabled + + @return True if event testing mode is enabled, false if not. + */ + static bool IsEventTestingModeEnabled(); + + /** Set safe mode to enabled */ + static void EnableSafeMode(); + + /** Determines if safe mode is enabled */ + static bool IsSafeModeEnabled(); + + ///@} + + /** Get the desktop environment the process is currently running in + + @returns String representing the desktop environment + */ + static const OUString& GetDesktopEnvironment(); + + /*** @name Platform Functionality + */ + ///@{ + + /** Add a file to the system shells recent document list if there is any. + This function may have no effect under Unix because there is no standard + API among the different desktop managers. + + @param rFileUrl The file url of the document. + + @param rMimeType The mime content type of the document specified by aFileUrl. + If an empty string will be provided "application/octet-stream" + will be used. + + @param rDocumentService The app (or "document service") you will be adding the file to + e.g. com.sun.star.text.TextDocument + */ + static void AddToRecentDocumentList(const OUString& rFileUrl, const OUString& rMimeType, const OUString& rDocumentService); + + /*** Show a native error messagebox + + @param sTitle Title of error messagebox + + @param sMessage Message displayed in messagebox + */ + static void ShowNativeErrorBox(const OUString& sTitle , + const OUString& sMessage); + + /** Update main thread identifier */ + static void UpdateMainThread(); + + /** Do we have a native / system file selector available? + + @returns True if native file selector is available, false otherwise. + */ + static bool hasNativeFileSelection(); + + /** Create a platform specific file picker, if one is available, otherwise return an + empty reference. + + @param rServiceManager Const reference to a UNO component context (service manager). + + @returns File picker if available, otherwise an empty reference. + */ + static css::uno::Reference< css::ui::dialogs::XFilePicker2 > + createFilePicker( const css::uno::Reference< css::uno::XComponentContext >& rServiceManager ); + + /** Create a platform specific folder picker, if one is available, otherwise return an + empty reference + + @param rServiceManager Const reference to a UNO component context (service manager). + + @returns Folder picker if available, otherwise an empty reference. + */ + static css::uno::Reference< css::ui::dialogs::XFolderPicker2 > + createFolderPicker( const css::uno::Reference< css::uno::XComponentContext >& rServiceManager ); + + /** Cancel all open dialogs + */ + static void EndAllDialogs(); + + /** Cancel all open popups + */ + static void EndAllPopups(); + + /** Returns true, if the VCL plugin runs on the system event loop. + * + * AKA the VCL plugin can't handle nested event loops, like WASM or mobile. + */ + static bool IsOnSystemEventLoop(); + + ///@} + + // For vclbootstrapprotector: + static void setDeInitHook(Link<LinkParamNone*,void> const & hook); + + static std::unique_ptr<weld::Builder> CreateBuilder(weld::Widget* pParent, const OUString &rUIFile, bool bMobile = false, sal_uInt64 nLOKWindowId = 0); + // For the duration of vcl parent windows + static std::unique_ptr<weld::Builder> CreateInterimBuilder(vcl::Window* pParent, const OUString &rUIFile, bool bAllowCycleFocusOut, sal_uInt64 nLOKWindowId = 0); + + static weld::MessageDialog* CreateMessageDialog(weld::Widget* pParent, VclMessageType eMessageType, + VclButtonsType eButtonType, const OUString& rPrimaryMessage, + bool bMobile = false); + + static weld::Window* GetFrameWeld(const css::uno::Reference<css::awt::XWindow>& rWindow); + + // ILibreOfficeKitNotifier + void* m_pCallbackData; + LibreOfficeKitCallback m_pCallback; + + virtual void notifyWindow(vcl::LOKWindowId nLOKWindowId, + const OUString& rAction, + const std::vector<vcl::LOKPayloadItem>& rPayload = std::vector<vcl::LOKPayloadItem>()) const override; + virtual void libreOfficeKitViewCallback(int nType, const char* pPayload) const override; + +private: + DECL_DLLPRIVATE_STATIC_LINK( Application, PostEventHandler, void*, void ); +}; + +class SolarMutexGuard + : public osl::Guard<comphelper::SolarMutex> +{ +public: + SolarMutexGuard() + : osl::Guard<comphelper::SolarMutex>( Application::GetSolarMutex() ) {} +}; + +class SolarMutexClearableGuard + : public osl::ClearableGuard<comphelper::SolarMutex> +{ +public: + SolarMutexClearableGuard() + : osl::ClearableGuard<comphelper::SolarMutex>( Application::GetSolarMutex() ) {} +}; + +class SolarMutexResettableGuard + : public osl::ResettableGuard<comphelper::SolarMutex> +{ +public: + SolarMutexResettableGuard() + : osl::ResettableGuard<comphelper::SolarMutex>( Application::GetSolarMutex() ) {} +}; + +namespace vcl +{ + +/** guard class that uses tryToAcquire() and has isAcquired() to check + */ +class SolarMutexTryAndBuyGuard +{ +private: + bool m_isAcquired; +#ifdef DBG_UTIL + bool m_isChecked; +#endif + comphelper::SolarMutex& m_rSolarMutex; + + SolarMutexTryAndBuyGuard(const SolarMutexTryAndBuyGuard&) = delete; + SolarMutexTryAndBuyGuard& operator=(const SolarMutexTryAndBuyGuard&) = delete; + +public: + + SolarMutexTryAndBuyGuard() + : m_isAcquired(false) +#ifdef DBG_UTIL + , m_isChecked(false) +#endif + , m_rSolarMutex(Application::GetSolarMutex()) + + { + m_isAcquired = m_rSolarMutex.tryToAcquire(); + } + + ~SolarMutexTryAndBuyGuard() + { +#ifdef DBG_UTIL + assert(m_isChecked); +#endif + if (m_isAcquired) + m_rSolarMutex.release(); + } + + bool isAcquired() + { +#ifdef DBG_UTIL + m_isChecked = true; +#endif + return m_isAcquired; + } +}; + +} // namespace vcl + +/** + A helper class that calls Application::ReleaseSolarMutex() in its constructor + and restores the mutex in its destructor. +*/ +class SolarMutexReleaser +{ + const sal_uInt32 mnReleased; +public: + SolarMutexReleaser(): mnReleased(Application::ReleaseSolarMutex()) {} + ~SolarMutexReleaser() { Application::AcquireSolarMutex( mnReleased ); } +}; + +VCL_DLLPUBLIC Application* GetpApp(); + +// returns true if vcl is already initialized +VCL_DLLPUBLIC bool IsVCLInit(); +// returns true if vcl successfully initializes or was already initialized +VCL_DLLPUBLIC bool InitVCL(); +VCL_DLLPUBLIC void DeInitVCL(); + +VCL_DLLPUBLIC bool InitAccessBridge(); + +// only allowed to call, if no thread is running. You must call JoinMainLoopThread to free all memory. +VCL_DLLPUBLIC void CreateMainLoopThread( oslWorkerFunction pWorker, void * pThreadData ); +VCL_DLLPUBLIC void JoinMainLoopThread(); + +/// The following are to manage per-view (frame) help data. +struct ImplSVHelpData; +VCL_DLLPUBLIC ImplSVHelpData* CreateSVHelpData(); +VCL_DLLPUBLIC void DestroySVHelpData(ImplSVHelpData*); +VCL_DLLPUBLIC void SetSVHelpData(ImplSVHelpData*); + +/// The following are to manage per-view (frame) window data. +struct ImplSVWinData; +VCL_DLLPUBLIC ImplSVWinData* CreateSVWinData(); +VCL_DLLPUBLIC void DestroySVWinData(ImplSVWinData*); +VCL_DLLPUBLIC void SetSVWinData(ImplSVWinData*); + +inline void Application::EndYield() +{ + PostUserEvent( Link<void*,void>() ); +} + +#endif // _APP_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/svmain.hxx b/include/vcl/svmain.hxx new file mode 100644 index 000000000..ca6010784 --- /dev/null +++ b/include/vcl/svmain.hxx @@ -0,0 +1,33 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_SVMAIN_HXX +#define INCLUDED_VCL_SVMAIN_HXX + +#include <sal/config.h> +#include <vcl/dllapi.h> + +// #i47888# allow for alternative initialization as required for e.g. MacOSX +VCL_DLLPUBLIC int ImplSVMain(); + +VCL_DLLPUBLIC int SVMain(); + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/svtaccessiblefactory.hxx b/include/vcl/svtaccessiblefactory.hxx new file mode 100644 index 000000000..14bcc6532 --- /dev/null +++ b/include/vcl/svtaccessiblefactory.hxx @@ -0,0 +1,59 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_INCLUDE_VCL_SVTACCESSIBLEFACTORY_HXX +#define INCLUDED_INCLUDE_VCL_SVTACCESSIBLEFACTORY_HXX + +#include <config_options.h> +#include <vcl/dllapi.h> + +namespace vcl { class IAccessibleFactory; } + +namespace vcl +{ + /** a client for the accessibility implementations which have been outsourced + from the main vcl/svtools libraries + + All instances of this class share a reference to a common IAccessibleFactory + instance, which is used for creating all kind of Accessibility related + components. + + When the AccessibleFactoryAccess goes away, also this factory goes away, and the respective + library is unloaded. + + This class is not thread-safe. + */ + class UNLESS_MERGELIBS(VCL_DLLPUBLIC) AccessibleFactoryAccess + { + private: + bool m_bInitialized; + + public: + AccessibleFactoryAccess(); + + IAccessibleFactory& getFactory(); + + private: + void ensureInitialized(); + }; +} // namespace svt + +#endif // INCLUDED_INCLUDE_VCL_SVTACCESSIBLEFACTORY_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/syschild.hxx b/include/vcl/syschild.hxx new file mode 100644 index 000000000..11d85b029 --- /dev/null +++ b/include/vcl/syschild.hxx @@ -0,0 +1,67 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_SYSCHILD_HXX +#define INCLUDED_VCL_SYSCHILD_HXX + +#include <vcl/dllapi.h> +#include <vcl/window.hxx> + +struct SystemEnvData; +struct SystemWindowData; + +class VCL_DLLPUBLIC SystemChildWindow : public vcl::Window +{ +private: + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInitSysChild( vcl::Window* pParent, WinBits nStyle, SystemWindowData *pData, bool bShow = false ); + + // Copy assignment is forbidden and not implemented. + SystemChildWindow (const SystemChildWindow &) = delete; + SystemChildWindow & operator= (const SystemChildWindow &) = delete; + +public: + explicit SystemChildWindow( vcl::Window* pParent, WinBits nStyle ); + // create a SystemChildWindow using the given SystemWindowData + explicit SystemChildWindow( vcl::Window* pParent, WinBits nStyle, SystemWindowData *pData, bool bShow = true ); + virtual ~SystemChildWindow() override; + virtual Size GetOptimalSize() const override; + virtual void dispose() override; + + virtual const SystemEnvData* GetSystemData() const override; + + // per default systemchildwindows erase their background for better plugin support + // however, this might not always be required + void EnableEraseBackground( bool bEnable ); + void SetForwardKey( bool bEnable ); + //To avoid annoying flashing under X entering and leaving slides with opengl effects set the leaving + //bitmap as the background pixmap of the opengl child window and the entering bitmap as the background + //pixmap of the non-opengl parent window. If any expose events occur around the start and end of + //the transition then those windows are default filled by X with the desired start/end image so there's + //no visible flash + void SetLeaveEnterBackgrounds(const css::uno::Sequence<css::uno::Any>& rLeaveArgs, const css::uno::Sequence<css::uno::Any>& rEnterArgs); + // return the platform specific handle/id of this window; + sal_IntPtr GetParentWindowHandle() const; + + void* CreateGStreamerSink(); +}; + +#endif // INCLUDED_VCL_SYSCHILD_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/sysdata.hxx b/include/vcl/sysdata.hxx new file mode 100644 index 000000000..07ddea45d --- /dev/null +++ b/include/vcl/sysdata.hxx @@ -0,0 +1,201 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_SYSDATA_HXX +#define INCLUDED_VCL_SYSDATA_HXX + +#include <sal/types.h> +#include <vcl/dllapi.h> + +class SalFrame; + +#ifdef MACOSX +// predeclare the native classes to avoid header/include problems +typedef struct CGContext *CGContextRef; +typedef struct CGLayer *CGLayerRef; +typedef const struct __CTFont * CTFontRef; +#ifdef __OBJC__ +@class NSView; +#else +class NSView; +#endif +#endif + +#ifdef IOS +typedef const struct __CTFont * CTFontRef; +typedef struct CGContext *CGContextRef; +#endif + +#if defined(_WIN32) +#include <prewin.h> +#include <windef.h> +#include <postwin.h> +#endif + +struct VCL_DLLPUBLIC SystemEnvData +{ + enum class Toolkit { Invalid, Gen, Gtk, Qt }; + Toolkit toolkit; // the toolkit in use +#if defined(_WIN32) + HWND hWnd; // the window hwnd +#elif defined( MACOSX ) + NSView* mpNSView; // the cocoa (NSView *) implementing this object + bool mbOpenGL; // use an OpenGL providing NSView +#elif defined( ANDROID ) + // Nothing +#elif defined( IOS ) + // Nothing +#elif defined( UNX ) + enum class Platform { Invalid, Wayland, Xcb, WASM }; + + void* pDisplay; // the relevant display connection + SalFrame* pSalFrame; // contains a salframe, if object has one + void* pWidget; // the corresponding widget + void* pVisual; // the visual in use + int nScreen; // the current screen of the window + // note: this is a "long" in Xlib *but* in the protocol it's only 32-bit + // however, the GTK3 vclplug wants to store pointers in here! + sal_IntPtr aShellWindow; // the window of the frame's shell + Platform platform; // the windowing system in use +private: + sal_uIntPtr aWindow; // the window of the object +public: + + void SetWindowHandle(sal_uIntPtr nWindow) + { + aWindow = nWindow; + } + + // SalFrame can be any SalFrame, just needed to determine which backend to use + // to resolve the window handle + sal_uIntPtr GetWindowHandle(const SalFrame* pReference) const; + +#endif + + SystemEnvData() + : toolkit(Toolkit::Invalid) +#if defined(_WIN32) + , hWnd(nullptr) +#elif defined( MACOSX ) + , mpNSView(nullptr) + , mbOpenGL(false) +#elif defined( ANDROID ) +#elif defined( IOS ) +#elif defined( UNX ) + , pDisplay(nullptr) + , pSalFrame(nullptr) + , pWidget(nullptr) + , pVisual(nullptr) + , nScreen(0) + , aShellWindow(0) + , platform(Platform::Invalid) + , aWindow(0) +#endif + { + } +}; + +struct SystemParentData +{ + sal_uInt32 nSize; // size in bytes of this structure +#if defined(_WIN32) + HWND hWnd; // the window hwnd +#elif defined( MACOSX ) + NSView* pView; // the cocoa (NSView *) implementing this object +#elif defined( ANDROID ) + // Nothing +#elif defined( IOS ) + // Nothing +#elif defined( UNX ) + sal_uIntPtr aWindow; // the window of the object + bool bXEmbedSupport:1; // decides whether the object in question + // should support the XEmbed protocol +#endif +}; + +struct SystemMenuData +{ +#if defined(_WIN32) + HMENU hMenu; // the menu handle of the menu bar +#else + // Nothing +#endif +}; + +struct SystemGraphicsData +{ + sal_uInt32 nSize; // size in bytes of this structure +#if defined(_WIN32) + HDC hDC; // handle to a device context + HWND hWnd; // optional handle to a window +#elif defined( MACOSX ) + CGContextRef rCGContext; // CoreGraphics graphic context +#elif defined( ANDROID ) + // Nothing +#elif defined( IOS ) + CGContextRef rCGContext; // CoreGraphics graphic context +#elif defined( UNX ) + void* pDisplay; // the relevant display connection + sal_uIntPtr hDrawable; // a drawable + void* pVisual; // the visual in use + int nScreen; // the current screen of the drawable + void* pXRenderFormat; // render format for drawable + void* pSurface; // the cairo surface when using svp-based backends +#endif + SystemGraphicsData() + : nSize( sizeof( SystemGraphicsData ) ) +#if defined(_WIN32) + , hDC( nullptr ) + , hWnd( nullptr ) +#elif defined( MACOSX ) + , rCGContext( nullptr ) +#elif defined( ANDROID ) + // Nothing +#elif defined( IOS ) + , rCGContext( NULL ) +#elif defined( UNX ) + , pDisplay( nullptr ) + , hDrawable( 0 ) + , pVisual( nullptr ) + , nScreen( 0 ) + , pXRenderFormat( nullptr ) + , pSurface( nullptr ) +#endif + { } +}; + +struct SystemWindowData +{ +#if defined(_WIN32) // meaningless on Windows +#elif defined( MACOSX ) + bool bOpenGL; // create an OpenGL providing NSView + bool bLegacy; // create a 2.1 legacy context, only valid if bOpenGL == true +#elif defined( ANDROID ) + // Nothing +#elif defined( IOS ) + // Nothing +#elif defined( UNX ) + void* pVisual; // the visual to be used + bool bClipUsingNativeWidget; // default is false, true will attempt to clip the childwindow with a native widget +#endif +}; + +#endif // INCLUDED_VCL_SYSDATA_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/syswin.hxx b/include/vcl/syswin.hxx new file mode 100644 index 000000000..24f41331e --- /dev/null +++ b/include/vcl/syswin.hxx @@ -0,0 +1,249 @@ +/* -*- 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 . + */ + +#pragma once + +#include <vcl/dllapi.h> +#include <vcl/idle.hxx> +#include <vcl/vclenum.hxx> +#include <vcl/window.hxx> +#include <vcl/windowstate.hxx> +#include <com/sun/star/frame/XFrame.hpp> +#include <memory> + +class SalInstanceBuilder; +class ScreenshotTest; +class MenuBar; +class MnemonicGenerator; +class NotebookBar; +class TaskPaneList; +class VclBuilder; +struct NotebookBarAddonsItem; + +#define ICON_LO_DEFAULT 1 +#define ICON_TEXT_DOCUMENT 2 +#define ICON_SPREADSHEET_DOCUMENT 4 +#define ICON_DRAWING_DOCUMENT 6 +#define ICON_PRESENTATION_DOCUMENT 8 +#define ICON_TEMPLATE 11 +#define ICON_DATABASE_DOCUMENT 12 +#define ICON_MATH_DOCUMENT 13 +#define ICON_MACROLIBRARY 1 + +enum class MenuBarMode +{ + Normal, Hide +}; + +enum class TitleButton +{ + Docking = 1, + Hide = 2, + Menu = 4, +}; + +//helper baseclass to ease retro fitting dialogs/tabpages that load a resource +//to load a .ui file instead +// +//vcl requires the Window Children of a Parent Window to be destroyed before +//the Parent Window. VclBuilderContainer owns the VclBuilder which owns the +//Children Window. So the VclBuilderContainer dtor must be called before +//the Parent Window dtor. +// +//i.e. class Dialog : public SystemWindow, public VclBuilderContainer +//not class Dialog : public VclBuilderContainer, public SystemWindow +// +//With the new 'dispose' framework, it is necessary to force the builder +//dispose before the Window dispose; so a Dialog::dispose() method would +//finish: disposeBuilder(); SystemWindow::dispose() to capture this ordering. + +class VCL_DLLPUBLIC VclBuilderContainer +{ +public: + VclBuilderContainer(); + virtual ~VclBuilderContainer(); + void disposeBuilder(); + + void setDeferredProperties(); + +protected: + std::unique_ptr<VclBuilder> m_pUIBuilder; + + friend class ::SalInstanceBuilder; + friend class ::ScreenshotTest; +}; + +class VCL_DLLPUBLIC SystemWindow + : public vcl::Window + , public VclBuilderContainer +{ + friend class WorkWindow; + class ImplData; + +private: + VclPtr<MenuBar> mpMenuBar; + Size maMinOutSize; + bool mbDockBtn; + bool mbHideBtn; + bool mbSysChild; + bool mbIsCalculatingInitialLayoutSize; + bool mbInitialLayoutSizeCalculated; + bool mbPaintComplete; + MenuBarMode mnMenuBarMode; + sal_uInt16 mnIcon; + std::unique_ptr<ImplData> mpImplData; + Idle maLayoutIdle; + OUString maNotebookBarUIFile; +protected: + bool mbIsDeferredInit; + VclPtr<vcl::Window> mpDialogParent; +public: + using Window::ImplIsInTaskPaneList; + SAL_DLLPRIVATE bool ImplIsInTaskPaneList( vcl::Window* pWin ); + SAL_DLLPRIVATE bool isDeferredInit() const { return mbIsDeferredInit; } + +private: + SAL_DLLPRIVATE void ImplMoveToScreen( tools::Long& io_rX, tools::Long& io_rY, tools::Long i_nWidth, tools::Long i_nHeight, vcl::Window const * i_pConfigureWin ); + SAL_DLLPRIVATE void setPosSizeOnContainee(Size aSize, Window &rBox); + DECL_DLLPRIVATE_LINK( ImplHandleLayoutTimerHdl, Timer*, void ); + + // try to extract content and return as Bitmap. To do that reliably, a Yield-loop + // like in Execute() has to be executed and it is necessary to detect when the + // paint is finished + virtual void PrePaint(vcl::RenderContext& rRenderContext) override; + virtual void PostPaint(vcl::RenderContext& rRenderContext) override; + + // ensureRepaint - triggers Application::Yield until the dialog is + // completely repainted. Sometimes needed for dialogs showing progress + // during actions + SAL_DLLPRIVATE void ensureRepaint(); + +protected: + // Single argument ctors shall be explicit. + explicit SystemWindow(WindowType nType, const char* pIdleDebugName); + void loadUI(vcl::Window* pParent, const OString& rID, const OUString& rUIXMLDescription, const css::uno::Reference<css::frame::XFrame> &rFrame = css::uno::Reference<css::frame::XFrame>()); + + void SetWindowStateData( const WindowStateData& rData ); + + virtual void settingOptimalLayoutSize(Window *pBox); + + SAL_DLLPRIVATE void DoInitialLayout(); + +public: + virtual ~SystemWindow() override; + virtual void dispose() override; + + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + + virtual bool Close(); + virtual void TitleButtonClick( TitleButton nButton ); + virtual void Resizing( Size& rSize ); + virtual void Resize() override; + virtual Size GetOptimalSize() const override; + virtual void queue_resize(StateChangedType eReason = StateChangedType::Layout) override; + bool isLayoutEnabled() const; + void setOptimalLayoutSize(bool bAllowWindowShrink); + bool isCalculatingInitialLayoutSize() const { return mbIsCalculatingInitialLayoutSize; } + + void SetIcon( sal_uInt16 nIcon ); + sal_uInt16 GetIcon() const { return mnIcon; } + // for systems like MacOSX which can display the URL a document is loaded from + // separately from the window title + void SetRepresentedURL( const OUString& ); + + void ShowTitleButton( TitleButton nButton, bool bVisible ); + bool IsTitleButtonVisible( TitleButton nButton ) const; + + void SetMinOutputSizePixel( const Size& rSize ); + const Size& GetMinOutputSizePixel() const { return maMinOutSize; } + void SetMaxOutputSizePixel( const Size& rSize ); + const Size& GetMaxOutputSizePixel() const; + + void SetWindowState(std::string_view rStr); + OString GetWindowState(WindowStateMask nMask = WindowStateMask::All) const; + + void SetMenuBar(MenuBar* pMenuBar); + MenuBar* GetMenuBar() const { return mpMenuBar; } + void SetMenuBarMode( MenuBarMode nMode ); + void CollectMenuBarMnemonics(MnemonicGenerator& rMnemonicGenerator) const; + int GetMenuBarHeight() const; + + void SetNotebookBar(const OUString& rUIXMLDescription, + const css::uno::Reference<css::frame::XFrame>& rFrame, + const NotebookBarAddonsItem& aNotebookBarAddonsItem, + bool bReloadNotebookbar = false); + + void CloseNotebookBar(); + VclPtr<NotebookBar> const & GetNotebookBar() const; + + TaskPaneList* GetTaskPaneList(); + void GetWindowStateData( WindowStateData& rData ) const; + + virtual void SetText( const OUString& rStr ) override; + virtual OUString GetText() const override; + + /** + Returns the screen number the window is on + + The Display Screen number is counted the same way that + <code>Application::GetScreenPosSizePixel</code> + and of course <code>SystemWindow::SetScreenNumber</code> + are counted in. + + In case the window is positioned on multiple screens the + screen number returned will be of the screen containing the + upper left pixel of the frame area (that is of the client + area on system decorated windows, or the frame area of + undecorated resp. owner decorated windows. + + @returns the screen number + + @see SystemWindow::SetScreenNumber + */ + unsigned int GetScreenNumber() const; + /** + Move the Window to a new screen. The same rules for + positioning apply as in <code>SystemWindow::GetScreenNumber</code> + + The Display Screen number is counted the same way that + <code>Application::GetScreenPosSizePixel</code> + and of course <code>SystemWindow::GetScreenNumber</code> + are counted in. + + @see GetScreenNumber + */ + void SetScreenNumber( unsigned int nNewScreen ); + + void SetApplicationID( const OUString &rApplicationID ); + + bool UpdatePositionData(); + + void SetCloseHdl(const Link<SystemWindow&,void>& rLink); + const Link<SystemWindow&,void>& GetCloseHdl() const; + + SAL_DLLPRIVATE bool hasPendingLayout() const { return maLayoutIdle.IsActive(); } + + virtual void doDeferredInit(WinBits nBits); + + // Screenshot interface + VclPtr<VirtualDevice> createScreenshot(); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/tabctrl.hxx b/include/vcl/tabctrl.hxx new file mode 100644 index 000000000..40fdd54f2 --- /dev/null +++ b/include/vcl/tabctrl.hxx @@ -0,0 +1,232 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_TABCTRL_HXX +#define INCLUDED_VCL_TABCTRL_HXX + +#include <config_options.h> +#include <vcl/dllapi.h> +#include <vcl/ctrl.hxx> +#include <vcl/EnumContext.hxx> +#include <vcl/NotebookbarContextControl.hxx> + +class ImplTabItem; +struct ImplTabCtrlData; +class TabPage; +class Button; +class PushButton; +class ListBox; +class ToolBox; + +#ifndef TAB_APPEND +#define TAB_APPEND (sal_uInt16(0xFFFF)) +#define TAB_PAGE_NOTFOUND (sal_uInt16(0xFFFF)) +#endif /* !TAB_APPEND */ + +#define TAB_OFFSET 3 +#define TAB_TABOFFSET_X 3 +#define TAB_TABOFFSET_Y 3 +#define TAB_EXTRASPACE_X 6 +#define TAB_BORDER_LEFT 1 +#define TAB_BORDER_TOP 1 +#define TAB_BORDER_RIGHT 2 +#define TAB_BORDER_BOTTOM 2 + +class VCL_DLLPUBLIC TabControl : public Control +{ +protected: + std::unique_ptr<ImplTabCtrlData> mpTabCtrlData; + tools::Long mnLastWidth; + tools::Long mnLastHeight; + sal_uInt16 mnActPageId; + sal_uInt16 mnCurPageId; + bool mbFormat; + bool mbShowTabs; + bool mbRestoreHelpId; + bool mbSmallInvalidate; + bool mbLayoutDirty; + Link<TabControl*,void> maActivateHdl; + Link<TabControl*,bool> maDeactivateHdl; + + using Control::ImplInitSettings; + SAL_DLLPRIVATE void ImplInitSettings( bool bBackground ); + SAL_DLLPRIVATE ImplTabItem* ImplGetItem( sal_uInt16 nId ) const; + SAL_DLLPRIVATE ImplTabItem* ImplGetItem(const Point& rPt) const; + SAL_DLLPRIVATE Size ImplGetItemSize( ImplTabItem* pItem, tools::Long nMaxWidth ); + SAL_DLLPRIVATE tools::Rectangle ImplGetTabRect( sal_uInt16 nPos, tools::Long nWidth = -1, tools::Long nHeight = -1 ); + SAL_DLLPRIVATE tools::Rectangle ImplGetTabRect(const ImplTabItem*, tools::Long nWidth, tools::Long nHeight); + SAL_DLLPRIVATE void ImplChangeTabPage( sal_uInt16 nId, sal_uInt16 nOldId ); + SAL_DLLPRIVATE bool ImplPosCurTabPage(); + virtual void ImplActivateTabPage( bool bNext ); + SAL_DLLPRIVATE void ImplShowFocus(); + SAL_DLLPRIVATE void ImplDrawItem(vcl::RenderContext& rRenderContext, ImplTabItem const * pItem, + const tools::Rectangle& rCurRect, bool bFirstInGroup, + bool bLastInGroup); + SAL_DLLPRIVATE void ImplFreeLayoutData(); + SAL_DLLPRIVATE bool ImplHandleKeyEvent( const KeyEvent& rKeyEvent ); + + DECL_DLLPRIVATE_LINK( ImplListBoxSelectHdl, ListBox&, void ); + DECL_DLLPRIVATE_LINK( ImplWindowEventListener, VclWindowEvent&, void ); + + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + + virtual void FillLayoutData() const override; + virtual const vcl::Font& GetCanonicalFont( const StyleSettings& _rStyle ) const override; + virtual const Color& GetCanonicalTextColor( const StyleSettings& _rStyle ) const override; + virtual bool ImplPlaceTabs( tools::Long nWidth ); + SAL_DLLPRIVATE Size ImplCalculateRequisition(sal_uInt16& nHeaderHeight) const; + +public: + TabControl( vcl::Window* pParent, + WinBits nStyle = WB_STDTABCONTROL ); + virtual ~TabControl() override; + virtual void dispose() override; + + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void KeyInput( const KeyEvent& rKEvt ) override; + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Resize() override; + virtual void GetFocus() override; + virtual void LoseFocus() override; + virtual void RequestHelp( const HelpEvent& rHEvt ) override; + virtual void Command( const CommandEvent& rCEvt ) override; + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + + void ActivatePage(); + bool DeactivatePage(); + + virtual Size GetOptimalSize() const override; + + void SetTabPageSizePixel( const Size& rSize ); + + void InsertPage( sal_uInt16 nPageId, const OUString& rText, + sal_uInt16 nPos = TAB_APPEND ); + void RemovePage( sal_uInt16 nPageId ); + + void SetPageEnabled(sal_uInt16 nPageId, bool bEnable = true); + void SetPageVisible(sal_uInt16 nPageId, bool bVisible = true); + + sal_uInt16 GetPagePos( sal_uInt16 nPageId ) const; + sal_uInt16 GetPageCount() const; + sal_uInt16 GetPageId( sal_uInt16 nPos ) const; + sal_uInt16 GetPageId(const Point& rPos) const; + sal_uInt16 GetPageId( const OString& rName ) const; + + void SetCurPageId(sal_uInt16 nPageId); + sal_uInt16 GetCurPageId() const; + + void SelectTabPage( sal_uInt16 nPageId ); + + void SetTabPage(sal_uInt16 nPageId, TabPage* pPage); + TabPage* GetTabPage( sal_uInt16 nPageId ) const; + + void SetPageText( sal_uInt16 nPageId, const OUString& rText ); + OUString const & GetPageText( sal_uInt16 nPageId ) const; + + void SetHelpText( sal_uInt16 nPageId, const OUString& rText ); + const OUString& GetHelpText( sal_uInt16 nPageId ) const; + + void SetPageName( sal_uInt16 nPageId, const OString& rName ) const; + OString GetPageName( sal_uInt16 nPageId ) const; + + void SetAccessibleName( sal_uInt16 nItemId, const OUString& rStr ); + OUString GetAccessibleName( sal_uInt16 nItemId ) const; + + void SetAccessibleDescription( sal_uInt16 nItemId, const OUString& rStr ); + OUString GetAccessibleDescription( sal_uInt16 nItemId ) const; + + void SetPageImage( sal_uInt16 nPageId, const Image& rImage ); + + using Control::SetHelpId; + using Control::GetHelpId; + + void SetActivatePageHdl( const Link<TabControl*,void>& rLink ) { maActivateHdl = rLink; } + void SetDeactivatePageHdl( const Link<TabControl*, bool>& rLink ) { maDeactivateHdl = rLink; } + + // returns (control relative) bounding rectangle for the + // character at index nIndex relative to the text of page nPageId + using Control::GetCharacterBounds; + tools::Rectangle GetCharacterBounds( sal_uInt16 nPageId, tools::Long nIndex ) const; + + // returns the index relative to the text of page nPageId (also returned) + // at position rPoint (control relative) + using Control::GetIndexForPoint; + tools::Long GetIndexForPoint( const Point& rPoint, sal_uInt16& rPageId ) const; + + // returns the rectangle of the tab for page nPageId + tools::Rectangle GetTabBounds( sal_uInt16 nPageId ) const; + + virtual void SetPosPixel(const Point& rPos) override; + virtual void SetSizePixel(const Size& rNewSize) override; + virtual void SetPosSizePixel(const Point& rNewPos, const Size& rNewSize) override; + + virtual Size calculateRequisition() const; + void setAllocation(const Size &rAllocation); + + std::vector<sal_uInt16> GetPageIDs() const; + + virtual FactoryFunction GetUITestFactory() const override; + + virtual void queue_resize(StateChangedType eReason = StateChangedType::Layout) override; + + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + + virtual void DumpAsPropertyTree(tools::JsonWriter&) override; +}; + +class NotebookBar; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) NotebookbarTabControlBase : public TabControl, + public NotebookbarContextControl +{ +public: + NotebookbarTabControlBase( vcl::Window* pParent ); + ~NotebookbarTabControlBase() override; + void dispose() override; + + void SetContext( vcl::EnumContext::Context eContext ) override; + void SetIconClickHdl( Link<NotebookBar*, void> aHdl ); + void SetToolBox( ToolBox* pToolBox ); + ToolBox* GetToolBox() { return m_pShortcuts; } + Control* GetOpenMenu(); + + virtual Size calculateRequisition() const override; + static sal_uInt16 GetHeaderHeight(); + +protected: + virtual bool ImplPlaceTabs( tools::Long nWidth ) override; + virtual void ImplActivateTabPage( bool bNext ) override; + +private: + bool bLastContextWasSupported; + vcl::EnumContext::Context eLastContext; + Link<NotebookBar*,void> m_aIconClickHdl; + static sal_uInt16 m_nHeaderHeight; + VclPtr<ToolBox> m_pShortcuts; + VclPtr<PushButton> m_pOpenMenu; + DECL_DLLPRIVATE_LINK(OpenMenu, Button*, void); +}; + +#endif // INCLUDED_VCL_TABCTRL_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/tabpage.hxx b/include/vcl/tabpage.hxx new file mode 100644 index 000000000..e06c4c1a7 --- /dev/null +++ b/include/vcl/tabpage.hxx @@ -0,0 +1,77 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_TABPAGE_HXX +#define INCLUDED_VCL_TABPAGE_HXX + +#include <vcl/dllapi.h> +#include <vcl/window.hxx> +#include <vcl/IContext.hxx> + +class ScrollBar; + +class VCL_DLLPUBLIC TabPage final + : public vcl::Window + , public vcl::IContext +{ +private: + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + SAL_DLLPRIVATE void ImplInitSettings(); + void lcl_Scroll( tools::Long nX, tools::Long nY ); + DECL_DLLPRIVATE_LINK( ScrollBarHdl, ScrollBar*, void ); + + VclPtr<ScrollBar> m_pVScroll; + VclPtr<ScrollBar> m_pHScroll; + Size maScrollArea; + bool mbHasHoriBar; + bool mbHasVertBar; + Point mnScrollPos; + tools::Long mnScrWidth; + +public: + explicit TabPage( vcl::Window* pParent, WinBits nStyle = 0 ); + virtual ~TabPage() override; + virtual void dispose() override; + + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Draw( OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags ) override; + + virtual void StateChanged( StateChangedType nStateChange ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + //To-Do, consider inheriting from VclContainer + virtual void SetPosSizePixel(const Point& rNewPos, const Size& rNewSize) override; + virtual void SetPosPixel(const Point& rNewPos) override; + virtual void SetSizePixel(const Size& rNewSize) override; + virtual Size GetOptimalSize() const override; + + // for scrollable tabpage + virtual void Resize() override; + + void SetScrollWidth( tools::Long nWidth ); + void SetScrollHeight( tools::Long nHeight ); + void SetScrollLeft( tools::Long nLeft ); + void SetScrollTop( tools::Long Top ); + void ResetScrollBars(); +}; + +#endif // INCLUDED_VCL_TABPAGE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/task.hxx b/include/vcl/task.hxx new file mode 100644 index 000000000..5ed8cde7f --- /dev/null +++ b/include/vcl/task.hxx @@ -0,0 +1,115 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_TASK_HXX +#define INCLUDED_VCL_TASK_HXX + +#include <vcl/dllapi.h> + +struct ImplSchedulerData; + +enum class TaskPriority +{ + HIGHEST, ///< These events should run very fast! + DEFAULT, ///< Default priority used, e.g. the default timer priority + // Input from the OS event queue is processed before HIGH_IDLE tasks. + HIGH_IDLE, ///< Important idle events to be run before processing drawing events + RESIZE, ///< Resize runs before repaint, so we won't paint twice + REPAINT, ///< All repaint events should go in here + POST_PAINT, ///< Everything running directly after painting + DEFAULT_IDLE, ///< Default idle priority + LOWEST ///< Low, very idle cleanup tasks +}; + +#define PRIO_COUNT (static_cast<int>(TaskPriority::LOWEST) + 1) + +class VCL_DLLPUBLIC Task +{ + friend class Scheduler; + friend struct ImplSchedulerData; + + ImplSchedulerData *mpSchedulerData; ///< Pointer to the element in scheduler list + const char *mpDebugName; ///< Useful for debugging + TaskPriority mePriority; ///< Task priority + bool mbActive; ///< Currently in the scheduler + bool mbStatic; ///< Is a static object + +protected: + static void StartTimer( sal_uInt64 nMS ); + + const ImplSchedulerData* GetSchedulerData() const { return mpSchedulerData; } + + virtual void SetDeletionFlags(); + + /** + * How long (in MS) until the Task is ready to be dispatched? + * + * Simply return Scheduler::ImmediateTimeoutMs if you're ready, like an + * Idle. If you have to return Scheduler::InfiniteTimeoutMs, you probably + * need another mechanism to wake up the Scheduler or rely on other + * Tasks to be scheduled, or simply use a polling Timer. + * + * @param nTimeNow the current time + * @return the sleep time of the Task to become ready + */ + virtual sal_uInt64 UpdateMinPeriod( sal_uInt64 nTimeNow ) const = 0; + +public: + Task( const char *pDebugName ); + Task( const Task& rTask ); + virtual ~Task() COVERITY_NOEXCEPT_FALSE; + Task& operator=( const Task& rTask ); + + void SetPriority(TaskPriority ePriority); + TaskPriority GetPriority() const { return mePriority; } + + const char *GetDebugName() const { return mpDebugName; } + + // Call handler + virtual void Invoke() = 0; + + /** + * Schedules the task for execution + * + * If the timer is already active, it's reset! + * Check with Task::IsActive() to prevent reset. + * + * If you unset bStartTimer, the Task must call Task::StartTimer(...) to be correctly scheduled! + * Otherwise it might just be picked up when the Scheduler runs the next time. + * + * @param bStartTimer if false, don't schedule the Task by calling Task::StartTimer(0). + */ + virtual void Start(bool bStartTimer = true); + void Stop(); + + bool IsActive() const { return mbActive; } + + /** + * This function must be called for static tasks, so the Task destructor + * ignores the scheduler mutex, as it may not be available anymore. + * The cleanup is still correct, as it has already happened in + * DeInitScheduler call well before the static destructor calls. + */ + void SetStatic() { mbStatic = true; } + bool IsStatic() const { return mbStatic; } +}; + +#endif // INCLUDED_VCL_TASK_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/taskpanelist.hxx b/include/vcl/taskpanelist.hxx new file mode 100644 index 000000000..c055882e7 --- /dev/null +++ b/include/vcl/taskpanelist.hxx @@ -0,0 +1,54 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_TASKPANELIST_HXX +#define INCLUDED_VCL_TASKPANELIST_HXX + +#include <vcl/dllapi.h> + +#include <vector> +#include <vcl/keycod.hxx> +#include <vcl/vclptr.hxx> + +class KeyEvent; + +namespace vcl { class Window; } + +class VCL_DLLPUBLIC TaskPaneList +{ + ::std::vector< VclPtr<vcl::Window> > mTaskPanes; + vcl::Window *FindNextFloat( vcl::Window *pWindow, bool bForward ); + vcl::Window *FindNextSplitter( vcl::Window *pWindow ); + +public: + bool IsInList( vcl::Window *pWindow ); + +public: + TaskPaneList(); + ~TaskPaneList(); + + void AddWindow( vcl::Window *pWindow ); + void RemoveWindow( vcl::Window *pWindow ); + bool HandleKeyEvent(const KeyEvent& rKeyEvent); + static bool IsCycleKey(const vcl::KeyCode& rKeyCode); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/test/GraphicsRenderTests.hxx b/include/vcl/test/GraphicsRenderTests.hxx new file mode 100644 index 000000000..014f0d71e --- /dev/null +++ b/include/vcl/test/GraphicsRenderTests.hxx @@ -0,0 +1,167 @@ +/* -*- 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/. + * + */ +#pragma once + +#include <vcl/bitmap.hxx> +#include <vcl/dllapi.h> +#include <vcl/test/TestResult.hxx> + +#include <vector> + +class VCL_PLUGIN_PUBLIC VclTestResult +{ + OUString m_aTestName; + //For storing the result of the test. + OUString m_aTestStatus; + //For storing the resultant bitmap correspondingly to the test. + Bitmap m_aResultantBitmap; + +public: + VclTestResult(OUString atestName, OUString atestStatus, Bitmap atestBitmap) + : m_aTestName(atestName) + , m_aTestStatus(atestStatus) + , m_aResultantBitmap(atestBitmap) + { + } + const OUString& getTestName() const { return m_aTestName; } + OUString getStatus(bool bLocalize = false); + const Bitmap& getBitmap() const { return m_aResultantBitmap; } +}; + +class VCL_PLUGIN_PUBLIC GraphicsRenderTests +{ + bool m_aStoreResultantBitmap; + + //For storing the test's info + std::vector<VclTestResult> m_aTestResult; + //For storing the current graphics Backend in use. + OUString m_aCurGraphicsBackend; + //Location where the results should be stored. + OUString m_aUserInstallPath; + + void testDrawRectWithRectangle(); + void testDrawRectWithPixel(); + void testDrawRectWithLine(); + void testDrawRectWithPolygon(); + void testDrawRectWithPolyLine(); + void testDrawRectWithPolyLineB2D(); + void testDrawRectWithPolyPolygon(); + void testDrawRectWithPolyPolygonB2D(); + void testDrawRectAAWithRectangle(); + void testDrawRectAAWithPixel(); + void testDrawRectAAWithLine(); + void testDrawRectAAWithPolygon(); + void testDrawRectAAWithPolyLine(); + void testDrawRectAAWithPolyLineB2D(); + void testDrawRectAAWithPolyPolygon(); + void testDrawRectAAWithPolyPolygonB2D(); + void testDrawFilledRectWithRectangle(); + void testDrawFilledRectWithPolygon(); + void testDrawFilledRectWithPolyPolygon(); + void testDrawFilledRectWithPolyPolygon2D(); + void testDrawDiamondWithPolygon(); + void testDrawDiamondWithLine(); + void testDrawDiamondWithPolyline(); + void testDrawDiamondWithPolylineB2D(); + void testDrawInvertWithRectangle(); + void testDrawInvertN50WithRectangle(); + void testDrawInvertTrackFrameWithRectangle(); + void testDrawDropShapeWithPolyline(); + void testDrawDropShapeAAWithPolyline(); + void testDrawBezierWithPolylineB2D(); + void testDrawBezierAAWithPolylineB2D(); + void testDrawDropShapeWithPolygon(); + void testDrawDropShapeAAWithPolygon(); + void testDrawBitmap24bpp(); + void testDrawTransformedBitmap24bpp(); + void testComplexDrawTransformedBitmap24bpp(); + void testDrawBitmapExWithAlpha24bpp(); + void testDrawMask24bpp(); + void testDrawBlend24bpp(); + void testDrawBitmap32bpp(); + void testDrawTransformedBitmap32bpp(); + void testDrawBitmapExWithAlpha32bpp(); + void testDrawMask32bpp(); + void testDrawBlend32bpp(); + void testDrawBitmap8bppGreyScale(); + void testDrawTransformedBitmap8bppGreyScale(); + void testDrawXor(); + void testClipRectangle(); + void testClipPolygon(); + void testClipPolyPolygon(); + void testClipB2DPolyPolygon(); + void testDrawOutDev(); + void testDrawOutDevScaledClipped(); + void testDrawOutDevSelf(); + void testDashedLine(); + void testLinearGradient(); + void testLinearGradientAngled(); + void testLinearGradientBorder(); + void testLinearGradientIntensity(); + void testLinearGradientSteps(); + void testAxialGradient(); + void testRadialGradient(); + void testRadialGradientOfs(); + void testLineJoinBevel(); + void testLineJoinRound(); + void testLineJoinMiter(); + void testLineJoinNone(); + void testLineCapRound(); + void testLineCapSquare(); + void testLineCapButt(); + void testHalfEllipseWithPolyLine(); + void testHalfEllipseAAWithPolyLine(); + void testHalfEllipseWithPolyLineB2D(); + void testHalfEllipseAAWithPolyLineB2D(); + void testHalfEllipseWithPolygon(); + void testHalfEllipseAAWithPolygon(); + void testClosedBezierWithPolyline(); + void testClosedBezierWithPolygon(); + void testFilledAsymmetricalDropShape(); + void testTextDrawing(); + void testEvenOddRuleInIntersectingRectsWithPolyPolygon(); + void testEvenOddRuleInIntersectingRectsWithPolyPolygonB2D(); + void testDrawRectangleOnSize1028WithRect(); + void testDrawRectangleOnSize4096WithRect(); + void testDrawRectangleOnSize1028WithPixel(); + void testDrawRectangleOnSize4096WithPixel(); + void testDrawRectangleOnSize1028WithLine(); + void testDrawRectangleOnSize4096WithLine(); + void testDrawRectangleOnSize1028WithPolygon(); + void testDrawRectangleOnSize4096WithPolygon(); + void testDrawRectangleOnSize1028WithPolyLine(); + void testDrawRectangleOnSize4096WithPolyLine(); + void testDrawRectangleOnSize1028WithPolyLineB2D(); + void testDrawRectangleOnSize4096WithPolyLineB2D(); + void testDrawRectangleOnSize1028WithPolyPolygon(); + void testDrawRectangleOnSize4096WithPolyPolygon(); + void testDrawRectangleOnSize1028WithPolyPolygonB2D(); + void testDrawRectangleOnSize4096WithPolygonPolygonB2D(); + void testDrawOpenPolygonWithPolyLine(); + void testDrawOpenPolygonWithPolyLineB2D(); + void testDrawOpenPolygonWithPolygon(); + void testDrawOpenPolygonWithPolyPolygon(); + void testDrawOpenPolygonWithPolyPolygonB2D(); + void testDrawOpenBezierWithPolyLine(); + void testDrawOpenBezierWithPolyLineB2D(); + static OUString returnTestStatus(vcl::test::TestResult const result); + void runALLTests(); + void appendTestResult(OUString aTestName, OUString aTestStatus, Bitmap aTestBitmap = Bitmap()); + +public: + std::vector<VclTestResult>& getTestResults(); + OUString getResultString(bool bLocalize = false); + void run(bool storeResultBitmap = false); + + GraphicsRenderTests() + : m_aStoreResultantBitmap(false) + { + } +}; diff --git a/include/vcl/test/TestResult.hxx b/include/vcl/test/TestResult.hxx new file mode 100644 index 000000000..c64d4e88b --- /dev/null +++ b/include/vcl/test/TestResult.hxx @@ -0,0 +1,26 @@ +/* -*- 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/. + * + */ + +#pragma once + +/** Rendering test result. + * + * Test either "Passed", "Failed" or "PassedWithQuirks" which means + * the test passed but at least one rendering quirk was detected. + */ +namespace vcl::test +{ +enum class TestResult +{ + Failed, + PassedWithQuirks, + Passed +}; +} diff --git a/include/vcl/textdata.hxx b/include/vcl/textdata.hxx new file mode 100644 index 000000000..907a6fdd8 --- /dev/null +++ b/include/vcl/textdata.hxx @@ -0,0 +1,143 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_TEXTDATA_HXX +#define INCLUDED_VCL_TEXTDATA_HXX + +#include <sal/types.h> +#include <rtl/ustring.hxx> +#include <svl/hint.hxx> +#include <vcl/dllapi.h> +#include <memory> + +enum class ExtTextInputAttr; + +// for Notify, if all paragraphs were deleted +#define TEXT_PARA_ALL SAL_MAX_UINT32 +#define TEXT_INDEX_ALL SAL_MAX_INT32 + +class TextPaM +{ +private: + sal_uInt32 mnPara; + sal_Int32 mnIndex; + +public: + TextPaM() : mnPara(0), mnIndex(0) {} + TextPaM( sal_uInt32 nPara, sal_Int32 nIndex ) : mnPara(nPara), mnIndex(nIndex) {} + + sal_uInt32 GetPara() const { return mnPara; } + sal_uInt32& GetPara() { return mnPara; } + + sal_Int32 GetIndex() const { return mnIndex; } + sal_Int32& GetIndex() { return mnIndex; } + + inline bool operator == ( const TextPaM& rPaM ) const; + inline bool operator != ( const TextPaM& rPaM ) const; + inline bool operator < ( const TextPaM& rPaM ) const; + inline bool operator > ( const TextPaM& rPaM ) const; +}; + +inline bool TextPaM::operator == ( const TextPaM& rPaM ) const +{ + return ( mnPara == rPaM.mnPara ) && ( mnIndex == rPaM.mnIndex ); +} + +inline bool TextPaM::operator != ( const TextPaM& rPaM ) const +{ + return !( *this == rPaM ); +} + +inline bool TextPaM::operator < ( const TextPaM& rPaM ) const +{ + return ( mnPara < rPaM.mnPara ) || + ( ( mnPara == rPaM.mnPara ) && mnIndex < rPaM.mnIndex ); +} + +inline bool TextPaM::operator > ( const TextPaM& rPaM ) const +{ + return ( mnPara > rPaM.mnPara ) || + ( ( mnPara == rPaM.mnPara ) && mnIndex > rPaM.mnIndex ); +} + +class VCL_DLLPUBLIC TextSelection +{ +private: + TextPaM maStartPaM; + TextPaM maEndPaM; + +public: + TextSelection(); + TextSelection( const TextPaM& rPaM ); + TextSelection( const TextPaM& rStart, const TextPaM& rEnd ); + + const TextPaM& GetStart() const { return maStartPaM; } + TextPaM& GetStart() { return maStartPaM; } + + const TextPaM& GetEnd() const { return maEndPaM; } + TextPaM& GetEnd() { return maEndPaM; } + + void Justify(); + + bool HasRange() const { return maStartPaM != maEndPaM; } + + inline bool operator == ( const TextSelection& rSel ) const; + inline bool operator != ( const TextSelection& rSel ) const; +}; + +inline bool TextSelection::operator == ( const TextSelection& rSel ) const +{ + return ( ( maStartPaM == rSel.maStartPaM ) && ( maEndPaM == rSel.maEndPaM ) ); +} + +inline bool TextSelection::operator != ( const TextSelection& rSel ) const +{ + return !( *this == rSel ); +} + +class VCL_DLLPUBLIC TextHint : public SfxHint +{ +private: + sal_Int32 mnValue; + +public: + TextHint( SfxHintId nId ); + TextHint( SfxHintId nId, sal_Int32 nValue ); + + sal_Int32 GetValue() const { return mnValue; } +}; + +struct TEIMEInfos +{ + OUString aOldTextAfterStartPos; + std::unique_ptr<ExtTextInputAttr[]> pAttribs; + TextPaM aPos; + sal_Int32 nLen; + bool bWasCursorOverwrite; + + TEIMEInfos(const TextPaM& rPos, const OUString& rOldTextAfterStartPos); + ~TEIMEInfos(); + + void CopyAttribs(const ExtTextInputAttr* pA, sal_Int32 nL); + void DestroyAttribs(); +}; + +#endif // INCLUDED_VCL_TEXTDATA_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/texteng.hxx b/include/vcl/texteng.hxx new file mode 100644 index 000000000..1dbbd5ba1 --- /dev/null +++ b/include/vcl/texteng.hxx @@ -0,0 +1,302 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_VCL_TEXTENG_HXX +#define INCLUDED_VCL_TEXTENG_HXX + +#include <memory> +#include <sal/config.h> + +#include <cstddef> +#include <vector> + +#include <vcl/dllapi.h> +#include <vcl/vclptr.hxx> +#include <rtl/ustring.hxx> +#include <svl/SfxBroadcaster.hxx> +#include <tools/lineend.hxx> +#include <tools/link.hxx> +#include <tools/gen.hxx> +#include <tools/color.hxx> +#include <vcl/font.hxx> +#include <vcl/vclenum.hxx> + +#include <com/sun/star/lang/Locale.hpp> +#include <com/sun/star/uno/Reference.hxx> + +class TextDoc; +class TextView; +class TextPaM; +class TextSelection; +class TEParaPortions; +class TextAttrib; +class TextCharAttrib; +class TextUndo; +class TextUndoManager; +class IdleFormatter; +class TextNode; +class OutputDevice; +class KeyEvent; +class Timer; +class SfxUndoManager; +class TextLine; +struct TEIMEInfos; + +namespace com::sun::star::i18n { + class XBreakIterator; + class XExtendedInputSequenceChecker; +} + +class LocaleDataWrapper; + +typedef std::vector<TextView*> TextViews; + +class VCL_DLLPUBLIC TextEngine : public SfxBroadcaster +{ + friend class TextView; + friend class TextSelFunctionSet; + friend class ExtTextEngine; + + friend class TextUndo; + friend class TextUndoManager; + friend class TextUndoDelPara; + friend class TextUndoConnectParas; + friend class TextUndoSplitPara; + friend class TextUndoInsertChars; + friend class TextUndoRemoveChars; + + std::unique_ptr<TextDoc> mpDoc; + std::unique_ptr<TEParaPortions> mpTEParaPortions; + VclPtr<OutputDevice> mpRefDev; + + std::unique_ptr<TextViews> mpViews; + TextView* mpActiveView; + + std::unique_ptr<TextUndoManager> mpUndoManager; + + std::unique_ptr<IdleFormatter> mpIdleFormatter; + + std::unique_ptr<TEIMEInfos> mpIMEInfos; + + css::lang::Locale maLocale; + css::uno::Reference< css::i18n::XBreakIterator > mxBreakIterator; + css::uno::Reference < css::i18n::XExtendedInputSequenceChecker > mxISC; + + tools::Rectangle maInvalidRect; + + std::unique_ptr<LocaleDataWrapper> mpLocaleDataWrapper; + + vcl::Font maFont; + Color maTextColor; + + sal_Int32 mnMaxTextLen; + tools::Long mnMaxTextWidth; + tools::Long mnCharHeight; + tools::Long mnCurTextWidth; + tools::Long mnCurTextHeight; + tools::Long mnDefTab; + + TxtAlign meAlign; + + bool mbIsFormatting : 1; // semaphore for the Hook's + bool mbFormatted : 1; + bool mbUpdate : 1; + bool mbModified : 1; + bool mbUndoEnabled : 1; + bool mbIsInUndo : 1; + bool mbDowning : 1; + bool mbRightToLeft : 1; + bool mbHasMultiLineParas : 1; + + void CursorMoved( sal_uInt32 nNode ); + void TextModified(); + + void ImpInitDoc(); + void ImpRemoveText(); + TextPaM ImpDeleteText( const TextSelection& rSel ); + TextPaM ImpInsertText( const TextSelection& rSel, sal_Unicode c, bool bOverwrite = false ); + TextPaM ImpInsertText( const TextSelection& rSel, const OUString& rText ); + TextPaM ImpInsertParaBreak( const TextSelection& rTextSelection ); + TextPaM ImpInsertParaBreak( const TextPaM& rPaM ); + void ImpRemoveChars( const TextPaM& rPaM, sal_Int32 nChars ); + TextPaM ImpConnectParagraphs( sal_uInt32 nLeft, sal_uInt32 nRight ); + void ImpRemoveParagraph( sal_uInt32 nPara ); + void ImpInitWritingDirections( sal_uInt32 nPara ); + LocaleDataWrapper* ImpGetLocaleDataWrapper(); + + // to remain compatible in the minor release we copy the above ImpInsertText + // function and add the extra parameter we need but make sure this function + // gets not exported. First and second parameter swapped to have a different signature. + SAL_DLLPRIVATE TextPaM ImpInsertText( sal_Unicode c, const TextSelection& rSel, bool bOverwrite, bool bIsUserInput = false ); + // some other new functions needed that must not be exported to remain compatible + SAL_DLLPRIVATE css::uno::Reference< css::i18n::XExtendedInputSequenceChecker > const & GetInputSequenceChecker(); + SAL_DLLPRIVATE bool IsInputSequenceCheckingRequired( sal_Unicode c, const TextSelection& rCurSel ) const; + + // broadcast or adjust selections + void ImpParagraphInserted( sal_uInt32 nPara ); + void ImpParagraphRemoved( sal_uInt32 nPara ); + void ImpCharsRemoved( sal_uInt32 nPara, sal_Int32 nPos, sal_Int32 nChars ); + void ImpCharsInserted( sal_uInt32 nPara, sal_Int32 nPos, sal_Int32 nChars ); + + DECL_DLLPRIVATE_LINK( IdleFormatHdl, Timer *, void ); + void CheckIdleFormatter(); + void IdleFormatAndUpdate( TextView* pCurView, sal_uInt16 nMaxTimerRestarts = 5 ); + + bool CreateLines( sal_uInt32 nPara ); + void CreateAndInsertEmptyLine( sal_uInt32 nPara ); + void ImpBreakLine( sal_uInt32 nPara, TextLine* pLine, sal_Int32 nPortionStart, tools::Long nRemainingWidth ); + std::size_t SplitTextPortion( sal_uInt32 nPara, sal_Int32 nPos ); + void CreateTextPortions( sal_uInt32 nPara, sal_Int32 nStartPos ); + void RecalcTextPortion( sal_uInt32 nPara, sal_Int32 nStartPos, sal_Int32 nNewChars ); + void SeekCursor( sal_uInt32 nNode, sal_Int32 nPos, vcl::Font& rFont, OutputDevice* pOutDev ); + + void FormatDoc(); + void FormatFullDoc(); + void FormatAndUpdate( TextView* pCurView = nullptr ); + bool IsFormatting() const { return mbIsFormatting; } + void UpdateViews( TextView* pCurView = nullptr ); + + void ImpPaint( OutputDevice* pOut, const Point& rStartPos, tools::Rectangle const* pPaintArea, TextSelection const* pSelection = nullptr ); + + bool IsFormatted() const { return mbFormatted; } + + sal_Int32 GetCharPos( sal_uInt32 nPara, std::vector<TextLine>::size_type nLine, tools::Long nDocPosX ); + tools::Rectangle GetEditCursor( const TextPaM& rPaM, bool bSpecial, bool bPreferPortionStart = false ); + sal_Int32 ImpFindIndex( sal_uInt32 nPortion, const Point& rPosInPara ); + tools::Long ImpGetPortionXOffset( sal_uInt32 nPara, TextLine const * pLine, std::size_t nTextPortion ); + tools::Long ImpGetXPos( sal_uInt32 nPara, TextLine* pLine, sal_Int32 nIndex, bool bPreferPortionStart = false ); + tools::Long ImpGetOutputOffset( sal_uInt32 nPara, TextLine* pLine, sal_Int32 nIndex, sal_Int32 nIndex2 ); + bool ImpGetRightToLeft( sal_uInt32 nPara, sal_Int32 nPos ); + static void ImpInitLayoutMode( OutputDevice* pOutDev ); + TxtAlign ImpGetAlign() const; + + tools::Long CalcTextHeight() const; + tools::Long CalcParaHeight( sal_uInt32 nParagraph ) const; + tools::Long CalcTextWidth( sal_uInt32 nPara ); + tools::Long CalcTextWidth( sal_uInt32 nPara, sal_Int32 nPortionStart, sal_Int32 nPortionLen); + Range GetInvalidYOffsets( sal_uInt32 nPortion ); + + // for Undo/Redo + void InsertContent( std::unique_ptr<TextNode> pNode, sal_uInt32 nPara ); + TextPaM SplitContent( sal_uInt32 nNode, sal_Int32 nSepPos ); + TextPaM ConnectContents( sal_uInt32 nLeftNode ); + + // adjust PaM's and selections that were transferred to the API to a valid range + void ValidateSelection( TextSelection& rSel ) const; + void ValidatePaM( TextPaM& rPaM ) const; + +public: + TextEngine(); + virtual ~TextEngine() override; + TextEngine( const TextEngine& ) = delete; + TextEngine& operator=( const TextEngine& ) = delete; + + void SetText( const OUString& rStr ); + OUString GetText( LineEnd aSeparator = LINEEND_LF ) const; + OUString GetText( const TextSelection& rSel, LineEnd aSeparator = LINEEND_LF ) const; + OUString GetTextLines( LineEnd aSeparator = LINEEND_LF ) const; + void ReplaceText(const TextSelection& rSel, const OUString& rText); + + sal_Int32 GetTextLen() const; + sal_Int32 GetTextLen( const TextSelection& rSel ) const; + + void SetFont( const vcl::Font& rFont ); + const vcl::Font& GetFont() const { return maFont; } + + void SetLeftMargin( sal_uInt16 n ); + + void SetUpdateMode( bool bUpdate ); + bool GetUpdateMode() const { return mbUpdate; } + + sal_uInt16 GetViewCount() const; + TextView* GetView( sal_uInt16 nView ) const; + void InsertView( TextView* pTextView ); + void RemoveView( TextView* pTextView ); + TextView* GetActiveView() const { return mpActiveView;} + void SetActiveView( TextView* pView ); + + void SetMaxTextLen( sal_Int32 nLen ); + sal_Int32 GetMaxTextLen() const { return mnMaxTextLen; } + + void SetMaxTextWidth( tools::Long nWidth ); + tools::Long GetMaxTextWidth() const { return mnMaxTextWidth; } + + tools::Long GetTextHeight() const; + tools::Long CalcTextWidth(); + tools::Long GetCharHeight() const { return mnCharHeight; } + + sal_uInt32 GetParagraphCount() const; + OUString GetText( sal_uInt32 nParagraph ) const; + sal_Int32 GetTextLen( sal_uInt32 nParagraph ) const; + tools::Long GetTextHeight( sal_uInt32 nParagraph ) const; + + void GetTextPortionRange(const TextPaM& rPaM, sal_Int32& nStart, sal_Int32& nEnd); + + sal_uInt16 GetLineCount( sal_uInt32 nParagraph ) const; + sal_Int32 GetLineLen( sal_uInt32 nParagraph, sal_uInt16 nLine ) const; + + void SetRightToLeft( bool bR2L ); + bool IsRightToLeft() const { return mbRightToLeft; } + + bool HasUndoManager() const { return mpUndoManager != nullptr; } + SfxUndoManager& GetUndoManager(); + void UndoActionStart( sal_uInt16 nId = 0 ); + void UndoActionEnd(); + void InsertUndo( std::unique_ptr<TextUndo> pUndo, bool bTryMerge = false ); + bool IsInUndo() const { return mbIsInUndo; } + void SetIsInUndo( bool bInUndo ) { mbIsInUndo = bInUndo; } + void ResetUndo(); + + void EnableUndo( bool bEnable ); + bool IsUndoEnabled() const { return mbUndoEnabled; } + + void SetModified( bool bModified ) { mbModified = bModified; } + bool IsModified() const { return mbModified; } + + bool Read( SvStream& rInput, const TextSelection* pSel = nullptr ); + + void Write( SvStream& rOutput ); + + TextPaM GetPaM( const Point& rDocPos ); + tools::Rectangle PaMtoEditCursor( const TextPaM& rPaM, bool bSpecial = false ); + OUString GetWord( const TextPaM& rCursorPos, TextPaM* pStartOfWord = nullptr, TextPaM* pEndOfWord = nullptr ); + + const TextAttrib* FindAttrib( const TextPaM& rPaM, sal_uInt16 nWhich ) const; + const TextCharAttrib* FindCharAttrib( const TextPaM& rPaM, sal_uInt16 nWhich ) const; + + void RemoveAttribs( sal_uInt32 nPara ); + void SetAttrib( const TextAttrib& rAttr, sal_uInt32 nPara, sal_Int32 nStart, sal_Int32 nEnd ); + + TxtAlign GetTextAlign() const { return meAlign; } + void SetTextAlign( TxtAlign eAlign ); + + void Draw( OutputDevice* pDev, const Point& rPos ); + + void SetLocale( const css::lang::Locale& rLocale ); + css::lang::Locale const & GetLocale(); + css::uno::Reference< css::i18n::XBreakIterator > const & GetBreakIterator(); + + static bool DoesKeyChangeText( const KeyEvent& rKeyEvent ); + static bool IsSimpleCharInput( const KeyEvent& rKeyEvent ); + + const Color& GetTextColor() const { return maTextColor; } +}; + +#endif // INCLUDED_VCL_TEXTENG_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/textfilter.hxx b/include/vcl/textfilter.hxx new file mode 100644 index 000000000..603daafd9 --- /dev/null +++ b/include/vcl/textfilter.hxx @@ -0,0 +1,31 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ +#ifndef INCLUDED_VCL_TEXTFILTER_HXX +#define INCLUDED_VCL_TEXTFILTER_HXX + +#include <vcl/dllapi.h> +#include <rtl/ustring.hxx> + +class VCL_DLLPUBLIC TextFilter +{ +private: + OUString sForbiddenChars; + +public: + void SetForbiddenChars(const OUString& rSet) { sForbiddenChars = rSet; } + + virtual OUString filter(const OUString& rText); + + TextFilter(const OUString& rForbiddenChars = OUString(" ")); + virtual ~TextFilter(); +}; + +#endif // INCLUDED_VCL_TEXTFILTER_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/textrectinfo.hxx b/include/vcl/textrectinfo.hxx new file mode 100644 index 000000000..2c212922f --- /dev/null +++ b/include/vcl/textrectinfo.hxx @@ -0,0 +1,61 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_TEXTRECTINFO_HXX +#define INCLUDED_VCL_TEXTRECTINFO_HXX + +#include <sal/config.h> + +#include <tools/long.hxx> +#include <vcl/dllapi.h> +class OutputDevice; + +class VCL_DLLPUBLIC TextRectInfo +{ + friend class ::OutputDevice; + +private: + tools::Long mnMaxWidth; + sal_uInt16 mnLineCount; + bool mbEllipsis; + +public: + TextRectInfo(); + + tools::Long GetMaxLineWidth() const { return mnMaxWidth; } + bool IsEllipses() const { return mbEllipsis; } + + bool operator ==( const TextRectInfo& rInfo ) const + { return ((mnMaxWidth == rInfo.mnMaxWidth) && + (mnLineCount == rInfo.mnLineCount) && + (mbEllipsis == rInfo.mbEllipsis)); } + bool operator !=( const TextRectInfo& rInfo ) const + { return !(TextRectInfo::operator==( rInfo )); } +}; + +inline TextRectInfo::TextRectInfo() +{ + mnMaxWidth = 0; + mnLineCount = 0; + mbEllipsis = false; +} + +#endif // INCLUDED_VCL_TEXTRECTINFO_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/textview.hxx b/include/vcl/textview.hxx new file mode 100644 index 000000000..29bc302d4 --- /dev/null +++ b/include/vcl/textview.hxx @@ -0,0 +1,229 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_TEXTVIEW_HXX +#define INCLUDED_VCL_TEXTVIEW_HXX + +#include <config_options.h> +#include <tools/gen.hxx> +#include <tools/lineend.hxx> +#include <tools/stream.hxx> +#include <vcl/dllapi.h> +#include <vcl/dndhelp.hxx> +#include <vcl/textdata.hxx> +#include <vcl/outdev.hxx> +#include <memory> + +class TextEngine; + +class KeyEvent; +class MouseEvent; +class CommandEvent; +namespace vcl { class Window; } + +namespace com::sun::star::datatransfer::clipboard { + class XClipboard; +} +namespace i18nutil { + struct SearchOptions; +} + + +struct ImpTextView; +class ExtTextEngine; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) TETextDataObject final : public css::datatransfer::XTransferable, + public ::cppu::OWeakObject + +{ +private: + OUString maText; + SvMemoryStream maHTMLStream; + +public: + explicit TETextDataObject( const OUString& rText ); + + SvMemoryStream& GetHTMLStream() { return maHTMLStream; } + + // css::uno::XInterface + css::uno::Any SAL_CALL queryInterface( const css::uno::Type & rType ) override; + void SAL_CALL acquire() noexcept override { OWeakObject::acquire(); } + void SAL_CALL release() noexcept override { OWeakObject::release(); } + + // css::datatransfer::XTransferable + css::uno::Any SAL_CALL getTransferData( const css::datatransfer::DataFlavor& aFlavor ) override; + css::uno::Sequence< css::datatransfer::DataFlavor > SAL_CALL getTransferDataFlavors( ) override; + sal_Bool SAL_CALL isDataFlavorSupported( const css::datatransfer::DataFlavor& aFlavor ) override; +}; + + +class VCL_DLLPUBLIC TextView final : public vcl::unohelper::DragAndDropClient +{ + friend class TextEngine; + friend class TextUndo; + friend class TextUndoManager; + friend class TextSelFunctionSet; + + std::unique_ptr<ImpTextView> mpImpl; + + TextView( const TextView& ) = delete; + TextView& operator=( const TextView& ) = delete; + + bool ImpIndentBlock( bool bRight ); + void ShowSelection(); + void HideSelection(); + void ShowSelection( const TextSelection& rSel ); + void ImpShowHideSelection( const TextSelection* pRange = nullptr ); + + TextSelection const & ImpMoveCursor( const KeyEvent& rKeyEvent ); + TextPaM ImpDelete( sal_uInt8 nMode, sal_uInt8 nDelMode ); + bool IsInSelection( const TextPaM& rPaM ) const; + + void ImpPaint(vcl::RenderContext& rRenderContext, const Point& rStartPos, tools::Rectangle const* pPaintArea, TextSelection const* pSelection); + void ImpPaint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect); + void ImpShowCursor( bool bGotoCursor, bool bForceVisCursor, bool bEndKey ); + void ImpSetSelection( const TextSelection& rSelection ); + Point ImpGetOutputStartPos( const Point& rStartDocPos ) const; + + void ImpHideDDCursor(); + void ImpShowDDCursor(); + + bool ImplTruncateNewText( OUString& rNewText ) const; + bool ImplCheckTextLen( const OUString& rNewText ) const; + + // DragAndDropClient + virtual void dragGestureRecognized( const css::datatransfer::dnd::DragGestureEvent& dge ) override; + virtual void dragDropEnd( const css::datatransfer::dnd::DragSourceDropEvent& dsde ) override; + virtual void drop( const css::datatransfer::dnd::DropTargetDropEvent& dtde ) override; + virtual void dragEnter( const css::datatransfer::dnd::DropTargetDragEnterEvent& dtdee ) override; + virtual void dragExit( const css::datatransfer::dnd::DropTargetEvent& dte ) override; + virtual void dragOver( const css::datatransfer::dnd::DropTargetDragEvent& dtde ) override; + + using DragAndDropClient::dragEnter; + using DragAndDropClient::dragExit; + using DragAndDropClient::dragOver; + +public: + TextView( ExtTextEngine* pEng, vcl::Window* pWindow ); + virtual ~TextView() override; + + TextEngine* GetTextEngine() const; + vcl::Window* GetWindow() const; + + void Invalidate(); + void Scroll( tools::Long nHorzScroll, tools::Long nVertScroll ); + + void ShowCursor( bool bGotoCursor = true, bool bForceVisCursor = true ); + void HideCursor(); + + void EnableCursor( bool bEnable ); + bool IsCursorEnabled() const; + + const TextSelection& GetSelection() const; + TextSelection& GetSelection(); + void SetSelection( const TextSelection& rNewSel ); + void SetSelection( const TextSelection& rNewSel, bool bGotoCursor ); + bool HasSelection() const; + + OUString GetSelected() const; + OUString GetSelected( LineEnd aSeparator ) const; + void DeleteSelected(); + + void InsertText( const OUString& rNew ); + + bool KeyInput( const KeyEvent& rKeyEvent ); + void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect); + void MouseButtonUp( const MouseEvent& rMouseEvent ); + void MouseButtonDown( const MouseEvent& rMouseEvent ); + void MouseMove( const MouseEvent& rMouseEvent ); + void Command( const CommandEvent& rCEvt ); + + void Cut(); + void Copy(); + void Paste(); + + void Copy( css::uno::Reference< css::datatransfer::clipboard::XClipboard > const & rxClipboard ); + void Paste( css::uno::Reference< css::datatransfer::clipboard::XClipboard > const & rxClipboard ); + + void Undo(); + void Redo(); + + void Read( SvStream& rInput ); + + void SetStartDocPos( const Point& rPos ); + const Point& GetStartDocPos() const; + + Point GetDocPos( const Point& rWindowPos ) const; + Point GetWindowPos( const Point& rDocPos ) const; + + void SetInsertMode( bool bInsert ); + bool IsInsertMode() const; + + void SetAutoIndentMode( bool bAutoIndent ); + + void SetReadOnly( bool bReadOnly ); + bool IsReadOnly() const; + + void SetAutoScroll( bool bAutoScroll ); + bool IsAutoScroll() const; + + void SetCursorAtPoint( const Point& rPointPixel ); + bool IsSelectionAtPoint( const Point& rPointPixel ); + + void SetPaintSelection( bool bPaint); + + // Moved in here from the protected part. + // For 'SvtXECTextCursor' (TL). Possibly needs to be solved again differently. + TextPaM PageUp( const TextPaM& rPaM ); + TextPaM PageDown( const TextPaM& rPaM ); + TextPaM CursorUp( const TextPaM& rPaM ); + TextPaM CursorDown( const TextPaM& rPaM ); + TextPaM CursorLeft( const TextPaM& rPaM, sal_uInt16 nCharacterIteratorMode ); + TextPaM CursorRight( const TextPaM& rPaM, sal_uInt16 nCharacterIteratorMode ); + TextPaM CursorFirstWord( const TextPaM& rPaM ); + TextPaM CursorWordLeft( const TextPaM& rPaM ); + TextPaM CursorWordRight( const TextPaM& rPaM ); + TextPaM CursorStartOfLine( const TextPaM& rPaM ); + TextPaM CursorEndOfLine( const TextPaM& rPaM ); + static TextPaM CursorStartOfParagraph( const TextPaM& rPaM ); + TextPaM CursorEndOfParagraph( const TextPaM& rPaM ); + static TextPaM CursorStartOfDoc(); + TextPaM CursorEndOfDoc(); + + /** + Returns the number in paragraph of the line in which the cursor is blinking + if enabled, -1 otherwise. + */ + sal_Int32 GetLineNumberOfCursorInSelection() const; + + void MatchGroup(); + + // tdf#49482: Moves the start of the PaM to the center of the textview + void CenterPaM( const TextPaM& rPaM ); + + bool Search( const i18nutil::SearchOptions& rSearchOptions, bool bForward ); + sal_uInt16 Replace( const i18nutil::SearchOptions& rSearchOptions, bool bAll, bool bForward ); + + bool IndentBlock(); + bool UnindentBlock(); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/threadex.hxx b/include/vcl/threadex.hxx new file mode 100644 index 000000000..af2978ce3 --- /dev/null +++ b/include/vcl/threadex.hxx @@ -0,0 +1,174 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_THREADEX_HXX +#define INCLUDED_VCL_THREADEX_HXX + +#include <osl/conditn.hxx> +#include <tools/link.hxx> +#include <vcl/dllapi.h> + +#include <optional> +#include <memory> + +namespace vcl +{ + class VCL_DLLPUBLIC SolarThreadExecutor + { + osl::Condition m_aStart; + osl::Condition m_aFinish; + bool m_bTimeout; + + DECL_DLLPRIVATE_LINK( worker, void*, void ); + + public: + SolarThreadExecutor(); + virtual ~SolarThreadExecutor(); + + virtual void doIt() = 0; + void execute(); + }; + +namespace solarthread { + +/// @internal +namespace detail { + +template <typename FuncT, typename ResultT> +class GenericSolarThreadExecutor final : public SolarThreadExecutor +{ +public: + static ResultT exec( FuncT const& func ) + { + typedef GenericSolarThreadExecutor<FuncT, ResultT> ExecutorT; + ::std::unique_ptr<ExecutorT> const pExecutor( new ExecutorT(func) ); + pExecutor->execute(); + if (pExecutor->m_exc) + std::rethrow_exception(pExecutor->m_exc); + return *pExecutor->m_result; + } + +private: + explicit GenericSolarThreadExecutor( FuncT const& func ) + : m_func(func), m_result() {} + + virtual void doIt() override + { + try { + m_result = m_func(); + } + catch (...) { + m_exc = std::current_exception(); + } + } + + std::exception_ptr m_exc; +#ifdef _MSC_VER + FuncT m_func; // "const" and std::bind() results in Error C3848 expression would lose const-volatile qualifiers +#else + FuncT const m_func; +#endif + // using std::optional here omits the need that ResultT is default + // constructable: + ::std::optional<ResultT> m_result; +}; + +template <typename FuncT> +class GenericSolarThreadExecutor<FuncT, void> final : public SolarThreadExecutor +{ +public: + static void exec( FuncT const& func ) + { + typedef GenericSolarThreadExecutor<FuncT, void> ExecutorT; + ::std::unique_ptr<ExecutorT> const pExecutor( new ExecutorT(func) ); + pExecutor->execute(); + if (pExecutor->m_exc) + std::rethrow_exception(pExecutor->m_exc); + } + +private: + explicit GenericSolarThreadExecutor( FuncT const& func ) + : m_func(func) {} + + virtual void doIt() override + { + try { + m_func(); + } + catch (...) { + m_exc = std::current_exception(); + } + } + + std::exception_ptr m_exc; + FuncT const m_func; +}; + +} // namespace detail + + +/** This function will execute the passed functor synchronously in the + solar thread, thus the calling thread will (eventually) be blocked until + the functor has been called. + Any exception that came up calling the functor in the solar thread + will be caught and rethrown in the calling thread. + The result type of this function needs to be default constructable. + Please keep in mind not to pass addresses to stack variables + (e.g. for out parameters) to foreign threads, use inout_by_ref() + for this purpose. For in parameters, this may not affect you, because + the functor object is copy constructed into free store. This way + you must not use \verbatim std::cref()/std::ref() \endverbatim or similar + for objects on your thread's stack. + Use inout_by_ref() or inout_by_ptr() for this purpose, e.g. + + \code{.cpp} + using namespace vcl::solarthread; + + long n = 3; + // calling foo( long & r ): + syncExecute( std::bind( &foo, inout_by_ref(n) ) ); + // calling foo( long * p ): + syncExecute( std::bind( &foo, inout_by_ptr(&n) ) ); + + char const* pc = "default"; + // calling foo( char const** ppc ): + syncExecute( std::bind( &foo, inout_by_ptr(&pc) ) ); + // calling foo( char const*& rpc ): + syncExecute( std::bind( &foo, inout_by_ref(pc) ) ); + \endcode + + @tpl ResultT result type, defaults to FuncT::result_type to seamlessly + support mem_fn and bind + @tpl FuncT functor type, let your compiler deduce this type + @param func functor object to be executed in solar thread + @return return value of functor +*/ +template <typename FuncT> +inline auto syncExecute(FuncT const& func) -> decltype(func()) +{ + return detail::GenericSolarThreadExecutor< + FuncT, decltype(func())>::exec(func); +} + +} // namespace solarthread +} // namespace vcl + +#endif // INCLUDED_VCL_THREADEX_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/timer.hxx b/include/vcl/timer.hxx new file mode 100644 index 000000000..89cc623a1 --- /dev/null +++ b/include/vcl/timer.hxx @@ -0,0 +1,77 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_TIMER_HXX +#define INCLUDED_VCL_TIMER_HXX + +#include <tools/link.hxx> +#include <vcl/task.hxx> + +class VCL_DLLPUBLIC Timer : public Task +{ + Link<Timer *, void> maInvokeHandler; ///< Callback Link + sal_uInt64 mnTimeout; + const bool mbAuto; + +protected: + virtual void SetDeletionFlags() override; + virtual sal_uInt64 UpdateMinPeriod( sal_uInt64 nTimeNow ) const override; + + Timer( bool bAuto, const char *pDebugName ); + +public: + Timer( const char *pDebugName ); + Timer( const Timer& rTimer ); + virtual ~Timer() override; + Timer& operator=( const Timer& rTimer ); + + /** + * Calls the maInvokeHandler with the parameter this. + */ + virtual void Invoke() override; + /** + * Calls the maInvokeHandler with the parameter. + * + * Convenience Invoke function, mainly used to call with nullptr. + * + * @param arg parameter for the Link::Call function + */ + void Invoke( Timer *arg ); + void SetInvokeHandler( const Link<Timer *, void>& rLink ) { maInvokeHandler = rLink; } + void ClearInvokeHandler() { SetInvokeHandler( Link<Timer *, void>() ); } + + void SetTimeout( sal_uInt64 nTimeoutMs ); + sal_uInt64 GetTimeout() const { return mnTimeout; } + virtual void Start(bool bStartTimer = true) override; +}; + +/// An auto-timer is a multi-shot timer re-emitting itself at +/// interval until destroyed or stopped. +class VCL_DLLPUBLIC AutoTimer : public Timer +{ +public: + AutoTimer( const char *pDebugName ); +}; + +/// Value suitable as a timeout user input into an EditBox to an expensive update +#define EDIT_UPDATEDATA_TIMEOUT 350 + +#endif // INCLUDED_VCL_TIMER_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolbox.hxx b/include/vcl/toolbox.hxx new file mode 100644 index 000000000..dda33ff02 --- /dev/null +++ b/include/vcl/toolbox.hxx @@ -0,0 +1,537 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_TOOLBOX_HXX +#define INCLUDED_VCL_TOOLBOX_HXX + +#include <vcl/vclenum.hxx> +#include <vcl/dllapi.h> +#include <vcl/dockwin.hxx> +#include <vcl/image.hxx> +#include <vcl/keycod.hxx> +#include <vcl/toolboxid.hxx> +#include <o3tl/typed_flags_set.hxx> +#include <tools/degree.hxx> + +#include <limits> +#include <memory> +#include <vector> + +namespace com::sun::star::frame { class XFrame; } +namespace com::sun::star::frame { struct FeatureStateEvent; } +template <class T> class VclStatusListener; + +class Timer; +struct ImplToolItem; +struct ImplToolBoxPrivateData; +class PopupMenu; +class VclMenuEvent; +class StyleSettings; + +// item ids in the custom menu may not exceed this constant +constexpr sal_uInt16 TOOLBOX_MENUITEM_START = 0x1000; + +// defines for the menubutton +enum class ToolBoxMenuType { + NONE = 0x0000, // no menu at all, scrolling by spin buttons + ClippedItems = 0x0001, // menu will contain "more" indicator + Customize = 0x0002 // menu will contain "customization" and "more" indicator +}; +namespace o3tl +{ + template<> struct typed_flags<ToolBoxMenuType> : is_typed_flags<ToolBoxMenuType, 0x0003> {}; +} + +enum class ToolBoxLayoutMode +{ + Normal, // traditional layout, items are centered in the toolbar + Locked // horizontal positions of all items remain unchanged, + // vertical positions of items smaller than first item are aligned to first item's vertical center, + // vertical positions of items larger than first item remain unchanged +}; + +// Position of the text when icon and text are painted +enum class ToolBoxTextPosition { Right, Bottom }; + +class Idle; + +/// A toolbar: contains all those icons, typically below the menu bar. +class VCL_DLLPUBLIC ToolBox : public DockingWindow +{ + friend class FloatingWindow; + friend class ImplTBDragMgr; + +public: + using ImplToolItems = std::vector<ImplToolItem>; + + virtual FactoryFunction GetUITestFactory() const override; + + void SetCurItemId( ToolBoxItemId CurID ) { mnCurItemId=CurID; } + + static constexpr auto APPEND + = std::numeric_limits<ImplToolItems::size_type>::max(); + + static constexpr auto ITEM_NOTFOUND + = std::numeric_limits<ImplToolItems::size_type>::max(); + +private: + struct ImplToolSize + { + tools::Long mnWidth; + tools::Long mnHeight; + ImplToolItems::size_type mnLines; + }; + + std::unique_ptr<ImplToolBoxPrivateData> mpData; + std::vector<ImplToolSize> maFloatSizes; + std::unique_ptr<Idle> mpIdle; + tools::Rectangle maUpperRect; + tools::Rectangle maLowerRect; + tools::Rectangle maPaintRect; + VclPtr<FloatingWindow> mpFloatWin; + tools::Long mnDX; + tools::Long mnDY; + tools::Long mnMaxItemWidth; // max item width + tools::Long mnMaxItemHeight; // max item height (for standard items) + tools::Long mnWinHeight; // max window height (for window items) + tools::Long mnLeftBorder; // inner border + tools::Long mnTopBorder; + tools::Long mnRightBorder; + tools::Long mnBottomBorder; + tools::Long mnLastResizeDY; + tools::Long mnActivateCount; + Degree10 mnImagesRotationAngle; + ToolBoxItemId mnLastFocusItemId; + ToolBoxItemId mnHighItemId; + ToolBoxItemId mnCurItemId; + ToolBoxItemId mnDownItemId; + ImplToolItems::size_type mnCurPos; + ImplToolItems::size_type mnLines; // total number of toolbox lines + ImplToolItems::size_type mnCurLine; // the currently visible line + ImplToolItems::size_type mnCurLines; // number of lines due to line breaking + ImplToolItems::size_type mnVisLines; // number of visible lines (for scrolling) + ImplToolItems::size_type mnFloatLines; // number of lines during floating mode + ImplToolItems::size_type mnDockLines; + sal_uInt16 mnMouseModifier; + bool mbDrag:1, + mbUpper:1, + mbLower:1, + mbIn:1, + mbCalc:1, + mbFormat:1, + mbFullPaint:1, + mbHorz:1, + mbScroll:1, + mbLastFloatMode:1, + mbCustomize:1, + mbDragging:1, + mbIsKeyEvent:1, + mbChangingHighlight:1, + mbImagesMirrored:1, + mbLineSpacing:1, + mbIsArranged:1; + WindowAlign meAlign; + WindowAlign meDockAlign; + ButtonType meButtonType; + PointerStyle meLastStyle; + WinBits mnWinStyle; + ToolBoxLayoutMode meLayoutMode; + ToolBoxTextPosition meTextPosition; + Link<ToolBox *, void> maClickHdl; + Link<ToolBox *, void> maDoubleClickHdl; + Link<ToolBox *, void> maActivateHdl; + Link<ToolBox *, void> maDeactivateHdl; + Link<ToolBox *, void> maSelectHdl; + Link<ToolBox *, void> maMenuButtonHdl; + Link<StateChangedType const *, void> maStateChangedHandler; + Link<DataChangedEvent const *, void> maDataChangedHandler; + /** StatusListener. Notifies about rotated images etc */ + rtl::Reference<VclStatusListener<ToolBox>> mpStatusListener; + +public: + using Window::ImplInit; +private: + SAL_DLLPRIVATE void InvalidateItem(ImplToolItems::size_type nPosition); + SAL_DLLPRIVATE void InvalidateSpin(bool bInvalidateUpper = true, + bool bInvalidateLower = true); + SAL_DLLPRIVATE void InvalidateMenuButton(); + + SAL_DLLPRIVATE void ImplInitToolBoxData(); + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + using DockingWindow::ImplInitSettings; + SAL_DLLPRIVATE void ImplInitSettings( bool bFont, bool bForeground, bool bBackground ); + SAL_DLLPRIVATE ImplToolItem* ImplGetItem( ToolBoxItemId nId ) const; + SAL_DLLPRIVATE bool ImplCalcItem(); + SAL_DLLPRIVATE ImplToolItems::size_type ImplCalcBreaks( tools::Long nWidth, sal_Int32* pMaxLineWidth, bool bCalcHorz ) const; + SAL_DLLPRIVATE void ImplFormat( bool bResize = false ); + SAL_DLLPRIVATE void ImplDrawSpin(vcl::RenderContext& rRenderContext); + SAL_DLLPRIVATE void ImplDrawSeparator(vcl::RenderContext& rRenderContext, ImplToolItems::size_type nPos, const tools::Rectangle& rRect); + SAL_DLLPRIVATE void ImplDrawItem(vcl::RenderContext& rRenderContext, ImplToolItems::size_type nPos, sal_uInt16 nHighlight ); + using Window::ImplInvalidate; + SAL_DLLPRIVATE void ImplInvalidate( bool bNewCalc = false, bool bFullPaint = false ); + SAL_DLLPRIVATE void ImplUpdateItem( ImplToolItems::size_type nIndex = ITEM_NOTFOUND ); + SAL_DLLPRIVATE bool ImplHandleMouseMove( const MouseEvent& rMEvt, bool bRepeat = false ); + SAL_DLLPRIVATE bool ImplHandleMouseButtonUp( const MouseEvent& rMEvt, bool bCancel = false ); + SAL_DLLPRIVATE void ImplChangeHighlight( ImplToolItem const * pItem, bool bNoGrabFocus = false ); + SAL_DLLPRIVATE bool ImplChangeHighlightUpDn( bool bUp, bool bNoCycle = false ); + SAL_DLLPRIVATE ImplToolItems::size_type ImplGetItemLine( ImplToolItem const * pCurrentItem ); + SAL_DLLPRIVATE ImplToolItem* ImplGetFirstValidItem( ImplToolItems::size_type nLine ); + SAL_DLLPRIVATE bool ImplOpenItem( vcl::KeyCode aKeyCode ); + SAL_DLLPRIVATE bool ImplActivateItem( vcl::KeyCode aKeyCode ); + SAL_DLLPRIVATE void ImplShowFocus(); + SAL_DLLPRIVATE void ImplHideFocus(); + SAL_DLLPRIVATE void ImplUpdateInputEnable(); + SAL_DLLPRIVATE void ImplFillLayoutData(); + SAL_DLLPRIVATE bool ImplHasClippedItems(); + SAL_DLLPRIVATE Point ImplGetPopupPosition( const tools::Rectangle& rRect ) const; + SAL_DLLPRIVATE bool ImplIsFloatingMode() const; + SAL_DLLPRIVATE bool ImplIsInPopupMode() const; + SAL_DLLPRIVATE const OUString& ImplGetHelpText( ToolBoxItemId nItemId ) const; + SAL_DLLPRIVATE Size ImplGetOptimalFloatingSize(); + SAL_DLLPRIVATE bool ImplHasExternalMenubutton() const; + SAL_DLLPRIVATE void ImplDrawFloatwinBorder(vcl::RenderContext& rRenderContext, ImplToolItem const * pItem ); + + DECL_DLLPRIVATE_LINK( ImplUpdateHdl, Timer*, void ); + DECL_DLLPRIVATE_LINK( ImplCustomMenuListener, VclMenuEvent&, void ); + DECL_DLLPRIVATE_LINK( ImplDropdownLongClickHdl, Timer*, void ); + + ToolBox (const ToolBox &) = delete; + ToolBox& operator= (const ToolBox &) = delete; + +public: + SAL_DLLPRIVATE void ImplFloatControl( bool bStart, FloatingWindow* pWindow ); + + SAL_DLLPRIVATE int ImplGetDragWidth() const; + static SAL_DLLPRIVATE int ImplGetDragWidth( const vcl::RenderContext& rRenderContext, + bool bHorz ); + static SAL_DLLPRIVATE int ImplGetDragWidth( const vcl::Window& rWindow, + bool bHorz ); + SAL_DLLPRIVATE void ImplUpdateDragArea() const; + SAL_DLLPRIVATE void ImplCalcBorder( WindowAlign eAlign, tools::Long& rLeft, tools::Long& rTop, + tools::Long& rRight, tools::Long& rBottom ) const; + SAL_DLLPRIVATE void ImplCheckUpdate(); + static SAL_DLLPRIVATE void ImplDrawGrip(vcl::RenderContext& rRenderContext, + const tools::Rectangle &aDragArea, int nDragWidth, + WindowAlign eAlign, bool bHorz); + + SAL_DLLPRIVATE void ImplDrawGrip(vcl::RenderContext& rRenderContext); + SAL_DLLPRIVATE void ImplDrawGradientBackground(vcl::RenderContext& rRenderContext); + SAL_DLLPRIVATE bool ImplDrawNativeBackground(vcl::RenderContext& rRenderContext) const; + SAL_DLLPRIVATE void ImplDrawTransparentBackground(const vcl::Region &rRegion); + SAL_DLLPRIVATE static void ImplDrawConstantBackground(vcl::RenderContext& rRenderContext, const vcl::Region &rRegion, bool bIsInPopupMode); + SAL_DLLPRIVATE void ImplDrawBackground(vcl::RenderContext& rRenderContext, const tools::Rectangle &rRect); + + SAL_DLLPRIVATE void ImplErase(vcl::RenderContext& rRenderContext, const tools::Rectangle &rRect, bool bHighlight, bool bHasOpenPopup = false ); + + SAL_DLLPRIVATE void ImplDrawBorder(vcl::RenderContext& rRenderContext); + SAL_DLLPRIVATE const ImplToolItem *ImplGetFirstClippedItem() const; + SAL_DLLPRIVATE Size ImplCalcSize( ImplToolItems::size_type nCalcLines, sal_uInt16 nCalcMode = 0 ); + SAL_DLLPRIVATE void ImplCalcFloatSizes(); + SAL_DLLPRIVATE Size ImplCalcFloatSize( ImplToolItems::size_type& rLines ); + SAL_DLLPRIVATE void ImplCalcMinMaxFloatSize( Size& rMinSize, Size& rMaxSize ); + SAL_DLLPRIVATE void ImplSetMinMaxFloatSize(); + SAL_DLLPRIVATE ImplToolItems::size_type ImplCalcLines( tools::Long nToolSize ) const; + SAL_DLLPRIVATE sal_uInt16 ImplTestLineSize( const Point& rPos ) const; + SAL_DLLPRIVATE void ImplLineSizing( const Point& rPos, tools::Rectangle& rRect, sal_uInt16 nLineMode ); + SAL_DLLPRIVATE static ImplToolItems::size_type ImplFindItemPos( const ImplToolItem* pItem, const ImplToolItems& rList ); + SAL_DLLPRIVATE void ImplDrawMenuButton(vcl::RenderContext& rRenderContext, bool bHighlight); + SAL_DLLPRIVATE void ImplDrawButton(vcl::RenderContext& rRenderContext, const tools::Rectangle &rRect, sal_uInt16 highlight, bool bChecked, bool bEnabled, bool bIsWindow); + SAL_DLLPRIVATE ImplToolItems::size_type ImplCountLineBreaks() const; + SAL_DLLPRIVATE ImplToolBoxPrivateData* ImplGetToolBoxPrivateData() const { return mpData.get(); } + + SAL_DLLPRIVATE void ApplyBackgroundSettings(vcl::RenderContext&, const StyleSettings&); + SAL_DLLPRIVATE void ApplyForegroundSettings(vcl::RenderContext&, const StyleSettings&); + +protected: + virtual void ApplySettings(vcl::RenderContext& rRenderContext) override; + +public: + ToolBox(vcl::Window* pParent, WinBits nStyle = 0); + ToolBox(vcl::Window* pParent, const OString& rID, const OUString& rUIXMLDescription, + const css::uno::Reference<css::frame::XFrame> &rFrame = css::uno::Reference<css::frame::XFrame>()); + virtual ~ToolBox() override; + virtual void dispose() override; + + virtual void Click(); + void DoubleClick(); + virtual void Activate() override; + virtual void Deactivate() override; + void Highlight(); + virtual void Select(); + + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void MouseButtonUp( const MouseEvent& rMEvt ) override; + virtual void MouseMove( const MouseEvent& rMEvt ) override; + virtual void Tracking( const TrackingEvent& rTEvt ) override; + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Resize() override; + virtual void RequestHelp( const HelpEvent& rHEvt ) override; + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void Command( const CommandEvent& rCEvt ) override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + virtual void LoseFocus() override; + virtual void KeyInput( const KeyEvent& rKEvt ) override; + + virtual void ToggleFloatingMode() override; + virtual void StartDocking() override; + virtual bool Docking( const Point& rPos, tools::Rectangle& rRect ) override; + virtual void EndDocking( const tools::Rectangle& rRect, bool bFloatMode ) override; + virtual void Resizing( Size& rSize ) override; + virtual Size GetOptimalSize() const override; + virtual void doDeferredInit(WinBits nBits) override; + virtual void queue_resize(StateChangedType eReason = StateChangedType::Layout) override; + + /// Insert a command (like '.uno:Save'). + virtual void InsertItem( const OUString& rCommand, + const css::uno::Reference<css::frame::XFrame>& rFrame, + ToolBoxItemBits nBits, + const Size& rRequestedSize, + ImplToolItems::size_type nPos = APPEND ); + void InsertItem( ToolBoxItemId nItemId, const Image& rImage, + ToolBoxItemBits nBits = ToolBoxItemBits::NONE, + ImplToolItems::size_type nPos = APPEND ); + void InsertItem( ToolBoxItemId nItemId, const Image& rImage, + const OUString& rText, + ToolBoxItemBits nBits = ToolBoxItemBits::NONE, + ImplToolItems::size_type nPos = APPEND ); + void InsertItem( ToolBoxItemId nItemId, const OUString& rText, + ToolBoxItemBits nBits = ToolBoxItemBits::NONE, + ImplToolItems::size_type nPos = APPEND ); + void InsertWindow( ToolBoxItemId nItemId, vcl::Window* pWindow, + ToolBoxItemBits nBits = ToolBoxItemBits::NONE, + ImplToolItems::size_type nPos = APPEND ); + void InsertSpace(); + void InsertSeparator( ImplToolItems::size_type nPos = APPEND, sal_uInt16 nPixSize = 0 ); + void InsertBreak( ImplToolItems::size_type nPos = APPEND ); + void RemoveItem( ImplToolItems::size_type nPos ); + void CopyItem( const ToolBox& rToolBox, ToolBoxItemId nItemId ); + void Clear(); + + void SetButtonType( ButtonType eNewType ); + ButtonType GetButtonType() const { return meButtonType; } + + // sets a fixed button size (small, large or dontcare (==autosize)) + void SetToolboxButtonSize( ToolBoxButtonSize eSize ); + ToolBoxButtonSize GetToolboxButtonSize() const; + vcl::ImageType GetImageSize() const; + + void SetAlign( WindowAlign eNewAlign = WindowAlign::Top ); + WindowAlign GetAlign() const { return meAlign; } + bool IsHorizontal() const { return mbHorz; } + + void SetLineCount( ImplToolItems::size_type nNewLines ); + void ShowLine( bool bNext ); + + ImplToolItems::size_type GetItemCount() const; + ToolBoxItemType GetItemType( ImplToolItems::size_type nPos ) const; + ImplToolItems::size_type GetItemPos( ToolBoxItemId nItemId ) const; + ImplToolItems::size_type GetItemPos( const Point& rPos ) const; + ToolBoxItemId GetItemId( ImplToolItems::size_type nPos ) const; + ToolBoxItemId GetItemId( const Point& rPos ) const; + /// Map the command name (like .uno:Save) back to item id. + ToolBoxItemId GetItemId( const OUString& rCommand ) const; + tools::Rectangle GetItemRect( ToolBoxItemId nItemId ); + tools::Rectangle GetItemPosRect( ImplToolItems::size_type nPos ); + tools::Rectangle const & GetOverflowRect() const; + + /// Returns size of the bitmap / text that is inside this toolbox item. + Size GetItemContentSize( ToolBoxItemId nItemId ); + + ToolBoxItemId GetCurItemId() const { return mnCurItemId; } + ToolBoxItemId GetDownItemId() const { return mnDownItemId; } + sal_uInt16 GetModifier() const { return mnMouseModifier; } + + void SetItemBits( ToolBoxItemId nItemId, ToolBoxItemBits nBits ); + ToolBoxItemBits GetItemBits( ToolBoxItemId nItemId ) const; + + void SetItemExpand( ToolBoxItemId nItemId, bool bExpand ); + // e.g. a label used as an itemwindow + void SetItemWindowNonInteractive(ToolBoxItemId nItemId, bool bNonInteractive); + + + void SetItemData( ToolBoxItemId nItemId, void* pNewData ); + void* GetItemData( ToolBoxItemId nItemId ) const; + void SetItemImage( ToolBoxItemId nItemId, const Image& rImage ); + Image GetItemImage( ToolBoxItemId nItemId ) const; + void SetItemImageAngle( ToolBoxItemId nItemId, Degree10 nAngle10 ); + void SetItemImageMirrorMode( ToolBoxItemId nItemId, bool bMirror ); + void SetItemText( ToolBoxItemId nItemId, const OUString& rText ); + const OUString& GetItemText( ToolBoxItemId nItemId ) const; + void SetItemWindow( ToolBoxItemId nItemId, vcl::Window* pNewWindow ); + vcl::Window* GetItemWindow( ToolBoxItemId nItemId ) const; + ToolBoxItemId GetHighlightItemId() const { return mnHighItemId; } + + void EndSelection(); + + void SetItemDown( ToolBoxItemId nItemId, bool bDown ); + + void SetItemState( ToolBoxItemId nItemId, TriState eState ); + TriState GetItemState( ToolBoxItemId nItemId ) const; + + void CheckItem( ToolBoxItemId nItemId, bool bCheck = true ); + bool IsItemChecked( ToolBoxItemId nItemId ) const; + + void EnableItem( ToolBoxItemId nItemId, bool bEnable = true ); + bool IsItemEnabled( ToolBoxItemId nItemId ) const; + + void TriggerItem( ToolBoxItemId nItemId ); + + /// Shows or hides items. + void ShowItem(ToolBoxItemId nItemId, bool bVisible = true); + + /// Convenience method to hide items (via ShowItem). + void HideItem(ToolBoxItemId nItemId) { ShowItem( nItemId, false ); } + + bool IsItemClipped( ToolBoxItemId nItemId ) const; + bool IsItemVisible( ToolBoxItemId nItemId ) const; + bool IsItemReallyVisible( ToolBoxItemId nItemId ) const; + + void SetItemCommand( ToolBoxItemId nItemId, const OUString& rCommand ); + OUString GetItemCommand( ToolBoxItemId nItemId ) const; + + using Window::SetQuickHelpText; + void SetQuickHelpText( ToolBoxItemId nItemId, const OUString& rText ); + using Window::GetQuickHelpText; + OUString GetQuickHelpText( ToolBoxItemId nItemId ) const; + + void SetHelpText( ToolBoxItemId nItemId, const OUString& rText ); + const OUString& GetHelpText( ToolBoxItemId nItemId ) const; + + void SetHelpId( ToolBoxItemId nItemId, const OString& rHelpId ); + + // window size according to current alignment, floating state and number of lines + Size CalcWindowSizePixel(); + // window size according to current alignment, floating state and a given number of lines + Size CalcWindowSizePixel( ImplToolItems::size_type nCalcLines ); + // window size according to current floating state and a given number of lines and a given alignment + Size CalcWindowSizePixel( ImplToolItems::size_type nCalcLines, WindowAlign eAlign ); + // floating window size according to number of lines (uses the number of line breaks) + Size CalcFloatingWindowSizePixel(); + // floating window size with a given number of lines + Size CalcFloatingWindowSizePixel( ImplToolItems::size_type nCalcLines ); + // automatic window size for popup mode + Size CalcPopupWindowSizePixel(); + + // computes the smallest useful size when docked, ie with the first item visible only (+drag area and menu button) + Size CalcMinimumWindowSizePixel(); + + ImplToolItems::size_type GetFloatingLines() const; + + void SetStyle( WinBits nNewStyle ); + WinBits GetStyle() const { return mnWinStyle; } + + // enable/disable undocking + void Lock( bool bLock ); + // read configuration to determine locking behaviour + static bool AlwaysLocked(); + + void EnableCustomize( bool bEnable = true ); + bool IsCustomize() const { return mbCustomize; } + + using DockingWindow::SetHelpText; + using DockingWindow::GetHelpText; + using DockingWindow::SetHelpId; + using DockingWindow::GetHelpId; + + void SetClickHdl( const Link<ToolBox *, void>& rLink ) { maClickHdl = rLink; } + void SetDoubleClickHdl( const Link<ToolBox *, void>& rLink ) { maDoubleClickHdl = rLink; } + void SetDropdownClickHdl( const Link<ToolBox *, void>& rLink ); + void SetActivateHdl( const Link<ToolBox *, void>& rLink ) { maActivateHdl = rLink; } + void SetDeactivateHdl( const Link<ToolBox *, void>& rLink ) { maDeactivateHdl = rLink; } + void SetSelectHdl( const Link<ToolBox *, void>& rLink ) { maSelectHdl = rLink; } + void SetStateChangedHdl( const Link<StateChangedType const *, void>& aLink ) { maStateChangedHandler = aLink; } + void SetDataChangedHdl( const Link<DataChangedEvent const *, void>& aLink ) { maDataChangedHandler = aLink; } + void SetMenuButtonHdl( const Link<ToolBox *, void>& rLink ) { maMenuButtonHdl = rLink; } + + // support for custom menu (eg for configuration) + // note: this menu will also be used to display currently + // clipped toolbox items, so you should only touch + // items that you added by yourself + // the private toolbox items will only use item ids starting from TOOLBOX_MENUITEM_START + // to allow for customization of the menu the corresponding handler is called + // when the menu button was clicked and before the menu is executed + void SetMenuType( ToolBoxMenuType aType = ToolBoxMenuType::Customize ); + ToolBoxMenuType GetMenuType() const; + bool IsMenuEnabled() const; + PopupMenu* GetMenu() const; + void UpdateCustomMenu(); + void SetMenuExecuteHdl( const Link<ToolBox *, void>& rLink ); + + // open custommenu + void ExecuteCustomMenu( const tools::Rectangle& rRect = tools::Rectangle() ); + + // allow Click Handler to distinguish between mouse and key input + bool IsKeyEvent() const { return mbIsKeyEvent; } + + // allows framework to set/query the planned popupmode + bool WillUsePopupMode() const; + void WillUsePopupMode( bool b); + + // accessibility helpers + + // gets the displayed text + OUString GetDisplayText() const override; + // returns the bounding box for the character at index nIndex + // where nIndex is relative to the starting index of the item + // with id nItemId (in coordinates of the displaying window) + tools::Rectangle GetCharacterBounds( ToolBoxItemId nItemId, tools::Long nIndex ); + // -1 is returned if no character is at that point + // if an index is found the corresponding item id is filled in (else 0) + tools::Long GetIndexForPoint( const Point& rPoint, ToolBoxItemId& rItemID ); + + static Size GetDefaultImageSize(ToolBoxButtonSize eToolBoxButtonSize); + Size GetDefaultImageSize() const; + void ChangeHighlight( ImplToolItems::size_type nPos ); + + + void SetToolbarLayoutMode( ToolBoxLayoutMode eLayout ); + void statusChanged(const css::frame::FeatureStateEvent& rEvent); + + void SetToolBoxTextPosition( ToolBoxTextPosition ePosition ); + + void SetLineSpacing(bool b) { mbLineSpacing = b; } + + virtual void DumpAsPropertyTree(tools::JsonWriter&) override; +}; + +inline void ToolBox::CheckItem( ToolBoxItemId nItemId, bool bCheck ) +{ + SetItemState( nItemId, bCheck ? TRISTATE_TRUE : TRISTATE_FALSE ); +} + +inline bool ToolBox::IsItemChecked( ToolBoxItemId nItemId ) const +{ + return (GetItemState( nItemId ) == TRISTATE_TRUE); +} + +inline Size ToolBox::CalcWindowSizePixel() +{ + return CalcWindowSizePixel( mnLines ); +} + +inline ToolBox::ImplToolItems::size_type ToolBox::GetFloatingLines() const +{ + return mnFloatLines; +} + +#endif // INCLUDED_VCL_TOOLBOX_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolboxid.hxx b/include/vcl/toolboxid.hxx new file mode 100644 index 000000000..009a10d74 --- /dev/null +++ b/include/vcl/toolboxid.hxx @@ -0,0 +1,23 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#pragma once + +#include <o3tl/strong_int.hxx> + +typedef o3tl::strong_int<sal_uInt16, struct ToolBoxItemIdTag> ToolBoxItemId; +namespace std +{ +template <> struct hash<ToolBoxItemId> +{ + std::size_t operator()(ToolBoxItemId const& s) const { return std::size_t(sal_uInt16(s)); } +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/include/vcl/toolkit/README b/include/vcl/toolkit/README new file mode 100644 index 000000000..889f0b20a --- /dev/null +++ b/include/vcl/toolkit/README @@ -0,0 +1,2 @@ +These are includes which are now only used by the toolkit module, which exposes +them via uno. Don't use these in any new code. diff --git a/include/vcl/toolkit/button.hxx b/include/vcl/toolkit/button.hxx new file mode 100644 index 000000000..e894f9e28 --- /dev/null +++ b/include/vcl/toolkit/button.hxx @@ -0,0 +1,507 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <vcl/dllapi.h> +#include <vcl/image.hxx> +#include <vcl/ctrl.hxx> +#include <vcl/vclenum.hxx> +#include <memory> +#include <vector> + +namespace com::sun::star::frame { struct FeatureStateEvent; } +template <class T> class VclPtr; + +class Color; +class ImplCommonButtonData; +enum class DrawButtonFlags; + +class VCL_DLLPUBLIC Button : public Control +{ +private: + std::unique_ptr<ImplCommonButtonData> mpButtonData; + Link<Button*,void> maClickHdl; + + /// Command URL (like .uno:Save) in case the button should handle it. + OUString maCommand; + + Button (const Button &) = delete; + Button & operator= (const Button &) = delete; +public: + SAL_DLLPRIVATE DrawTextFlags ImplGetTextStyle( WinBits nWinStyle, SystemTextColorFlags nSystemTextColorFlags ) const; + SAL_DLLPRIVATE void ImplDrawAlignedImage(OutputDevice* pDev, Point& rPos, Size& rSize, + sal_Int32 nImageSep, + DrawTextFlags nTextStyle, tools::Rectangle *pSymbolRect=nullptr, bool bAddImageSep = false ); + SAL_DLLPRIVATE void ImplSetFocusRect( const tools::Rectangle &rFocusRect ); + SAL_DLLPRIVATE const tools::Rectangle& ImplGetFocusRect() const; + SAL_DLLPRIVATE void ImplSetSymbolAlign( SymbolAlign eAlign ); + /// The x-coordinate of the vertical separator line, use in MenuButton subclass only. + SAL_DLLPRIVATE tools::Long ImplGetSeparatorX() const; + SAL_DLLPRIVATE void ImplSetSeparatorX( tools::Long nX ); + +protected: + explicit Button( WindowType nType ); + + // for drawing RadioButton or CheckButton that has Text and/or Image + SAL_DLLPRIVATE void ImplDrawRadioCheck(OutputDevice* pDev, WinBits nWinStyle, SystemTextColorFlags nSystemTextColorFlags, + const Point& rPos, const Size& rSize, + const Size& rImageSize, tools::Rectangle& rStateRect, + tools::Rectangle& rMouseRect); + SAL_DLLPRIVATE tools::Long ImplGetImageToTextDistance() const; + +public: + virtual ~Button() override; + virtual void dispose() override; + + virtual void Click(); + + void SetClickHdl( const Link<Button*,void>& rLink ) { maClickHdl = rLink; } + const Link<Button*,void>& GetClickHdl() const { return maClickHdl; } + + /// Setup handler for UNO commands so that commands like .uno:Something are handled automagically by this button. + void SetCommandHandler(const OUString& aCommand); + OUString const & GetCommand() const { return maCommand; } + + void SetModeImage( const Image& rImage ); + Image const & GetModeImage( ) const; + bool HasImage() const; + void SetImageAlign( ImageAlign eAlign ); + ImageAlign GetImageAlign() const; + DrawButtonFlags GetButtonState() const; + DrawButtonFlags& GetButtonState(); + + /// Set an image to use as the complete render view of a custom button, + /// instead of the usual contents of a button + void SetCustomButtonImage( const Image& rImage ); + Image const & GetCustomButtonImage() const; + + bool IsSmallSymbol() const; + void SetSmallSymbol(); + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + + /// Sets the button state according to the FeatureStateEvent emitted by a Uno state change. + virtual void statusChanged(const css::frame::FeatureStateEvent& rEvent); + + virtual FactoryFunction GetUITestFactory() const override; + + virtual void DumpAsPropertyTree(tools::JsonWriter&) override; + +protected: + + /// Handler for click, in case we want the button to handle uno commands (.uno:Something). + DECL_DLLPRIVATE_STATIC_LINK(Button, dispatchCommandHandler, Button*, void); +}; + +enum class PushButtonDropdownStyle +{ + NONE = 0x0000, + MenuButton = 0x0002, //visual down arrow + SplitMenuButton = 0x0003, //visual down arrow and separator line +}; + +class VCL_DLLPUBLIC PushButton : public Button +{ +public: + SAL_DLLPRIVATE void ImplSetDefButton( bool bSet ); + SAL_DLLPRIVATE void ImplDrawPushButtonFrame(vcl::RenderContext& rRenderContext, tools::Rectangle& rRect, DrawButtonFlags nStyle); + SAL_DLLPRIVATE static bool ImplHitTestPushButton(vcl::Window const * pDev, const Point& rPos); + SAL_DLLPRIVATE bool ImplIsDefButton() const; + + explicit PushButton( vcl::Window* pParent, WinBits nStyle = 0 ); + + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void Tracking( const TrackingEvent& rTEvt ) override; + virtual void KeyInput( const KeyEvent& rKEvt ) override; + virtual void KeyUp( const KeyEvent& rKEvt ) override; + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Draw( OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags ) override; + virtual void Resize() override; + virtual void GetFocus() override; + virtual void LoseFocus() override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + + void Toggle(); + + void SetSymbol( SymbolType eSymbol ); + SymbolType GetSymbol() const { return meSymbol; } + void SetSymbolAlign( SymbolAlign eAlign ); + + void SetDropDown( PushButtonDropdownStyle nStyle ); + + void SetState( TriState eState ); + TriState GetState() const { return meState; } + virtual void statusChanged(const css::frame::FeatureStateEvent& rEvent) override; + + void Check( bool bCheck = true ); + bool IsChecked() const; + + void SetPressed( bool bPressed ); + bool IsPressed() const { return mbPressed; } + + void EndSelection(); + + Size CalcMinimumSize() const; + virtual Size GetOptimalSize() const override; + + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + virtual void ShowFocus(const tools::Rectangle& rRect) override; + + void setAction(bool bIsAction) + { + mbIsAction = bIsAction; + } + + bool isAction() const + { + return mbIsAction; + } + + void DumpAsPropertyTree(tools::JsonWriter&) override; + +protected: + PushButtonDropdownStyle mnDDStyle; + bool mbIsActive; + + SAL_DLLPRIVATE void ImplInitPushButtonData(); + SAL_DLLPRIVATE static WinBits ImplInitStyle( const vcl::Window* pPrevWindow, WinBits nStyle ); + SAL_DLLPRIVATE void ImplInitSettings( bool bBackground ); + SAL_DLLPRIVATE void ImplDrawPushButtonContent(OutputDevice* pDev, SystemTextColorFlags nSystemTextColorFlags, + const tools::Rectangle& rRect, bool bMenuBtnSep, + DrawButtonFlags nButtonFlags); + SAL_DLLPRIVATE void ImplDrawPushButton(vcl::RenderContext& rRenderContext); + using Button::ImplGetTextStyle; + SAL_DLLPRIVATE DrawTextFlags ImplGetTextStyle( SystemTextColorFlags nSystemTextColorFlags ) const; + SAL_DLLPRIVATE bool IsSymbol() const { return ( (meSymbol != SymbolType::DONTKNOW) && (meSymbol != SymbolType::IMAGE) ); } + + PushButton( const PushButton & ) = delete; + PushButton& operator=( const PushButton & ) + = delete; + + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + + using Control::ImplInitSettings; + using Window::ImplInit; + + explicit PushButton( WindowType nType ); + + virtual void FillLayoutData() const override; + virtual const vcl::Font& + GetCanonicalFont( const StyleSettings& _rStyle ) const override; + virtual const Color& + GetCanonicalTextColor( const StyleSettings& _rStyle ) const override; + +private: + SymbolType meSymbol; + TriState meState; + bool mbPressed; + bool mbIsAction; +}; + +inline void PushButton::Check( bool bCheck ) +{ + SetState( bCheck ? TRISTATE_TRUE : TRISTATE_FALSE ); +} + +inline bool PushButton::IsChecked() const +{ + return (GetState() == TRISTATE_TRUE); +} + +class VCL_DLLPUBLIC OKButton final : public PushButton +{ +private: + using PushButton::ImplInit; + + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + + OKButton (const OKButton &) = delete; + OKButton & operator= (const OKButton &) = delete; + +public: + explicit OKButton( vcl::Window* pParent, WinBits nStyle = WB_DEFBUTTON ); + + virtual void Click() override; +}; + +class VCL_DLLPUBLIC CancelButton : public PushButton +{ +protected: + using PushButton::ImplInit; +private: + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + + CancelButton (const CancelButton &) = delete; + CancelButton & operator= (const CancelButton &) = delete; + +public: + explicit CancelButton( vcl::Window* pParent, WinBits nStyle = 0 ); + + virtual void Click() override; +}; + +class CloseButton final : public CancelButton +{ +public: + explicit CloseButton(vcl::Window* pParent); +}; + +class VCL_DLLPUBLIC HelpButton final : public PushButton +{ +private: + using PushButton::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + + HelpButton( const HelpButton & ) = delete; + HelpButton & operator= ( const HelpButton & ) = delete; + + virtual void StateChanged( StateChangedType nStateChange ) override; + +public: + explicit HelpButton( vcl::Window* pParent, WinBits nStyle = 0 ); + + virtual void Click() override; +}; + +class VCL_DLLPUBLIC CheckBox : public Button +{ +private: + tools::Rectangle maStateRect; + tools::Rectangle maMouseRect; + TriState meState; + bool mbTriState; + Link<CheckBox&,void> maToggleHdl; + SAL_DLLPRIVATE void ImplInitCheckBoxData(); + SAL_DLLPRIVATE static WinBits ImplInitStyle( const vcl::Window* pPrevWindow, WinBits nStyle ); + SAL_DLLPRIVATE void ImplInitSettings( bool bBackground ); + SAL_DLLPRIVATE void ImplDraw( OutputDevice* pDev, SystemTextColorFlags nSystemTextColorFlags, + const Point& rPos, const Size& rSize, + const Size& rImageSize, tools::Rectangle& rStateRect, + tools::Rectangle& rMouseRect ); + SAL_DLLPRIVATE void ImplDrawCheckBox(vcl::RenderContext& rRenderContext ); + SAL_DLLPRIVATE Size ImplGetCheckImageSize() const; + + CheckBox(const CheckBox &) = delete; + CheckBox& operator= (const CheckBox &) = delete; + +protected: + using Control::ImplInitSettings; + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + virtual void FillLayoutData() const override; + virtual const vcl::Font& GetCanonicalFont( const StyleSettings& _rStyle ) const override; + virtual const Color& GetCanonicalTextColor( const StyleSettings& _rStyle ) const override; + void ImplAdjustNWFSizes() override; + + virtual void ImplDrawCheckBoxState(vcl::RenderContext& rRenderContext); + SAL_DLLPRIVATE const tools::Rectangle& GetStateRect() const { return maStateRect; } + SAL_DLLPRIVATE const tools::Rectangle& GetMouseRect() const { return maMouseRect; } + +public: + SAL_DLLPRIVATE void ImplCheck(); +public: + explicit CheckBox( vcl::Window* pParent, WinBits nStyle = 0 ); + + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void Tracking( const TrackingEvent& rTEvt ) override; + virtual void KeyInput( const KeyEvent& rKEvt ) override; + virtual void KeyUp( const KeyEvent& rKEvt ) override; + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Draw( OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags ) override; + virtual void Resize() override; + virtual void GetFocus() override; + virtual void LoseFocus() override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + + void Toggle(); + + void SetState( TriState eState ); + TriState GetState() const { return meState; } + + void Check( bool bCheck = true ) + { + SetState( bCheck ? TRISTATE_TRUE : TRISTATE_FALSE ); + } + + bool IsChecked() const + { + return (GetState() == TRISTATE_TRUE); + } + + void EnableTriState( bool bTriState = true ); + bool IsTriStateEnabled() const { return mbTriState; } + + static Image GetCheckImage( const AllSettings& rSettings, DrawButtonFlags nFlags ); + + Size CalcMinimumSize( tools::Long nMaxWidth = 0 ) const; + virtual Size GetOptimalSize() const override; + + void SetToggleHdl( const Link<CheckBox&,void>& rLink ) { maToggleHdl = rLink; } + + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + virtual void ShowFocus(const tools::Rectangle& rRect) override; + + /// Button has additional stuff that we need to dump too. + void DumpAsPropertyTree(tools::JsonWriter&) override; + + virtual FactoryFunction GetUITestFactory() const override; +}; + +class VCL_DLLPUBLIC RadioButton : public Button +{ +private: + friend class VclBuilder; + + std::shared_ptr< std::vector< VclPtr< RadioButton > > > m_xGroup; + tools::Rectangle maStateRect; + tools::Rectangle maMouseRect; + Image maImage; + bool mbChecked; + bool mbRadioCheck; + bool mbStateChanged; + bool mbUsesExplicitGroup; + Link<RadioButton&,void> maToggleHdl; + SAL_DLLPRIVATE void ImplInitRadioButtonData(); + SAL_DLLPRIVATE WinBits ImplInitStyle( const vcl::Window* pPrevWindow, WinBits nStyle ) const; + SAL_DLLPRIVATE void ImplInitSettings( bool bBackground ); + SAL_DLLPRIVATE void ImplDrawRadioButtonState(vcl::RenderContext& rRenderContext); + SAL_DLLPRIVATE void ImplDraw( OutputDevice* pDev, SystemTextColorFlags nSystemTextColorFlags, + const Point& rPos, const Size& rSize, + const Size& rImageSize, tools::Rectangle& rStateRect, + tools::Rectangle& rMouseRect ); + SAL_DLLPRIVATE void ImplDrawRadioButton(vcl::RenderContext& rRenderContext ); + SAL_DLLPRIVATE void ImplUncheckAllOther(); + SAL_DLLPRIVATE Size ImplGetRadioImageSize() const; + + RadioButton(const RadioButton &) = delete; + RadioButton& operator= (const RadioButton &) = delete; + +protected: + using Control::ImplInitSettings; + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + +public: + SAL_DLLPRIVATE void ImplCallClick( bool bGrabFocus = false, GetFocusFlags nFocusFlags = GetFocusFlags::NONE ); + +protected: + virtual void FillLayoutData() const override; + virtual const vcl::Font& + GetCanonicalFont( const StyleSettings& _rStyle ) const override; + virtual const Color& + GetCanonicalTextColor( const StyleSettings& _rStyle ) const override; + void ImplAdjustNWFSizes() override; + +public: + /* + bUsesExplicitGroup of true means that group() is used to set what radiobuttons are part of a group + while false means that contiguous radiobuttons are considered part of a group where WB_GROUP designates + the start of the group and all contiguous radiobuttons without WB_GROUP set form the rest of the group. + + true is fairly straightforward, false leads to trick situations and is the legacy case + */ + explicit RadioButton(vcl::Window* pParent, bool bUsesExplicitGroup, WinBits nWinStyle); + virtual ~RadioButton() override; + virtual void dispose() override; + + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void Tracking( const TrackingEvent& rTEvt ) override; + virtual void KeyInput( const KeyEvent& rKEvt ) override; + virtual void KeyUp( const KeyEvent& rKEvt ) override; + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Draw( OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags ) override; + virtual void Resize() override; + virtual void GetFocus() override; + virtual void LoseFocus() override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + + void Toggle(); + + bool IsStateChanged() const { return mbStateChanged; } + + void EnableRadioCheck( bool bRadioCheck ) { mbRadioCheck = bRadioCheck; } + bool IsRadioCheckEnabled() const { return mbRadioCheck; } + + void SetModeRadioImage( const Image& rImage ); + + void SetState( bool bCheck ); + void Check( bool bCheck = true ); + bool IsChecked() const { return mbChecked; } + + static Image GetRadioImage( const AllSettings& rSettings, DrawButtonFlags nFlags ); + + Size CalcMinimumSize( tools::Long nMaxWidth = 0 ) const; + virtual Size GetOptimalSize() const override; + + void SetToggleHdl( const Link<RadioButton&,void>& rLink ) { maToggleHdl = rLink; } + + /** GetRadioButtonGroup returns a list of pointers to <code>RadioButton</code>s in the same group. + + The pointers in the returned list are valid at the time call returns. However rescheduling + or giving up the SolarMutex may mean events get executed that lead to the pointers getting + invalid. + + @param bIncludeThis + defines whether <code>this</code> is contained in the returned list + + @return + on return contains the <code>RadioButton</code>s + in the same group as this <code>RadioButton</code>. + */ + std::vector<VclPtr<RadioButton> > GetRadioButtonGroup(bool bIncludeThis = true) const; + + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + + /* + * Group this RadioButton with another + */ + void group(RadioButton &rOther); + virtual void ShowFocus(const tools::Rectangle& rRect) override; + + /// Button has additional stuff that we need to dump too. + void DumpAsPropertyTree(tools::JsonWriter&) override; + + virtual FactoryFunction GetUITestFactory() const override; +}; + +class VCL_DLLPUBLIC ImageButton final : public PushButton +{ +private: + using PushButton::ImplInitStyle; + + SAL_DLLPRIVATE void ImplInitStyle(); + + ImageButton( const ImageButton & ) = delete; + ImageButton & operator= ( const ImageButton & ) = delete; + +public: + ImageButton( vcl::Window* pParent, WinBits nStyle = 0 ); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/calendar.hxx b/include/vcl/toolkit/calendar.hxx new file mode 100644 index 000000000..a1a1cd901 --- /dev/null +++ b/include/vcl/toolkit/calendar.hxx @@ -0,0 +1,98 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <config_options.h> +#include <vcl/dllapi.h> + +#include <vcl/toolkit/field.hxx> +#include <vcl/weld.hxx> + +class FloatingWindow; +struct ImplCFieldFloatWin; + +/************************************************************************* + +Description +============ + +class CalendarField + +This class is a DateField with which one can select a date via a DropDownButton +and the CalendarControl. + +-------------------------------------------------------------------------- + +WinBits + +See DateField + +The preferences for the CalendarControl can be set via SetCalendarStyle(). + +-------------------------------------------------------------------------- + +With EnableToday()/EnableNone() we can enable a TodayButton and a NoneButton. + +-------------------------------------------------------------------------- + +Because we only take over the start date into the field, we should query +with GetCalendar() in the SelectHandler and with GetSelectDateCount()/GetSelectDate() +the selected range. We then can e.g. take over that value to another field. + +-------------------------------------------------------------------------- + +If a derived Calendar should be used, we can override the CreateCalendar() +method in CalendarField and create an own calendar there ourselves. + +*************************************************************************/ + + +class VCL_DLLPUBLIC CalendarField final : public DateField +{ +private: + VclPtr<ImplCFieldFloatWin> mpFloatWin; + weld::Button* mpTodayBtn; + weld::Button* mpNoneBtn; + bool mbToday; + bool mbNone; + + DECL_DLLPRIVATE_LINK( ImplSelectHdl, weld::Calendar&, void ); + DECL_DLLPRIVATE_LINK( ImplClickHdl, weld::Button&, void ); + DECL_DLLPRIVATE_LINK( ImplPopupModeEndHdl, FloatingWindow*, void ); + +public: + CalendarField( vcl::Window* pParent, WinBits nWinStyle ); + virtual ~CalendarField() override; + virtual void dispose() override; + + virtual bool ShowDropDown( bool bShow ) override; + + void EnableToday() { mbToday = true; } + void EnableNone() { mbNone = true; } + +private: + virtual void StateChanged( StateChangedType nStateChange ) override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/combobox.hxx b/include/vcl/toolkit/combobox.hxx new file mode 100644 index 000000000..bdc415744 --- /dev/null +++ b/include/vcl/toolkit/combobox.hxx @@ -0,0 +1,197 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <memory> +#include <vcl/dllapi.h> +#include <vcl/toolkit/edit.hxx> + +#define COMBOBOX_APPEND (SAL_MAX_INT32) +#define COMBOBOX_ENTRY_NOTFOUND (SAL_MAX_INT32) +#define COMBOBOX_MAX_ENTRIES (SAL_MAX_INT32 - 1) + +class ImplListBoxWindow; +class UserDrawEvent; + +/// A widget used to choose from a list of items and which has an entry. +class VCL_DLLPUBLIC ComboBox : public Edit +{ +private: + struct SAL_DLLPRIVATE Impl; + std::unique_ptr<Impl> m_pImpl; + +protected: + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + SAL_DLLPRIVATE static WinBits ImplInitStyle( WinBits nStyle ); + SAL_DLLPRIVATE void ImplCalcEditHeight(); + SAL_DLLPRIVATE tools::Long getMaxWidthScrollBarAndDownButton() const; + +protected: + bool IsDropDownBox() const; + + virtual void FillLayoutData() const override; + +public: + explicit ComboBox( vcl::Window* pParent, WinBits nStyle = 0 ); + virtual ~ComboBox() override; + virtual void dispose() override; + + virtual void Draw( OutputDevice* pDev, const Point& rPos,SystemTextColorFlags nFlags ) override; + virtual void Resize() override; + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + void Select(); + void DoubleClick(); + + virtual void Modify() override; + + virtual const Wallpaper& GetDisplayBackground() const override; + + virtual void setPosSizePixel( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, PosSizeFlags nFlags = PosSizeFlags::All ) override; + + tools::Rectangle GetDropDownPosSizePixel() const; + + void AdaptDropDownLineCountToMaximum(); + void SetDropDownLineCount( sal_uInt16 nLines ); + sal_uInt16 GetDropDownLineCount() const; + + void EnableAutoSize( bool bAuto ); + bool IsAutoSizeEnabled() const; + + virtual void SetText( const OUString& rStr ) override; + virtual void SetText( const OUString& rStr, const Selection& rNewSelection ) override; + + sal_Int32 InsertEntry(const OUString& rStr, sal_Int32 nPos = COMBOBOX_APPEND); + sal_Int32 InsertEntryWithImage( const OUString& rStr, const Image& rImage, sal_Int32 nPos = COMBOBOX_APPEND ); + + void RemoveEntryAt(sal_Int32 nPos); + + void Clear(); + sal_Int32 GetEntryPos( std::u16string_view rStr ) const; + Image GetEntryImage( sal_Int32 nPos ) const; + OUString GetEntry( sal_Int32 nPos ) const; + sal_Int32 GetEntryCount() const; + + bool IsTravelSelect() const; + bool IsInDropDown() const; + void ToggleDropDown(); + + void SetUserItemSize( const Size& rSz ); + void EnableUserDraw( bool bUserDraw ); + bool IsUserDrawEnabled() const; + + void DrawEntry( const UserDrawEvent& rEvt ); + void SetBorderStyle( WindowBorderStyle nBorderStyle ); + + /** + * Adds a new separator at the given position n. + */ + void AddSeparator( sal_Int32 n ); + + void EnableAutocomplete( bool bEnable, bool bMatchCase = false ); + bool IsAutocompleteEnabled() const; + + bool IsMultiSelectionEnabled() const; + + void SetSelectHdl(const Link<ComboBox&,void>& rLink); + void SetEntryActivateHdl(const Link<Edit&,bool>& rLink); + void SetUserDrawHdl(const Link<UserDrawEvent*, void>& rLink); + + Size CalcMinimumSize() const override; + virtual Size GetOptimalSize() const override; + Size CalcAdjustedSize( const Size& rPrefSize ) const; + Size CalcBlockSize( sal_uInt16 nColumns, sal_uInt16 nLines ) const; + void GetMaxVisColumnsAndLines( sal_uInt16& rnCols, sal_uInt16& rnLines ) const; + + void SetMRUEntries( std::u16string_view rEntries ); + OUString GetMRUEntries() const; + void SetMaxMRUCount( sal_Int32 n ); + sal_Int32 GetMaxMRUCount() const; + void SetEntryData( sal_Int32 nPos, void* pNewData ); + void* GetEntryData( sal_Int32 nPos ) const; + + sal_Int32 GetTopEntry() const; + + sal_uInt16 GetDisplayLineCount() const; + + sal_Int32 GetSelectedEntryCount() const; + sal_Int32 GetSelectedEntryPos( sal_Int32 nSelIndex = 0 ) const; + bool IsEntryPosSelected( sal_Int32 nPos ) const; + void SelectEntryPos( sal_Int32 nPos, bool bSelect = true ); + void SetNoSelection(); + tools::Rectangle GetBoundingRectangle( sal_Int32 nItem ) const; + + // determine if Select was called due to typing or cursoring in the + // combobox, as opposed to something selected from the menu or via some + // other route. e.g. the toolbar fontsize combobox wants to immediately + // change size only if something is picked from the combobox menu, other + // changes don't auto-apply until the user presses return + bool IsModifyByKeyboard() const; + + // determine if Edit::Modify was called due to the ComboBox changing the edit area + // itself + bool IsSyntheticModify() const; + + + /** checks whether a certain point lies within the bounds of + a list item and returns the item as well as the character position + the point is at. + + <p>If the point is inside an item the item pos is put into <code>rPos</code> and + the item-relative character index is returned. If the point is not inside + an item -1 is returned and rPos is unchanged.</p> + + @param rPoint + tells the point for which an item is requested. + + @param rPos + gets the item at the specified point <code>rPoint</code> + + @returns + the item-relative character index at point <code>rPos</code> or -1 + if no item is at that point. + */ + using Control::GetIndexForPoint; + tools::Long GetIndexForPoint( const Point& rPoint, sal_Int32 & rPos ) const; + + void setMaxWidthChars(sal_Int32 nWidth); + + void SetWidthInChars(sal_Int32 nWidthInChars); + + tools::Long GetDropDownEntryHeight() const; + + // the drop down window container + ImplListBoxWindow* GetMainWindow() const; + + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + + virtual FactoryFunction GetUITestFactory() const override; + + virtual void DumpAsPropertyTree(tools::JsonWriter&) override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/dialog.hxx b/include/vcl/toolkit/dialog.hxx new file mode 100644 index 000000000..31326106c --- /dev/null +++ b/include/vcl/toolkit/dialog.hxx @@ -0,0 +1,169 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <memory> +#include <string_view> + +#include <vcl/dllapi.h> +#include <vcl/syswin.hxx> +#include <vcl/vclptr.hxx> +#include <vcl/abstdlg.hxx> + +struct DialogImpl; +class Button; +class PushButton; +class VclBox; +class VclButtonBox; + +class VCL_DLLPUBLIC Dialog : public SystemWindow +{ +public: + enum class InitFlag + { + /** Use given parent or get a default one using GetDefaultParent(...) */ + Default, + + /** No Parent */ + NoParent + }; + +private: + std::unique_ptr<DialogImpl> mpDialogImpl; + tools::Long mnMousePositioned; + bool mbInExecute; + bool mbInSyncExecute; + bool mbInClose; + bool mbModalMode; + InitFlag mnInitFlag; // used for deferred init + + VclPtr<VclButtonBox> mpActionArea; + VclPtr<VclBox> mpContentArea; + + SAL_DLLPRIVATE void RemoveFromDlgList(); + SAL_DLLPRIVATE void ImplInitDialogData(); + SAL_DLLPRIVATE void ImplInitSettings(); + SAL_DLLPRIVATE VclPtr<vcl::Window> AddBorderWindow(vcl::Window* pParent, WinBits nBits); + + virtual void ApplySettings(vcl::RenderContext& rRenderContext) override; + + SAL_DLLPRIVATE Dialog (const Dialog &) = delete; + SAL_DLLPRIVATE Dialog & operator= (const Dialog &) = delete; + + DECL_DLLPRIVATE_LINK(ImplAsyncCloseHdl, void*, void); + DECL_DLLPRIVATE_LINK(ResponseHdl, Button*, void); + + // get the default parent for a dialog as is done in standard initialization + SAL_DLLPRIVATE static vcl::Window* GetDefaultParent(WinBits nStyle); + +protected: + void ImplInitDialog( vcl::Window* pParent, WinBits nStyle, InitFlag eFlag = InitFlag::Default ); + + /// Find and set the LOK notifier according to the pParent. + void ImplLOKNotifier(vcl::Window* pParent); + +public: + SAL_DLLPRIVATE bool IsInClose() const { return mbInClose; } + virtual void doDeferredInit(WinBits nBits) override; + SAL_DLLPRIVATE void disposeOwnedButtons(); + + SAL_DLLPRIVATE static vcl::Window* GetDefDialogParent(); + +protected: + explicit Dialog( WindowType nType ); + explicit Dialog( vcl::Window* pParent, std::u16string_view rID, const OUString& rUIXMLDescription); + virtual void Draw( OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags ) override; + virtual void settingOptimalLayoutSize(Window *pBox) override; + +protected: + friend class VclBuilder; + friend class SalInstanceBuilder; + void set_action_area(VclButtonBox* pBox); + void set_content_area(VclBox* pBox); + +public: + explicit Dialog( vcl::Window* pParent, WinBits nStyle = WB_STDDIALOG, InitFlag eFlag = InitFlag::Default ); + virtual ~Dialog() override; + virtual void dispose() override; + + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void StateChanged( StateChangedType nStateChange ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + virtual void Command( const CommandEvent& rCEvt ) override; + virtual void PixelInvalidate(const tools::Rectangle* pRectangle) override; + + virtual void queue_resize(StateChangedType eReason = StateChangedType::Layout) override; + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + VclButtonBox* get_action_area() { return mpActionArea; } + VclBox* get_content_area() { return mpContentArea; } + + virtual bool Close() override; + + short Execute(); + bool IsInExecute() const { return mbInExecute; } + // Return true when dialog is synchronously executed (calling ::Execute()) + bool IsInSyncExecute() const { return mbInSyncExecute; }; + + virtual FactoryFunction GetUITestFactory() const override; + +private: + bool ImplStartExecute(); + static void ImplEndExecuteModal(); + void ImplSetModalInputMode(bool bModal); + + vcl::Window* GetFirstControlForFocus(); +public: + + /// Commence execution of a modal dialog, disposes owner on failure + bool StartExecuteAsync(VclAbstractDialog::AsyncContext &rCtx); + + // Dialog::Execute replacement API + + + void EndDialog( tools::Long nResult = RET_CANCEL ); + + void GetDrawWindowBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder, + sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const; + + void SetModalInputMode( bool bModal ); + bool IsModalInputMode() const { return mbModalMode; } + + void GrabFocusToFirstControl(); + virtual void Resize() override; + + void Activate() override; + + void SetPopupMenuHdl(const Link<const CommandEvent&, bool>& rLink); + void SetInstallLOKNotifierHdl(const Link<void*, vcl::ILibreOfficeKitNotifier*>& rLink); + void SetLOKTunnelingState(bool bEnabled); + + void add_button(PushButton* pButton, int nResponse, bool bTransferOwnership); + void set_default_response(int nResponse); + int get_default_response() const; + vcl::Window* get_widget_for_response(int nResponse); + + void DumpAsPropertyTree(tools::JsonWriter& rJsonWriter) override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/edit.hxx b/include/vcl/toolkit/edit.hxx new file mode 100644 index 000000000..6cba93604 --- /dev/null +++ b/include/vcl/toolkit/edit.hxx @@ -0,0 +1,249 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <vcl/ctrl.hxx> +#include <vcl/textfilter.hxx> + +#include <memory> + +#include <rtl/ustrbuf.hxx> +#include <o3tl/deleter.hxx> +#include <vcl/dllapi.h> +#include <vcl/dndhelp.hxx> +#include <vcl/vclptr.hxx> +#include <com/sun/star/uno/Reference.h> + +namespace com::sun::star::i18n { + class XBreakIterator; + class XExtendedInputSequenceChecker; +} +namespace weld { + class Widget; +} + +class PopupMenu; +class VclBuilder; +struct DDInfo; +struct Impl_IMEInfos; + +#define EDIT_NOLIMIT SAL_MAX_INT32 + +class Timer; + +class VCL_DLLPUBLIC Edit : public Control, public vcl::unohelper::DragAndDropClient +{ +private: + VclPtr<Edit> mpSubEdit; + TextFilter* mpFilterText; + std::unique_ptr<DDInfo, o3tl::default_delete<DDInfo>> mpDDInfo; + std::unique_ptr<Impl_IMEInfos> mpIMEInfos; + OUStringBuffer maText; + OUString maPlaceholderText; + OUString maSaveValue; + OUString maUndoText; + tools::Long mnXOffset; + Selection maSelection; + sal_uInt16 mnAlign; + sal_Int32 mnMaxTextLen; + sal_Int32 mnWidthInChars; + sal_Int32 mnMaxWidthChars; + sal_Unicode mcEchoChar; + bool mbInternModified:1, + mbReadOnly:1, + mbInsertMode:1, + mbClickedInSelection:1, + mbIsSubEdit:1, + mbActivePopup:1, + mbForceControlBackground:1, + mbPassword; + Link<Edit&,void> maModifyHdl; + Link<Edit&,void> maAutocompleteHdl; + Link<Edit&,bool> maActivateHdl; + std::unique_ptr<VclBuilder> mpUIBuilder; + + css::uno::Reference<css::i18n::XBreakIterator> mxBreakIterator; + css::uno::Reference<css::i18n::XExtendedInputSequenceChecker> mxISC; + + SAL_DLLPRIVATE bool ImplTruncateToMaxLen( OUString&, sal_Int32 nSelectionLen ) const; + SAL_DLLPRIVATE void ImplInitEditData(); + SAL_DLLPRIVATE OUString ImplGetText() const; + SAL_DLLPRIVATE void ImplRepaint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRectangle); + SAL_DLLPRIVATE void ImplInvalidateOrRepaint(); + SAL_DLLPRIVATE void ImplDelete( const Selection& rSelection, sal_uInt8 nDirection, sal_uInt8 nMode ); + SAL_DLLPRIVATE void ImplSetText( const OUString& rStr, const Selection* pNewSelection ); + SAL_DLLPRIVATE void ImplInsertText( const OUString& rStr, const Selection* pNewSelection = nullptr, bool bIsUserInput = false ); + SAL_DLLPRIVATE static OUString ImplGetValidString( const OUString& rString ); + SAL_DLLPRIVATE void ImplClearBackground(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRectangle, tools::Long nXStart, tools::Long nXEnd); + SAL_DLLPRIVATE void ImplPaintBorder(vcl::RenderContext const & rRenderContext); + SAL_DLLPRIVATE void ImplShowCursor( bool bOnlyIfVisible = true ); + SAL_DLLPRIVATE void ImplAlign(); + SAL_DLLPRIVATE void ImplAlignAndPaint(); + SAL_DLLPRIVATE sal_Int32 ImplGetCharPos( const Point& rWindowPos ) const; + SAL_DLLPRIVATE void ImplSetCursorPos( sal_Int32 nChar, bool bSelect ); + SAL_DLLPRIVATE void ImplShowDDCursor(); + SAL_DLLPRIVATE void ImplHideDDCursor(); + SAL_DLLPRIVATE bool ImplHandleKeyEvent( const KeyEvent& rKEvt ); + SAL_DLLPRIVATE void ImplCopyToSelectionClipboard(); + SAL_DLLPRIVATE void ImplCopy(css::uno::Reference<css::datatransfer::clipboard::XClipboard> const & rxClipboard); + SAL_DLLPRIVATE void ImplPaste(css::uno::Reference<css::datatransfer::clipboard::XClipboard> const & rxClipboard); + SAL_DLLPRIVATE tools::Long ImplGetTextYPosition() const; + SAL_DLLPRIVATE css::uno::Reference<css::i18n::XExtendedInputSequenceChecker> const& ImplGetInputSequenceChecker(); + SAL_DLLPRIVATE css::uno::Reference<css::i18n::XBreakIterator> const& ImplGetBreakIterator(); + SAL_DLLPRIVATE void filterText(); + +protected: + using Control::ImplInitSettings; + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + SAL_DLLPRIVATE static WinBits ImplInitStyle( WinBits nStyle ); + SAL_DLLPRIVATE void ImplSetSelection( const Selection& rSelection, bool bPaint = true ); + SAL_DLLPRIVATE ControlType ImplGetNativeControlType() const; + SAL_DLLPRIVATE tools::Long ImplGetExtraXOffset() const; + SAL_DLLPRIVATE tools::Long ImplGetExtraYOffset() const; + static SAL_DLLPRIVATE void ImplInvalidateOutermostBorder( vcl::Window* pWin ); + + css::uno::Reference<css::datatransfer::dnd::XDragSourceListener > mxDnDListener; + + // DragAndDropClient + using vcl::unohelper::DragAndDropClient::dragEnter; + using vcl::unohelper::DragAndDropClient::dragExit; + using vcl::unohelper::DragAndDropClient::dragOver; + virtual void dragGestureRecognized(const css::datatransfer::dnd::DragGestureEvent& dge) override; + virtual void dragDropEnd(const css::datatransfer::dnd::DragSourceDropEvent& dsde) override; + virtual void drop(const css::datatransfer::dnd::DropTargetDropEvent& dtde) override; + virtual void dragEnter(const css::datatransfer::dnd::DropTargetDragEnterEvent& dtdee) override; + virtual void dragExit(const css::datatransfer::dnd::DropTargetEvent& dte) override; + virtual void dragOver(const css::datatransfer::dnd::DropTargetDragEvent& dtde) override; + +protected: + Edit(WindowType nType); + virtual void FillLayoutData() const override; + virtual void ApplySettings(vcl::RenderContext& rRenderContext) override; +public: + // public because needed in button.cxx + SAL_DLLPRIVATE bool ImplUseNativeBorder(vcl::RenderContext const & rRenderContext, WinBits nStyle) const; + + Edit( vcl::Window* pParent, WinBits nStyle = WB_BORDER ); + virtual ~Edit() override; + virtual void dispose() override; + + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void MouseButtonUp( const MouseEvent& rMEvt ) override; + virtual void KeyInput( const KeyEvent& rKEvt ) override; + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Resize() override; + virtual void Draw( OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags ) override; + virtual void GetFocus() override; + virtual void LoseFocus() override; + virtual void Tracking( const TrackingEvent& rTEvt ) override; + virtual void Command( const CommandEvent& rCEvt ) override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + virtual void Modify(); + + static bool IsCharInput( const KeyEvent& rKEvt ); + + virtual void SetModifyFlag(); + + void SetEchoChar( sal_Unicode c ); + sal_Unicode GetEchoChar() const { return mcEchoChar; } + + virtual void SetReadOnly( bool bReadOnly = true ); + virtual bool IsReadOnly() const { return mbReadOnly; } + + void SetInsertMode( bool bInsert ); + bool IsInsertMode() const; + + virtual void SetMaxTextLen( sal_Int32 nMaxLen ); + virtual sal_Int32 GetMaxTextLen() const { return mnMaxTextLen; } + + void SetWidthInChars(sal_Int32 nWidthInChars); + sal_Int32 GetWidthInChars() const { return mnWidthInChars; } + + void setMaxWidthChars(sal_Int32 nWidth); + + virtual void SetSelection( const Selection& rSelection ); + virtual const Selection& GetSelection() const; + + virtual void ReplaceSelected( const OUString& rStr ); + virtual void DeleteSelected(); + virtual OUString GetSelected() const; + + virtual void Cut(); + virtual void Copy(); + virtual void Paste(); + void Undo(); + + virtual void SetText( const OUString& rStr ) override; + virtual void SetText( const OUString& rStr, const Selection& rNewSelection ); + virtual OUString GetText() const override; + + void SetCursorAtLast(); + + void SetPlaceholderText( const OUString& rStr ); + + void SaveValue() { maSaveValue = GetText(); } + const OUString& GetSavedValue() const { return maSaveValue; } + + virtual void SetModifyHdl( const Link<Edit&,void>& rLink ) { maModifyHdl = rLink; } + virtual const Link<Edit&,void>& GetModifyHdl() const { return maModifyHdl; } + + void SetActivateHdl(const Link<Edit&,bool>& rLink) { maActivateHdl = rLink; } + + void SetSubEdit( Edit* pEdit ); + Edit* GetSubEdit() const { return mpSubEdit; } + + void SetAutocompleteHdl( const Link<Edit&,void>& rLink ) { maAutocompleteHdl = rLink; } + const Link<Edit&,void>& GetAutocompleteHdl() const { return maAutocompleteHdl; } + + virtual Size CalcMinimumSize() const; + virtual Size CalcMinimumSizeForText(const OUString &rString) const; + virtual Size GetOptimalSize() const override; + virtual Size CalcSize(sal_Int32 nChars) const; + sal_Int32 GetMaxVisChars() const; + + // shows a warning box saying "text too long, truncated" + static void ShowTruncationWarning(weld::Widget* pParent); + + VclPtr<PopupMenu> CreatePopupMenu(); + + virtual OUString GetSurroundingText() const override; + virtual Selection GetSurroundingTextSelection() const override; + virtual bool DeleteSurroundingText(const Selection& rSelection) override; + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + + void SetTextFilter(TextFilter* pFilter) { mpFilterText = pFilter; } + + virtual FactoryFunction GetUITestFactory() const override; + + void SetForceControlBackground(bool b) { mbForceControlBackground = b; } + + bool IsPassword() const { return mbPassword; } + + virtual void DumpAsPropertyTree(tools::JsonWriter& rJsonWriter) override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/field.hxx b/include/vcl/toolkit/field.hxx new file mode 100644 index 000000000..086a9d5f1 --- /dev/null +++ b/include/vcl/toolkit/field.hxx @@ -0,0 +1,627 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <sal/config.h> + +#include <string_view> + +#include <config_options.h> +#include <tools/date.hxx> +#include <tools/fldunit.hxx> +#include <tools/time.hxx> +#include <vcl/toolkit/combobox.hxx> +#include <vcl/toolkit/spinfld.hxx> +#include <vcl/formatter.hxx> + +namespace com::sun::star::lang { struct Locale; } + +class CalendarWrapper; +class LocaleDataWrapper; +class LanguageTag; + +class VCL_DLLPUBLIC FormatterBase +{ +private: + VclPtr<Edit> mpField; + mutable std::unique_ptr<LocaleDataWrapper> + mpLocaleDataWrapper; + bool mbReformat; + bool mbStrictFormat; + bool mbEmptyFieldValue; + bool mbEmptyFieldValueEnabled; + +protected: + SAL_DLLPRIVATE void ImplSetText( const OUString& rText, Selection const * pNewSel = nullptr ); + SAL_DLLPRIVATE bool ImplGetEmptyFieldValue() const { return mbEmptyFieldValue; } + + void SetEmptyFieldValueData( bool bValue ) { mbEmptyFieldValue = bValue; } + + SAL_DLLPRIVATE LocaleDataWrapper& ImplGetLocaleDataWrapper() const; + /** reset the LocaleDataWrapper when the language tag changes */ + SAL_DLLPRIVATE void ImplResetLocaleDataWrapper() const; + + Edit* GetField() const { return mpField; } + void ClearField() { mpField.clear(); } + +public: + explicit FormatterBase(Edit* pField); + virtual ~FormatterBase(); + + const LocaleDataWrapper& GetLocaleDataWrapper() const; + + bool MustBeReformatted() const { return mbReformat; } + void MarkToBeReformatted( bool b ) { mbReformat = b; } + + void SetStrictFormat( bool bStrict ); + bool IsStrictFormat() const { return mbStrictFormat; } + + virtual void Reformat(); + virtual void ReformatAll(); + + const css::lang::Locale& GetLocale() const; + const LanguageTag& GetLanguageTag() const; + + void SetEmptyFieldValue(); + bool IsEmptyFieldValue() const; + + void EnableEmptyFieldValue( bool bEnable ) { mbEmptyFieldValueEnabled = bEnable; } + bool IsEmptyFieldValueEnabled() const { return mbEmptyFieldValueEnabled; } +}; + +class VCL_DLLPUBLIC NumericFormatter : public FormatterBase +{ +public: + virtual ~NumericFormatter() override; + + virtual void Reformat() override; + + void SetMin( sal_Int64 nNewMin ); + sal_Int64 GetMin() const { return mnMin; } + void SetMax( sal_Int64 nNewMax ); + sal_Int64 GetMax() const { return mnMax; } + + sal_Int64 ClipAgainstMinMax(sal_Int64 nValue) const; + + void SetFirst( sal_Int64 nNewFirst ) { mnFirst = nNewFirst; } + sal_Int64 GetFirst() const { return mnFirst; } + void SetLast( sal_Int64 nNewLast ) { mnLast = nNewLast; } + sal_Int64 GetLast() const { return mnLast; } + void SetSpinSize( sal_Int64 nNewSize ) { mnSpinSize = nNewSize; } + sal_Int64 GetSpinSize() const { return mnSpinSize; } + + void SetDecimalDigits( sal_uInt16 nDigits ); + sal_uInt16 GetDecimalDigits() const { return mnDecimalDigits;} + + void SetUseThousandSep( bool b ); + bool IsUseThousandSep() const { return mbThousandSep; } + + void SetUserValue( sal_Int64 nNewValue ); + virtual void SetValue( sal_Int64 nNewValue ); + sal_Int64 GetValue() const; + virtual OUString CreateFieldText( sal_Int64 nValue ) const; + + sal_Int64 Normalize( sal_Int64 nValue ) const; + sal_Int64 Denormalize( sal_Int64 nValue ) const; + + OUString GetValueString() const; + void SetValueFromString(const OUString& rStr); + +protected: + sal_Int64 mnLastValue; + sal_Int64 mnMin; + sal_Int64 mnMax; + bool mbFormatting; + + // the members below are used in all derivatives of NumericFormatter + // not in NumericFormatter itself. + sal_Int64 mnSpinSize; + sal_Int64 mnFirst; + sal_Int64 mnLast; + + NumericFormatter(Edit* pEdit); + + void FieldUp(); + void FieldDown(); + void FieldFirst(); + void FieldLast(); + void FormatValue(Selection const * pNewSelection = nullptr); + + SAL_DLLPRIVATE void ImplNumericReformat(); + SAL_DLLPRIVATE void ImplNewFieldValue( sal_Int64 nNewValue ); + SAL_DLLPRIVATE void ImplSetUserValue( sal_Int64 nNewValue, Selection const * pNewSelection = nullptr ); + + virtual sal_Int64 GetValueFromString(const OUString& rStr) const; + +private: + sal_uInt16 mnDecimalDigits; + bool mbThousandSep; + +}; + +class VCL_DLLPUBLIC MetricFormatter : public NumericFormatter +{ +public: + virtual ~MetricFormatter() override; + + virtual void Reformat() override; + + virtual void SetUnit( FieldUnit meUnit ); + FieldUnit GetUnit() const { return meUnit; } + void SetCustomUnitText( const OUString& rStr ); + const OUString& GetCustomUnitText() const { return maCustomUnitText; } + + using NumericFormatter::SetMax; + void SetMax( sal_Int64 nNewMax, FieldUnit eInUnit ); + using NumericFormatter::GetMax; + sal_Int64 GetMax( FieldUnit eOutUnit ) const; + using NumericFormatter::SetMin; + void SetMin( sal_Int64 nNewMin, FieldUnit eInUnit ); + using NumericFormatter::GetMin; + sal_Int64 GetMin( FieldUnit eOutUnit ) const; + + void SetValue( sal_Int64 nNewValue, FieldUnit eInUnit ); + virtual void SetValue( sal_Int64 nValue ) override; + using NumericFormatter::SetUserValue; + void SetUserValue( sal_Int64 nNewValue, FieldUnit eInUnit ); + using NumericFormatter::GetValue; + sal_Int64 GetValue( FieldUnit eOutUnit ) const; + virtual OUString CreateFieldText( sal_Int64 nValue ) const override; + sal_Int64 GetCorrectedValue( FieldUnit eOutUnit ) const; + +protected: + FieldUnit meUnit; + + MetricFormatter(Edit* pEdit); + + SAL_DLLPRIVATE void ImplMetricReformat( const OUString& rStr, double& rValue, OUString& rOutStr ); + + virtual sal_Int64 GetValueFromString(const OUString& rStr) const override; + sal_Int64 GetValueFromStringUnit(const OUString& rStr, FieldUnit eOutUnit) const; + +private: + OUString maCustomUnitText; +}; + +class VCL_DLLPUBLIC MetricField final : public SpinField, public MetricFormatter +{ +public: + explicit MetricField( vcl::Window* pParent, WinBits nWinStyle ); + + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + virtual Size CalcMinimumSize() const override; + + virtual void Modify() override; + + virtual void Up() override; + virtual void Down() override; + virtual void First() override; + virtual void Last() override; + + virtual void SetUnit( FieldUnit meUnit ) override; + + void SetFirst( sal_Int64 nNewFirst, FieldUnit eInUnit ); + sal_Int64 GetFirst( FieldUnit eOutUnit ) const; + void SetLast( sal_Int64 nNewLast, FieldUnit eInUnit ); + sal_Int64 GetLast( FieldUnit eOutUnit ) const; + + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + virtual void dispose() override; + + virtual void DumpAsPropertyTree(tools::JsonWriter&) override; + virtual FactoryFunction GetUITestFactory() const override; +}; + +class VCL_DLLPUBLIC MetricBox final : public ComboBox, public MetricFormatter +{ +public: + explicit MetricBox( vcl::Window* pParent, WinBits nWinStyle ); + + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + virtual Size CalcMinimumSize() const override; + + virtual void Modify() override; + + virtual void ReformatAll() override; + + // Needed, because GetValue() with nPos hide these functions + using MetricFormatter::GetValue; + + virtual void dispose() override; +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) CurrencyFormatter : public NumericFormatter +{ +protected: + CurrencyFormatter(Edit* pEdit); + SAL_DLLPRIVATE void ImplCurrencyReformat( const OUString& rStr, OUString& rOutStr ); + virtual sal_Int64 GetValueFromString(const OUString& rStr) const override; + +public: + virtual ~CurrencyFormatter() override; + + virtual void Reformat() override; + + virtual void SetValue( sal_Int64 nNewValue ) override; + virtual OUString CreateFieldText( sal_Int64 nValue ) const override; +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) CurrencyField final : public SpinField, public CurrencyFormatter +{ +public: + CurrencyField( vcl::Window* pParent, WinBits nWinStyle ); + + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + virtual void Modify() override; + + virtual void Up() override; + virtual void Down() override; + virtual void First() override; + virtual void Last() override; + virtual void dispose() override; +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) TimeFormatter : public FormatterBase +{ +private: + tools::Time maLastTime; + tools::Time maMin; + tools::Time maMax; + TimeFieldFormat meFormat; + TimeFormat mnTimeFormat; + bool mbDuration; + bool mbEnforceValidValue; + +protected: + tools::Time maFieldTime; + + TimeFormatter(Edit* pEdit); + + SAL_DLLPRIVATE void ImplTimeReformat( std::u16string_view rStr, OUString& rOutStr ); + SAL_DLLPRIVATE void ImplNewFieldValue( const tools::Time& rTime ); + SAL_DLLPRIVATE void ImplSetUserTime( const tools::Time& rNewTime, Selection const * pNewSelection = nullptr ); + SAL_DLLPRIVATE bool ImplAllowMalformedInput() const; + +public: + static OUString FormatTime(const tools::Time& rNewTime, TimeFieldFormat eFormat, TimeFormat eHourFormat, bool bDuration, const LocaleDataWrapper& rLocaleData); + static bool TextToTime(std::u16string_view rStr, tools::Time& rTime, TimeFieldFormat eFormat, bool bDuration, const LocaleDataWrapper& rLocaleDataWrapper, bool _bSkipInvalidCharacters = true); + static int GetTimeArea(TimeFieldFormat eFormat, std::u16string_view rText, int nCursor, + const LocaleDataWrapper& rLocaleDataWrapper); + static tools::Time SpinTime(bool bUp, const tools::Time& rTime, TimeFieldFormat eFormat, + bool bDuration, std::u16string_view rText, int nCursor, + const LocaleDataWrapper& rLocaleDataWrapper); + + virtual ~TimeFormatter() override; + + virtual void Reformat() override; + virtual void ReformatAll() override; + + void SetMin( const tools::Time& rNewMin ); + const tools::Time& GetMin() const { return maMin; } + void SetMax( const tools::Time& rNewMax ); + const tools::Time& GetMax() const { return maMax; } + + void SetTimeFormat( TimeFormat eNewFormat ); + TimeFormat GetTimeFormat() const { return mnTimeFormat;} + + void SetFormat( TimeFieldFormat eNewFormat ); + TimeFieldFormat GetFormat() const { return meFormat; } + + void SetDuration( bool mbDuration ); + bool IsDuration() const { return mbDuration; } + + void SetTime( const tools::Time& rNewTime ); + void SetUserTime( const tools::Time& rNewTime ); + tools::Time GetTime() const; + void SetEmptyTime() { FormatterBase::SetEmptyFieldValue(); } + bool IsEmptyTime() const { return FormatterBase::IsEmptyFieldValue(); } + + /** enables or disables the enforcement of valid values + + If this is set to true (which is the default), then GetTime will always return a valid + time, no matter whether the current text can really be interpreted as time. (Note: this + is the compatible behavior). + + If this is set to false, the GetTime will return GetInvalidTime, in case the current text + cannot be interpreted as time. + + In addition, if this is set to false, the text in the field will <em>not</em> be corrected + when the control loses the focus - instead, the invalid input will be preserved. + */ + void EnforceValidValue( bool _bEnforce ) { mbEnforceValidValue = _bEnforce; } + bool IsEnforceValidValue( ) const { return mbEnforceValidValue; } +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) TimeField final : public SpinField, public TimeFormatter +{ +private: + tools::Time maFirst; + tools::Time maLast; + + SAL_DLLPRIVATE void ImplTimeSpinArea( bool bUp ); + +public: + explicit TimeField( vcl::Window* pParent, WinBits nWinStyle ); + + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + virtual void Modify() override; + + virtual void Up() override; + virtual void Down() override; + virtual void First() override; + virtual void Last() override; + + void SetFirst( const tools::Time& rNewFirst ) { maFirst = rNewFirst; } + const tools::Time& GetFirst() const { return maFirst; } + void SetLast( const tools::Time& rNewLast ) { maLast = rNewLast; } + const tools::Time& GetLast() const { return maLast; } + + void SetExtFormat( ExtTimeFieldFormat eFormat ); + virtual void dispose() override; +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) DateFormatter : public FormatterBase +{ +private: + Formatter::StaticFormatter maStaticFormatter; + std::unique_ptr<CalendarWrapper> mxCalendarWrapper; + Date maFieldDate; + Date maLastDate; + Date maMin; + Date maMax; + bool mbLongFormat; + bool mbShowDateCentury; + ExtDateFieldFormat mnExtDateFormat; + bool mbEnforceValidValue; + +protected: + DateFormatter(Edit* pEdit); + + SAL_DLLPRIVATE const Date& ImplGetFieldDate() const { return maFieldDate; } + SAL_DLLPRIVATE void ImplDateReformat( const OUString& rStr, OUString& rOutStr ); + SAL_DLLPRIVATE void ImplSetUserDate( const Date& rNewDate, + Selection const * pNewSelection = nullptr ); + SAL_DLLPRIVATE OUString ImplGetDateAsText( const Date& rDate ) const; + SAL_DLLPRIVATE void ImplNewFieldValue( const Date& rDate ); + CalendarWrapper& GetCalendarWrapper() const; + + SAL_DLLPRIVATE bool ImplAllowMalformedInput() const; + +public: + static OUString FormatDate(const Date& rNewDate, ExtDateFieldFormat eFormat, const LocaleDataWrapper& rLocaleData, const Formatter::StaticFormatter& rStaticFormatter); + static bool TextToDate(const OUString& rStr, Date& rTime, ExtDateFieldFormat eFormat, const LocaleDataWrapper& rLocaleDataWrapper, const CalendarWrapper& rCalendarWrapper); + static int GetDateArea(ExtDateFieldFormat& eFormat, std::u16string_view rText, int nCursor, const LocaleDataWrapper& rLocaleDataWrapper); + + virtual ~DateFormatter() override; + + virtual void Reformat() override; + virtual void ReformatAll() override; + + void SetExtDateFormat( ExtDateFieldFormat eFormat ); + ExtDateFieldFormat GetExtDateFormat( bool bResolveSystemFormat = false ) const; + + void SetMin( const Date& rNewMin ); + const Date& GetMin() const { return maMin; } + + void SetMax( const Date& rNewMax ); + const Date& GetMax() const { return maMax; } + + + // MT: Remove these methods too, ExtDateFormat should be enough! + // What should happen if using DDMMYYYY, but ShowCentury=false? + + void SetLongFormat( bool bLong ); + bool IsLongFormat() const { return mbLongFormat; } + void SetShowDateCentury( bool bShowCentury ); + bool IsShowDateCentury() const { return mbShowDateCentury; } + + + void SetDate( const Date& rNewDate ); + Date GetDate() const; + void SetEmptyDate(); + bool IsEmptyDate() const; + + void ResetLastDate() { maLastDate = Date( Date::EMPTY ); } + + static void ExpandCentury( Date& rDate ); + static void ExpandCentury( Date& rDate, sal_uInt16 nTwoDigitYearStart ); + + /** enables or disables the enforcement of valid values + + If this is set to true (which is the default), then GetDate will always return a valid + date, no matter whether the current text can really be interpreted as date. (Note: this + is the compatible behavior). + + If this is set to false, the GetDate will return GetInvalidDate, in case the current text + cannot be interpreted as date. + + In addition, if this is set to false, the text in the field will \em not be corrected + when the control loses the focus - instead, the invalid input will be preserved. + */ + void EnforceValidValue( bool _bEnforce ) { mbEnforceValidValue = _bEnforce; } + bool IsEnforceValidValue( ) const { return mbEnforceValidValue; } +}; + +class SAL_DLLPUBLIC_RTTI DateField : public SpinField, public DateFormatter +{ +private: + Date maFirst; + Date maLast; + +protected: + void ImplDateSpinArea( bool bUp ); + +public: + explicit DateField( vcl::Window* pParent, WinBits nWinStyle ); + + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + virtual void Modify() override; + + virtual void Up() override; + virtual void Down() override; + virtual void First() override; + virtual void Last() override; + + void SetFirst( const Date& rNewFirst ) { maFirst = rNewFirst; } + const Date& GetFirst() const { return maFirst; } + void SetLast( const Date& rNewLast ) { maLast = rNewLast; } + const Date& GetLast() const { return maLast; } + virtual void dispose() override; +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) NumericBox final : public ComboBox, public NumericFormatter +{ + SAL_DLLPRIVATE void ImplNumericReformat( const OUString& rStr, sal_Int64& rValue, OUString& rOutStr ); +public: + explicit NumericBox( vcl::Window* pParent, WinBits nWinStyle ); + + virtual Size CalcMinimumSize() const override; + + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + virtual void Modify() override; + + virtual void ReformatAll() override; + + virtual void dispose() override; +}; + +#define PATTERN_FORMAT_EMPTYLITERALS (sal_uInt16(0x0001)) + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) PatternFormatter : public FormatterBase +{ +private: + OString m_aEditMask; + OUString maLiteralMask; + bool mbSameMask; + bool mbInPattKeyInput; + +protected: + PatternFormatter(Edit* pEdit); + + SAL_DLLPRIVATE bool ImplIsSameMask() const { return mbSameMask; } + SAL_DLLPRIVATE bool& ImplGetInPattKeyInput() { return mbInPattKeyInput; } + +public: + virtual ~PatternFormatter() override; + + virtual void Reformat() override; + + void SetMask(const OString& rEditMask, const OUString& rLiteralMask ); + const OString& GetEditMask() const { return m_aEditMask; } + const OUString& GetLiteralMask() const { return maLiteralMask; } + + void SetString( const OUString& rStr ); + OUString GetString() const; +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) PatternField final : public SpinField, public PatternFormatter +{ +public: + explicit PatternField( vcl::Window* pParent, WinBits nWinStyle ); + + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void Modify() override; + virtual void dispose() override; +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) PatternBox final : public ComboBox, public PatternFormatter +{ +public: + PatternBox( vcl::Window* pParent, WinBits nWinStyle ); + + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + + virtual void Modify() override; + + virtual void ReformatAll() override; + virtual void dispose() override; +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) CurrencyBox final : public ComboBox, public CurrencyFormatter +{ +public: + explicit CurrencyBox( vcl::Window* pParent, WinBits nWinStyle ); + + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + virtual void Modify() override; + + virtual void ReformatAll() override; + + virtual void dispose() override; +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) DateBox final : public ComboBox, public DateFormatter +{ +public: + explicit DateBox( vcl::Window* pParent, WinBits nWinStyle ); + + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + virtual void Modify() override; + + virtual void ReformatAll() override; + virtual void dispose() override; +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) TimeBox final : public ComboBox, public TimeFormatter +{ +public: + explicit TimeBox( vcl::Window* pParent, WinBits nWinStyle ); + + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + virtual void Modify() override; + + virtual void ReformatAll() override; + virtual void dispose() override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/fixed.hxx b/include/vcl/toolkit/fixed.hxx new file mode 100644 index 000000000..238d1cbdf --- /dev/null +++ b/include/vcl/toolkit/fixed.hxx @@ -0,0 +1,181 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <vcl/dllapi.h> +#include <vcl/toolkit/edit.hxx> +#include <vcl/ctrl.hxx> +#include <vcl/image.hxx> + +class VCL_DLLPUBLIC FixedText : public Control +{ +private: + sal_Int32 m_nMaxWidthChars; + sal_Int32 m_nMinWidthChars; + VclPtr<vcl::Window> m_pMnemonicWindow; + + using Control::ImplInitSettings; + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + SAL_DLLPRIVATE static WinBits ImplInitStyle( WinBits nStyle ); + SAL_DLLPRIVATE void ImplDraw( OutputDevice* pDev, SystemTextColorFlags nSystemTextColorFlags, + const Point& rPos, const Size& rSize, bool bFillLayout = false ) const; +public: + SAL_DLLPRIVATE static DrawTextFlags ImplGetTextStyle( WinBits nWinBits ); +protected: + virtual void FillLayoutData() const override; + virtual const vcl::Font& + GetCanonicalFont( const StyleSettings& _rStyle ) const override; + virtual const Color& + GetCanonicalTextColor( const StyleSettings& _rStyle ) const override; + + virtual vcl::Window* getAccessibleRelationLabelFor() const override; + +public: + explicit FixedText( vcl::Window* pParent, WinBits nStyle = 0 ); + virtual ~FixedText() override; + virtual void dispose() override; + + virtual void ApplySettings(vcl::RenderContext& rRenderContext) override; + + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Draw( OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags ) override; + virtual void Resize() override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + void setMaxWidthChars(sal_Int32 nWidth); + void setMinWidthChars(sal_Int32 nWidth); + static Size CalcMinimumTextSize(Control const* pControl, tools::Long nMaxWidth = 0x7fffffff); + static Size getTextDimensions(Control const *pControl, const OUString &rTxt, tools::Long nMaxWidth); + Size CalcMinimumSize(tools::Long nMaxWidth = 0x7fffffff) const; + virtual Size GetOptimalSize() const override; + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + void set_mnemonic_widget(vcl::Window *pWindow); + vcl::Window* get_mnemonic_widget() const { return m_pMnemonicWindow; } +}; + +class SelectableFixedText final : public Edit +{ +public: + explicit SelectableFixedText( vcl::Window* pParent, WinBits nStyle ); + + virtual void LoseFocus() override; + virtual void ApplySettings(vcl::RenderContext&) override; + virtual void DumpAsPropertyTree(tools::JsonWriter& rJsonWriter) override; +}; + +class VCL_DLLPUBLIC FixedLine final : public Control +{ +private: + using Control::ImplInitSettings; + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + SAL_DLLPRIVATE static WinBits ImplInitStyle( WinBits nStyle ); + SAL_DLLPRIVATE void ImplDraw(vcl::RenderContext& rRenderContext); + + virtual void FillLayoutData() const override; + virtual const vcl::Font& + GetCanonicalFont( const StyleSettings& _rStyle ) const override; + virtual const Color& + GetCanonicalTextColor( const StyleSettings& _rStyle ) const override; + +public: + explicit FixedLine( vcl::Window* pParent, WinBits nStyle = WB_HORZ ); + + virtual void ApplySettings(vcl::RenderContext&) override; + + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Draw( OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags ) override; + virtual void Resize() override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + virtual Size GetOptimalSize() const override; + virtual void DumpAsPropertyTree(tools::JsonWriter& rJsonWriter) override; +}; + +class VCL_DLLPUBLIC FixedBitmap final : public Control +{ +private: + BitmapEx maBitmap; + + using Control::ImplInitSettings; + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + SAL_DLLPRIVATE static WinBits ImplInitStyle( WinBits nStyle ); + SAL_DLLPRIVATE void ImplDraw( OutputDevice* pDev, const Point& rPos, const Size& rSize ); + +public: + explicit FixedBitmap( vcl::Window* pParent, WinBits nStyle = 0 ); + + virtual void ApplySettings(vcl::RenderContext&) override; + + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Draw( OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags ) override; + virtual void Resize() override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + void SetBitmap( const BitmapEx& rBitmap ); +}; + +class VCL_DLLPUBLIC FixedImage : public Control +{ +private: + Image maImage; + +private: + using Control::ImplInitSettings; + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + SAL_DLLPRIVATE static WinBits ImplInitStyle( WinBits nStyle ); + +protected: + SAL_DLLPRIVATE void ImplDraw( OutputDevice* pDev, + const Point& rPos, const Size& rSize ); +public: + explicit FixedImage( vcl::Window* pParent, WinBits nStyle = 0 ); + + virtual void ApplySettings(vcl::RenderContext&) override; + + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Draw( OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags ) override; + virtual void Resize() override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + virtual Size GetOptimalSize() const override; + + void SetImage( const Image& rImage ); + const Image& GetImage() const { return maImage; } + + const Image& GetModeImage( ) const { return maImage;} + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + + static Image loadThemeImage(const OUString &rFileName); + + void DumpAsPropertyTree(tools::JsonWriter& rJsonWriter) override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/fixedhyper.hxx b/include/vcl/toolkit/fixedhyper.hxx new file mode 100644 index 000000000..6abfa0ac3 --- /dev/null +++ b/include/vcl/toolkit/fixedhyper.hxx @@ -0,0 +1,118 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <config_options.h> +#include <vcl/dllapi.h> +#include <vcl/toolkit/fixed.hxx> + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) FixedHyperlink final : public FixedText +{ +private: + tools::Long m_nTextLen; + PointerStyle m_aOldPointer; + Link<FixedHyperlink&,void> m_aClickHdl; + OUString m_sURL; + + /** initializes the font (link color and underline). + + Called by the Ctors. + */ + void Initialize(); + + /** is position X position hitting text */ + SAL_DLLPRIVATE bool ImplIsOverText(Point rPosition) const; + + DECL_DLLPRIVATE_LINK(HandleClick, FixedHyperlink&, void); + + /** overwrites Window::MouseMove(). + + Changes the pointer only over the text. + */ + virtual void MouseMove( const MouseEvent& rMEvt ) override; + + /** overwrites Window::MouseButtonUp(). + + Calls the set link if the mouse is over the text. + */ + virtual void MouseButtonUp( const MouseEvent& rMEvt ) override; + + /** overwrites Window::RequestHelp(). + + Shows tooltip only if the mouse is over the text. + */ + virtual void RequestHelp( const HelpEvent& rHEvt ) override; + +public: + /** ctors + + With WinBits. + */ + FixedHyperlink( vcl::Window* pParent, WinBits nWinStyle = 0 ); + + /** overwrites Window::GetFocus(). + + Changes the color of the text and shows a focus rectangle. + */ + virtual void GetFocus() override; + + /** overwrites Window::LoseFocus(). + + Changes the color of the text and hides the focus rectangle. + */ + virtual void LoseFocus() override; + + /** overwrites Window::KeyInput(). + + KEY_RETURN and KEY_SPACE calls the link handler. + */ + virtual void KeyInput( const KeyEvent& rKEvt ) override; + + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + + + /** sets m_aClickHdl with rLink. + + m_aClickHdl is called if the text is clicked. + */ + void SetClickHdl( const Link<FixedHyperlink&,void>& rLink ) { m_aClickHdl = rLink; } + const Link<FixedHyperlink&,void>& GetClickHdl() const { return m_aClickHdl; } + + // ::FixedHyperbaseLink + + /** sets the URL of the hyperlink and uses it as tooltip. */ + void SetURL(const OUString& rNewURL); + + /** returns the URL of the hyperlink. + + @return + m_sURL + */ + const OUString& GetURL() const { return m_sURL;} + + /** sets new text and recalculates the text length. */ + virtual void SetText(const OUString& rNewDescription) override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/floatwin.hxx b/include/vcl/toolkit/floatwin.hxx new file mode 100644 index 000000000..6799ac884 --- /dev/null +++ b/include/vcl/toolkit/floatwin.hxx @@ -0,0 +1,140 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <vcl/dllapi.h> +#include <vcl/syswin.hxx> +#include <memory> +#include <o3tl/typed_flags_set.hxx> + +class ToolBox; + +enum class FloatWinPopupEndFlags +{ + NONE = 0x00, + Cancel = 0x01, + TearOff = 0x02, + DontCallHdl = 0x04, + CloseAll = 0x08, + NoCloseChildren = 0x10, +}; +namespace o3tl +{ + template<> struct typed_flags<FloatWinPopupEndFlags> : is_typed_flags<FloatWinPopupEndFlags, 0x1f> {}; +} + +enum class FloatWinTitleType +{ + Unknown = 0, + Normal = 1, + TearOff = 2, + Popup = 3, + NONE = 4, +}; + +class VCL_DLLPUBLIC FloatingWindow : public SystemWindow +{ + class SAL_DLLPRIVATE ImplData; +private: + VclPtr<FloatingWindow> mpNextFloat; + VclPtr<vcl::Window> mpFirstPopupModeWin; + VclPtr<vcl::Window> mxPrevFocusWin; + std::unique_ptr<ImplData> mpImplData; + tools::Rectangle maFloatRect; + ImplSVEvent * mnPostId; + FloatWinPopupFlags mnPopupModeFlags; + FloatWinTitleType mnTitle; + FloatWinTitleType mnOldTitle; + bool mbInPopupMode; + bool mbPopupMode; + bool mbPopupModeCanceled; + bool mbPopupModeTearOff; + bool mbMouseDown; + bool mbGrabFocus; // act as key input window, although focus is not set + bool mbInCleanUp; + Link<FloatingWindow*,void> maPopupModeEndHdl; + + SAL_DLLPRIVATE void ImplCallPopupModeEnd(); + DECL_DLLPRIVATE_LINK( ImplEndPopupModeHdl, void*, void ); + + FloatingWindow (const FloatingWindow &) = delete; + FloatingWindow & operator= (const FloatingWindow &) = delete; + +protected: + SAL_DLLPRIVATE void ImplInitFloating( vcl::Window* pParent, WinBits nStyle ); + SAL_DLLPRIVATE void ImplInitSettings(); + + virtual void ApplySettings(vcl::RenderContext& rRenderContext) override; + +public: + SAL_DLLPRIVATE FloatingWindow* ImplFloatHitTest( vcl::Window* pReference, const Point& rPos, bool& rbHitTestInsideRect ); + SAL_DLLPRIVATE FloatingWindow* ImplFindLastLevelFloat(); + SAL_DLLPRIVATE bool ImplIsFloatPopupModeWindow( const vcl::Window* pWindow ); + SAL_DLLPRIVATE void ImplSetMouseDown() { mbMouseDown = true; } + SAL_DLLPRIVATE bool ImplIsMouseDown() const { return mbMouseDown; } + static Point ImplCalcPos(vcl::Window* pWindow, + const tools::Rectangle& rRect, FloatWinPopupFlags nFlags, + sal_uInt16& rArrangeIndex, Point* pLOKTwipsPos = nullptr); + static Point ImplConvertToAbsPos(vcl::Window* pReference, const Point& rPos); + static tools::Rectangle ImplConvertToAbsPos(vcl::Window* pReference, const tools::Rectangle& rRect); + static tools::Rectangle ImplConvertToRelPos(vcl::Window* pReference, const tools::Rectangle& rRect); + SAL_DLLPRIVATE void ImplEndPopupMode( FloatWinPopupEndFlags nFlags, const VclPtr<vcl::Window>& xFocusId ); + SAL_DLLPRIVATE tools::Rectangle& ImplGetItemEdgeClipRect(); + SAL_DLLPRIVATE bool ImplIsInPrivatePopupMode() const { return mbInPopupMode; } + virtual void doDeferredInit(WinBits nBits) override; + void PixelInvalidate(const tools::Rectangle* pRectangle) override; + +public: + explicit FloatingWindow(vcl::Window* pParent, WinBits nStyle); + explicit FloatingWindow(vcl::Window* pParent, const OString& rID, const OUString& rUIXMLDescription, + const css::uno::Reference<css::frame::XFrame> &rFrame = css::uno::Reference<css::frame::XFrame>()); + virtual ~FloatingWindow() override; + virtual void dispose() override; + + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + virtual void PopupModeEnd(); + + void SetTitleType( FloatWinTitleType nTitle ); + FloatWinTitleType GetTitleType() const { return mnTitle; } + + void StartPopupMode( const tools::Rectangle& rRect, FloatWinPopupFlags nFlags ); + void StartPopupMode( ToolBox* pBox, FloatWinPopupFlags nFlags ); + void EndPopupMode( FloatWinPopupEndFlags nFlags = FloatWinPopupEndFlags::NONE ); + void AddPopupModeWindow( vcl::Window* pWindow ); + FloatWinPopupFlags GetPopupModeFlags() const { return mnPopupModeFlags; } + void SetPopupModeFlags( FloatWinPopupFlags nFlags ) { mnPopupModeFlags = nFlags; } + bool IsInPopupMode() const { return mbPopupMode; } + bool IsInCleanUp() const { return mbInCleanUp; } + bool IsPopupModeCanceled() const { return mbPopupModeCanceled; } + bool IsPopupModeTearOff() const { return mbPopupModeTearOff; } + + void SetPopupModeEndHdl( const Link<FloatingWindow*,void>& rLink ) { maPopupModeEndHdl = rLink; } + + bool GrabsFocus() const { return mbGrabFocus; } +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/fmtfield.hxx b/include/vcl/toolkit/fmtfield.hxx new file mode 100644 index 000000000..56992ddb4 --- /dev/null +++ b/include/vcl/toolkit/fmtfield.hxx @@ -0,0 +1,100 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <vcl/formatter.hxx> +#include <vcl/toolkit/spinfld.hxx> + +class VCL_DLLPUBLIC FormattedField : public SpinField +{ +public: + FormattedField(vcl::Window* pParent, WinBits nStyle); + + virtual void dispose() override; + + // Spin-Handling + virtual void Up() override; + virtual void Down() override; + // Default Implementation: +/- default spin size to the double value + virtual void First() override; + virtual void Last() override; + // Default Implementation: Current double is set to the first or last value + + virtual bool set_property(const OString &rKey, const OUString &rValue) override; +public: + virtual void SetText( const OUString& rStr ) override; + virtual void SetText( const OUString& rStr, const Selection& rNewSelection ) override; + + void SetValueFromString(const OUString& rStr); // currently used by online + + virtual void DumpAsPropertyTree(tools::JsonWriter&) override; + + virtual FactoryFunction GetUITestFactory() const override; + + Formatter& GetFormatter(); + void SetFormatter(Formatter* pFormatter); + +protected: + std::unique_ptr<Formatter> m_xOwnFormatter; + Formatter* m_pFormatter; + + virtual bool EventNotify(NotifyEvent& rNEvt) override; + virtual void Modify() override; + + bool PreNotify(NotifyEvent& rNEvt) override; +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) DoubleNumericField final : public FormattedField +{ +public: + DoubleNumericField(vcl::Window* pParent, WinBits nStyle); + + virtual ~DoubleNumericField() override; + + validation::NumberValidator& GetNumberValidator() { return *m_pNumberValidator; } + void ResetConformanceTester(); + +private: + + std::unique_ptr<validation::NumberValidator> m_pNumberValidator; +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) DoubleCurrencyField final : public FormattedField +{ +public: + DoubleCurrencyField(vcl::Window* pParent, WinBits nStyle); + + const OUString& getCurrencySymbol() const { return m_sCurrencySymbol; } + void setCurrencySymbol(const OUString& rSymbol); + + bool getPrependCurrSym() const { return m_bPrependCurrSym; } + void setPrependCurrSym(bool _bPrepend); + + void UpdateCurrencyFormat(); +private: + OUString m_sCurrencySymbol; + bool m_bPrependCurrSym; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/group.hxx b/include/vcl/toolkit/group.hxx new file mode 100644 index 000000000..81e595ec2 --- /dev/null +++ b/include/vcl/toolkit/group.hxx @@ -0,0 +1,57 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <config_options.h> +#include <vcl/dllapi.h> +#include <vcl/ctrl.hxx> + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) GroupBox final : public Control +{ +private: + using Control::ImplInitSettings; + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + SAL_DLLPRIVATE static WinBits ImplInitStyle( WinBits nStyle ); + SAL_DLLPRIVATE void ImplInitSettings( bool bBackground ); + SAL_DLLPRIVATE void ImplDraw( OutputDevice* pDev, SystemTextColorFlags nSystemTextColorFlags, + const Point& rPos, const Size& rSize, bool bLayout = false ); + + virtual void FillLayoutData() const override; + virtual const vcl::Font& + GetCanonicalFont( const StyleSettings& _rStyle ) const override; + virtual const Color& + GetCanonicalTextColor( const StyleSettings& _rStyle ) const override; + +public: + explicit GroupBox( vcl::Window* pParent, WinBits nStyle ); + + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Draw( OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags ) override; + virtual void Resize() override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/imgctrl.hxx b/include/vcl/toolkit/imgctrl.hxx new file mode 100644 index 000000000..20b1863a0 --- /dev/null +++ b/include/vcl/toolkit/imgctrl.hxx @@ -0,0 +1,52 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <config_options.h> +#include <vcl/dllapi.h> +#include <vcl/toolkit/fixed.hxx> + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) ImageControl : public FixedImage +{ +private: + ::sal_Int16 mnScaleMode; + +public: + ImageControl( vcl::Window* pParent, WinBits nStyle ); + + // set/get the scale mode. This is one of the css.awt.ImageScaleMode constants + void SetScaleMode( const ::sal_Int16 _nMode ); + ::sal_Int16 GetScaleMode() const { return mnScaleMode; } + + virtual void Resize() override; + virtual void Draw( OutputDevice* pDev, const Point& rPos,SystemTextColorFlags nFlags ) override; + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void GetFocus() override; + virtual void LoseFocus() override; + +protected: + void ImplDraw( OutputDevice& rDev, const Point& rPos, const Size& rSize ) const; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/ivctrl.hxx b/include/vcl/toolkit/ivctrl.hxx new file mode 100644 index 000000000..502d16d09 --- /dev/null +++ b/include/vcl/toolkit/ivctrl.hxx @@ -0,0 +1,259 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <memory> +#include <vcl/dllapi.h> +#include <vcl/ctrl.hxx> +#include <tools/link.hxx> +#include <vcl/image.hxx> +#include <o3tl/deleter.hxx> +#include <o3tl/typed_flags_set.hxx> + +class SvxIconChoiceCtrl_Impl; + +enum class SvxIconViewFlags +{ + NONE = 0x0000, + POS_LOCKED = 0x0001, + SELECTED = 0x0002, + FOCUSED = 0x0004, + POS_MOVED = 0x0008, // Moved by Drag and Drop, but not logged +}; +namespace o3tl +{ + template<> struct typed_flags<SvxIconViewFlags> : is_typed_flags<SvxIconViewFlags, 0x000f> {}; +} + +enum class SvxIconChoiceCtrlTextMode +{ + Full = 1, // Enlarge BoundRect southwards + Short // Shorten with "..." +}; + +enum class SvxIconChoiceCtrlPositionMode +{ + Free, // Free pixel-perfect positioning + AutoArrange, // Auto arrange +}; + +class SvxIconChoiceCtrlEntry +{ + Image aImage; + + OUString aText; + OUString aQuickHelpText; + + friend class SvxIconChoiceCtrl_Impl; + friend class IcnCursor_Impl; + friend class EntryList_Impl; + friend class IcnGridMap_Impl; + + tools::Rectangle aRect; // Bounding-Rectangle of the entry + tools::Rectangle aGridRect; // Only valid in Grid-mode + sal_Int32 nPos; + + /* + The insert position in the Insertlist is equal to the (sort) order stated at the Insert + (-> Order of the anchors in the anchors-list!). In "AutoArrange" mode the visible order + can differ. The entries will be linked because of this. + */ + SvxIconChoiceCtrlEntry* pblink; // backward (linker neighbour) + SvxIconChoiceCtrlEntry* pflink; // forward (rechter neighbour) + + SvxIconChoiceCtrlTextMode eTextMode; + sal_uInt16 nX,nY; // for keyboard control + SvxIconViewFlags nFlags; + + void ClearFlags( SvxIconViewFlags nMask ) { nFlags &= ~nMask; } + void SetFlags( SvxIconViewFlags nMask ) { nFlags |= nMask; } + void AssignFlags( SvxIconViewFlags _nFlags ) { nFlags = _nFlags; } + + // set left neighbour (A <-> B ==> A <-> this <-> B) + void SetBacklink( SvxIconChoiceCtrlEntry* pA ) + { + pA->pflink->pblink = this; // X <- B + this->pflink = pA->pflink; // X -> B + this->pblink = pA; // A <- X + pA->pflink = this; // A -> X + } + // Unlink (A <-> this <-> B ==> A <-> B) + void Unlink() + { + this->pblink->pflink = this->pflink; + this->pflink->pblink = this->pblink; + this->pflink = nullptr; + this->pblink = nullptr; + } + +public: + SvxIconChoiceCtrlEntry( const OUString& rText, const Image& rImage ); + + const Image& GetImage () const { return aImage; } + void SetText ( const OUString& rText ) { aText = rText; } + const OUString& GetText () const { return aText; } + OUString VCL_DLLPUBLIC GetDisplayText() const; + void SetQuickHelpText( const OUString& rText ) { aQuickHelpText = rText; } + const OUString& GetQuickHelpText() const { return aQuickHelpText; } + + SvxIconChoiceCtrlTextMode GetTextMode() const { return eTextMode; } + SvxIconViewFlags GetFlags() const { return nFlags; } + bool IsSelected() const { return bool(nFlags & SvxIconViewFlags::SELECTED); } + bool IsFocused() const { return bool(nFlags & SvxIconViewFlags::FOCUSED); } + bool IsPosLocked() const { return bool(nFlags & SvxIconViewFlags::POS_LOCKED); } +}; + +class SvxIconChoiceCtrlColumnInfo +{ + tools::Long nWidth; + +public: + SvxIconChoiceCtrlColumnInfo() : + nWidth( 100 ) {} + SvxIconChoiceCtrlColumnInfo( const SvxIconChoiceCtrlColumnInfo& ); + + void SetWidth( tools::Long nWd ) { nWidth = nWd; } + tools::Long GetWidth() const { return nWidth; } +}; + + +/* + Window-Bits: + WB_ICON // Text beneath the icon + WB_SMALL_ICON // Text right to the icon, position does not mind + WB_DETAILS // Text right to the icon, limited positioning + WB_BORDER + WB_NOHIDESELECTION // Draw selection inactively, if not focused. + WB_NOHSCROLL + WB_NOVSCROLL + WB_NOSELECTION + WB_SMART_ARRANGE // Keep Visible-Area at arrange + WB_ALIGN_TOP // Align line vy line LTR + WB_ALIGN_LEFT // Align columns from top to bottom + WB_NODRAGSELECTION // No selection with tracking rectangle + WB_NOCOLUMNHEADER // No Headerbar in Details view (Headerbar not implemented) + WB_NOPOINTERFOCUS // No GrabFocus at MouseButtonDown + WB_HIGHLIGHTFRAME // The entry beneath the mouse will be highlighted + WB_NOASYNCSELECTHDL // Do not collect events -> Selection handlers will be called synchronously +*/ + +#define WB_ICON WB_RECTSTYLE +#define WB_SMALLICON WB_SMALLSTYLE +#define WB_DETAILS WB_VCENTER +#define WB_NOHSCROLL WB_SPIN +#define WB_NOVSCROLL WB_DRAG +#define WB_NOSELECTION WB_REPEAT +#define WB_NODRAGSELECTION WB_PATHELLIPSIS +#define WB_SMART_ARRANGE 0x01000000 // used to be WB_PASSWORD +#define WB_ALIGN_TOP WB_TOP +#define WB_ALIGN_LEFT WB_LEFT +#define WB_NOCOLUMNHEADER WB_CENTER +#define WB_HIGHLIGHTFRAME WB_IGNORETAB +#define WB_NOASYNCSELECTHDL WB_NOLABEL + +class MnemonicGenerator; + +class VCL_DLLPUBLIC SvtIconChoiceCtrl final : public Control +{ + friend class SvxIconChoiceCtrl_Impl; + + Link<SvtIconChoiceCtrl*,void> _aClickIconHdl; + std::unique_ptr<SvxIconChoiceCtrl_Impl, o3tl::default_delete<SvxIconChoiceCtrl_Impl>> _pImpl; + + virtual void KeyInput( const KeyEvent& rKEvt ) override; + virtual void Command( const CommandEvent& rCEvt ) override; + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void MouseButtonUp( const MouseEvent& rMEvt ) override; + virtual void MouseMove( const MouseEvent& rMEvt ) override; + virtual void Resize() override; + virtual void GetFocus() override; + virtual void LoseFocus() override; + void ClickIcon(); + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + virtual void RequestHelp( const HelpEvent& rHEvt ) override; + static void DrawEntryImage( + SvxIconChoiceCtrlEntry const * pEntry, + const Point& rPos, + OutputDevice& rDev ); + + static OUString GetEntryText( SvxIconChoiceCtrlEntry const * pEntry ); + + virtual void FillLayoutData() const override; + + void CallImplEventListeners(VclEventId nEvent, void* pData); + +public: + + SvtIconChoiceCtrl( vcl::Window* pParent, WinBits nWinStyle ); + virtual ~SvtIconChoiceCtrl() override; + virtual void dispose() override; + + WinBits GetStyle() const; + void SetSelectionMode(SelectionMode eMode); + + void SetFont( const vcl::Font& rFont ); + void SetPointFont( const vcl::Font& rFont ); + + void SetClickHdl( const Link<SvtIconChoiceCtrl*,void>& rLink ) { _aClickIconHdl = rLink; } + + using Window::SetBackground; + void SetBackground( const Wallpaper& rWallpaper ); + + void ArrangeIcons(); + + + SvxIconChoiceCtrlEntry* InsertEntry( const OUString& rText, + const Image& rImage); + + void RemoveEntry(sal_Int32 nEntryListPos); + + bool DoKeyInput( const KeyEvent& rKEvt ); + + sal_Int32 GetEntryCount() const; + SvxIconChoiceCtrlEntry* GetEntry( sal_Int32 nPos ) const; + sal_Int32 GetEntryListPos( SvxIconChoiceCtrlEntry const * pEntry ) const; + using Window::SetCursor; + void SetCursor( SvxIconChoiceCtrlEntry* pEntry ); + SvxIconChoiceCtrlEntry* GetCursor() const; + + // sal_uLong is the position of the selected element in the list + SvxIconChoiceCtrlEntry* GetSelectedEntry() const; + +#ifdef DBG_UTIL + void SetEntryTextMode( SvxIconChoiceCtrlTextMode eMode, SvxIconChoiceCtrlEntry* pEntry ); +#endif + + tools::Rectangle GetBoundingBox( SvxIconChoiceCtrlEntry* pEntry ) const; + tools::Rectangle GetEntryCharacterBounds( const sal_Int32 _nEntryPos, const sal_Int32 _nCharacterIndex ) const; + + void SetNoSelection(); + + // ACCESSIBILITY ========================================================== + + /** Creates and returns the accessible object of the Box. */ + virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessible() override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/longcurr.hxx b/include/vcl/toolkit/longcurr.hxx new file mode 100644 index 000000000..3206f3980 --- /dev/null +++ b/include/vcl/toolkit/longcurr.hxx @@ -0,0 +1,74 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <config_options.h> +#include <vcl/dllapi.h> +#include <tools/bigint.hxx> +#include <vcl/toolkit/field.hxx> + +class LocaleDataWrapper; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) LongCurrencyFormatter : public FormatterBase +{ +public: + virtual ~LongCurrencyFormatter() override; + + virtual void Reformat() override; + virtual void ReformatAll() override; + + OUString const & GetCurrencySymbol() const; + + void SetDecimalDigits( sal_uInt16 nDigits ); + sal_uInt16 GetDecimalDigits() const { return mnDecimalDigits;} + void SetValue(const BigInt& rNewValue); + void SetUserValue( BigInt nNewValue ); + BigInt GetValue() const; + +protected: + BigInt mnLastValue; + BigInt mnMin; + BigInt mnMax; + + LongCurrencyFormatter(Edit* pEdit); +private: + friend bool ImplLongCurrencyReformat( const OUString&, BigInt const &, BigInt const &, sal_uInt16, const LocaleDataWrapper&, OUString&, LongCurrencyFormatter const & ); + SAL_DLLPRIVATE void ImpInit(); + + sal_uInt16 mnDecimalDigits; + +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) LongCurrencyBox final : public ComboBox, public LongCurrencyFormatter +{ +public: + LongCurrencyBox( vcl::Window* pParent, WinBits nWinStyle ); + + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + + void Modify() override; + void ReformatAll() override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/lstbox.hxx b/include/vcl/toolkit/lstbox.hxx new file mode 100644 index 000000000..e3bcc1297 --- /dev/null +++ b/include/vcl/toolkit/lstbox.hxx @@ -0,0 +1,266 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <config_options.h> +#include <sal/types.h> +#include <o3tl/typed_flags_set.hxx> +#include <vcl/dllapi.h> +#include <vcl/ctrl.hxx> + +class DataChangedEvent; +class NotifyEvent; +class UserDrawEvent; + +#define LISTBOX_APPEND (SAL_MAX_INT32) +#define LISTBOX_ENTRY_NOTFOUND (SAL_MAX_INT32) +#define LISTBOX_MAX_ENTRIES (SAL_MAX_INT32 - 1) + +// the following defines can be used for the SetEntryFlags() +// and GetEntryFlags() methods + +// !! Do not use these flags for user data as they are reserved !! +// !! to change the internal behaviour of the ListBox implementation !! +// !! for specific entries. !! + +enum class ListBoxEntryFlags +{ + NONE = 0x0000, +/** this flag disables a selection of an entry completely. It is not + possible to select such entries either from the user interface + nor from the ListBox methods. Cursor traveling is handled correctly. + This flag can be used to add titles to a ListBox. +*/ + DisableSelection = 0x0001, + +/** this flag can be used to make an entry multiline capable + A normal entry is single line and will therefore be clipped + at the right listbox border. Setting this flag enables + word breaks for the entry text. +*/ + MultiLine = 0x0002, + +/** this flags lets the item be drawn disabled (e.g. in grey text) + usage only guaranteed with ListBoxEntryFlags::DisableSelection +*/ + DrawDisabled = 0x0004, +}; +namespace o3tl +{ + template<> struct typed_flags<ListBoxEntryFlags> : is_typed_flags<ListBoxEntryFlags, 0x0007> {}; +} + +class Image; +class ImplListBox; +class ImplListBoxFloatingWindow; +class ImplBtn; +class ImplWin; +class ImplListBoxWindow; + +/// A widget used to choose from a list of items and which has no entry. +class VCL_DLLPUBLIC ListBox : public Control +{ +private: + VclPtr<ImplListBox> mpImplLB; + VclPtr<ImplListBoxFloatingWindow> mpFloatWin; + VclPtr<ImplWin> mpImplWin; + VclPtr<ImplBtn> mpBtn; + sal_uInt16 mnDDHeight; + sal_Int32 m_nMaxWidthChars; + Link<ListBox&,void> maSelectHdl; + sal_uInt16 mnLineCount; + + bool mbDDAutoSize : 1; + +private: + SAL_DLLPRIVATE void ImplInitListBoxData(); + + DECL_DLLPRIVATE_LINK( ImplSelectHdl, LinkParamNone*, void ); + DECL_DLLPRIVATE_LINK( ImplScrollHdl, ImplListBox*, void ); + DECL_DLLPRIVATE_LINK( ImplCancelHdl, LinkParamNone*, void ); + DECL_DLLPRIVATE_LINK( ImplDoubleClickHdl, ImplListBoxWindow*, void ); + DECL_DLLPRIVATE_LINK( ImplPopupModeEndHdl, FloatingWindow*, void ); + DECL_DLLPRIVATE_LINK( ImplSelectionChangedHdl, sal_Int32, void ); + DECL_DLLPRIVATE_LINK( ImplFocusHdl, sal_Int32, void ); + DECL_DLLPRIVATE_LINK( ImplListItemSelectHdl, LinkParamNone*, void ); + + DECL_DLLPRIVATE_LINK( ImplClickBtnHdl, void*, void ); + +protected: + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + SAL_DLLPRIVATE static WinBits ImplInitStyle( WinBits nStyle ); + bool IsDropDownBox() const { return mpFloatWin != nullptr; } + +protected: + explicit ListBox( WindowType nType ); + + virtual void FillLayoutData() const override; + +public: + explicit ListBox( vcl::Window* pParent, WinBits nStyle = WB_BORDER ); + virtual ~ListBox() override; + virtual void dispose() override; + + virtual void ApplySettings(vcl::RenderContext& rRenderContext) override; + virtual void Draw( OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags ) override; + virtual void Resize() override; + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + void Select(); + void DoubleClick(); + virtual void GetFocus() override; + virtual void LoseFocus() override; + + virtual const Wallpaper& GetDisplayBackground() const override; + + virtual void setPosSizePixel( tools::Long nX, tools::Long nY, + tools::Long nWidth, tools::Long nHeight, PosSizeFlags nFlags = PosSizeFlags::All ) override; + + tools::Rectangle GetDropDownPosSizePixel() const; + + void AdaptDropDownLineCountToMaximum(); + void SetDropDownLineCount( sal_uInt16 nLines ); + sal_uInt16 GetDropDownLineCount() const; + + void EnableAutoSize( bool bAuto ); + bool IsAutoSizeEnabled() const { return mbDDAutoSize; } + + sal_Int32 InsertEntry( const OUString& rStr, sal_Int32 nPos = LISTBOX_APPEND ); + sal_Int32 InsertEntry( const OUString& rStr, const Image& rImage, sal_Int32 nPos = LISTBOX_APPEND ); + void RemoveEntry( sal_Int32 nPos ); + + void Clear(); + + sal_Int32 GetEntryPos( std::u16string_view rStr ) const; + Image GetEntryImage( sal_Int32 nPos ) const; + OUString GetEntry( sal_Int32 nPos ) const; + sal_Int32 GetEntryCount() const; + + void SelectEntry( std::u16string_view rStr, bool bSelect = true ); + void SelectEntryPos( sal_Int32 nPos, bool bSelect = true ); + void SelectEntriesPos( const std::vector<sal_Int32>& rPositions, bool bSelect = true ); + + sal_Int32 GetSelectedEntryCount() const; + OUString GetSelectedEntry( sal_Int32 nSelIndex = 0 ) const; + sal_Int32 GetSelectedEntryPos( sal_Int32 nSelIndex = 0 ) const; + + bool IsEntryPosSelected( sal_Int32 nPos ) const; + void SetNoSelection(); + + void SetEntryData( sal_Int32 nPos, void* pNewData ); + void* GetEntryData( sal_Int32 nPos ) const; + + /** this methods stores a combination of flags from the + ListBoxEntryFlags::* defines at the given entry. + See description of the possible ListBoxEntryFlags::* flags + for details. + Do not use these flags for user data as they are reserved + to change the internal behaviour of the ListBox implementation + for specific entries. + */ + void SetEntryFlags( sal_Int32 nPos, ListBoxEntryFlags nFlags ); + + void SetTopEntry( sal_Int32 nPos ); + sal_Int32 GetTopEntry() const; + + /** + * Removes existing separators, and sets the position of the + * one and only separator. + */ + void SetSeparatorPos( sal_Int32 n ); + /** + * Gets the position of the separator which was added first. + * Returns LISTBOX_ENTRY_NOTFOUND if there is no separator. + */ + sal_Int32 GetSeparatorPos() const; + + /** + * Adds a new separator at the given position n. + */ + void AddSeparator( sal_Int32 n ); + + bool IsTravelSelect() const; + bool IsInDropDown() const; + void ToggleDropDown(); + + void EnableMultiSelection( bool bMulti ); + bool IsMultiSelectionEnabled() const; + + void SetReadOnly( bool bReadOnly = true ); + bool IsReadOnly() const; + + tools::Rectangle GetBoundingRectangle( sal_Int32 nItem ) const; + + void SetSelectHdl( const Link<ListBox&,void>& rLink ) { maSelectHdl = rLink; } + + Size CalcSubEditSize() const; //size of area inside lstbox, i.e. no scrollbar/dropdown + Size CalcMinimumSize() const; //size of lstbox area, i.e. including scrollbar/dropdown + virtual Size GetOptimalSize() const override; + Size CalcAdjustedSize( const Size& rPrefSize ) const; + Size CalcBlockSize( sal_uInt16 nColumns, sal_uInt16 nLines ) const; + void GetMaxVisColumnsAndLines( sal_uInt16& rnCols, sal_uInt16& rnLines ) const; + + sal_uInt16 GetDisplayLineCount() const; + + /** checks whether a certain point lies within the bounds of + a listbox item and returns the item as well as the character position + the point is at. + + <p>If the point is inside an item the item pos is put into <code>rPos</code> and + the item-relative character index is returned. If the point is not inside + an item -1 is returned and rPos is unchanged.</p> + + @param rPoint + tells the point for which an item is requested. + + @param rPos + gets the item at the specified point <code>rPoint</code> + + @returns + the item-relative character index at point <code>rPos</code> or -1 + if no item is at that point. + */ + using Control::GetIndexForPoint; + tools::Long GetIndexForPoint( const Point& rPoint, sal_Int32 & rPos ) const; + + void setMaxWidthChars(sal_Int32 nWidth); + + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + + virtual FactoryFunction GetUITestFactory() const override; + + virtual void DumpAsPropertyTree(tools::JsonWriter&) override; +}; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MultiListBox final : public ListBox +{ +public: + explicit MultiListBox( vcl::Window* pParent, WinBits nStyle ); + +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/menubtn.hxx b/include/vcl/toolkit/menubtn.hxx new file mode 100644 index 000000000..ca77a48c9 --- /dev/null +++ b/include/vcl/toolkit/menubtn.hxx @@ -0,0 +1,97 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <config_options.h> +#include <vcl/toolkit/button.hxx> +#include <vcl/dllapi.h> +#include <memory> + +class Timer; +class PopupMenu; + +class VCL_DLLPUBLIC MenuButton : public PushButton +{ +private: + friend class VclBuilder; + + std::unique_ptr<Timer> mpMenuTimer; + VclPtr<PopupMenu> mpMenu; + VclPtr<Window> mpFloatingWindow; + OString msCurItemIdent; + sal_uInt16 mnCurItemId; + bool mbDelayMenu; + bool mbStartingMenu; + Link<MenuButton*,void> maActivateHdl; + Link<MenuButton*,void> maSelectHdl; + + DECL_DLLPRIVATE_LINK( ImplMenuTimeoutHdl, Timer*, void ); + + MenuButton( const MenuButton & ) = delete; + MenuButton& operator=( const MenuButton & ) = delete; + +protected: + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + +public: + explicit MenuButton( vcl::Window* pParent, WinBits nStyle = 0 ); + virtual ~MenuButton() override; + virtual void dispose() override; + + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void KeyInput( const KeyEvent& rKEvt ) override; + + virtual void Activate() override; + void Select(); + + void ExecuteMenu(); + bool InPopupMode() const; + void CancelMenu(); + + //if false then the whole button launches the menu + //if true, then the button has a separator + //where the right portion launches the menu immediately + //where the left portion activates the underlying Button handlers + //before launching the menu in an idle, allowing it to be cancelled + //before being shown + void SetDelayMenu(bool bDelay) { mbDelayMenu = bDelay; } + + void SetPopupMenu(PopupMenu* pNewMenu); + PopupMenu* GetPopupMenu() const { return mpMenu; } + + void SetPopover(Window* pWindow); + Window* GetPopover() { return mpFloatingWindow.get(); } + + OString const & GetCurItemIdent() const { return msCurItemIdent; } + + void SetActivateHdl( const Link<MenuButton *, void>& rLink ) { maActivateHdl = rLink; } + void SetSelectHdl( const Link<MenuButton *, void>& rLink ) { maSelectHdl = rLink; } + + virtual FactoryFunction GetUITestFactory() const override; + + void SetCurItemId(); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/morebtn.hxx b/include/vcl/toolkit/morebtn.hxx new file mode 100644 index 000000000..ca2a4b21d --- /dev/null +++ b/include/vcl/toolkit/morebtn.hxx @@ -0,0 +1,56 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <config_options.h> +#include <vcl/dllapi.h> +#include <vcl/toolkit/button.hxx> +#include <memory> + +struct ImplMoreButtonData; + + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MoreButton final : public PushButton +{ + std::unique_ptr<ImplMoreButtonData> mpMBData; + bool mbState; + + MoreButton( const MoreButton & ) = delete; + MoreButton& operator=( const MoreButton & ) = delete; + SAL_DLLPRIVATE void ShowState(); + + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + +public: + explicit MoreButton( vcl::Window* pParent, WinBits nStyle ); + virtual ~MoreButton() override; + virtual void dispose() override; + + void Click() override; + + using PushButton::SetState; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/prgsbar.hxx b/include/vcl/toolkit/prgsbar.hxx new file mode 100644 index 000000000..dd9423178 --- /dev/null +++ b/include/vcl/toolkit/prgsbar.hxx @@ -0,0 +1,80 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <config_options.h> +#include <vcl/dllapi.h> +#include <vcl/window.hxx> + +/************************************************************************* + * + * class ProgressBar + * + * this class is used to display the ProgressBar + * + * ----------------------------------------------------------------------- + * + * WinBits + * + * WB_BORDER border around the window + * WB_3DLOOK 3D representation + * + * ----------------------------------------------------------------------- + * + * Methods + * + * Use SetValue() to set a percentage between 0 and 100. A value larger + * than 100 will cause the last rectangle to start flashing + * + ************************************************************************/ + + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) ProgressBar final : public vcl::Window +{ +private: + Point maPos; + tools::Long mnPrgsWidth; + tools::Long mnPrgsHeight; + sal_uInt16 mnPercent; + sal_uInt16 mnPercentCount; + bool mbCalcNew; + + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit(); + SAL_DLLPRIVATE void ImplInitSettings( bool bFont, bool bForeground, bool bBackground ); + SAL_DLLPRIVATE void ImplDrawProgress(vcl::RenderContext& rRenderContext, sal_uInt16 nNewPerc); + +public: + ProgressBar( vcl::Window* pParent, WinBits nWinBits ); + + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Resize() override; + virtual void StateChanged( StateChangedType nStateChange ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + virtual Size GetOptimalSize() const override; + + void SetValue( sal_uInt16 nNewPercent ); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/roadmap.hxx b/include/vcl/toolkit/roadmap.hxx new file mode 100644 index 000000000..ef1cec250 --- /dev/null +++ b/include/vcl/toolkit/roadmap.hxx @@ -0,0 +1,116 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <config_options.h> +#include <vcl/dllapi.h> +#include <vcl/ctrl.hxx> +#include <vcl/toolkit/imgctrl.hxx> +#include <memory> + +class Bitmap; + +namespace vcl +{ + +struct RoadmapTypes +{ +public: + typedef sal_Int16 ItemId; + typedef sal_Int32 ItemIndex; +}; + +class HyperLabel; +class RoadmapImpl; +class RoadmapItem; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) ORoadmap final : public Control, public RoadmapTypes +{ +public: + ORoadmap( vcl::Window* _pParent, WinBits _nWinStyle ); + virtual ~ORoadmap( ) override; + virtual void dispose() override; + + void SetRoadmapBitmap( const BitmapEx& maBitmap ); + + void EnableRoadmapItem( ItemId _nItemId, bool _bEnable ); + + void ChangeRoadmapItemLabel( ItemId _nID, const OUString& sLabel ); + void ChangeRoadmapItemID( ItemId _nID, ItemId NewID ); + + void SetRoadmapInteractive( bool _bInteractive ); + bool IsRoadmapInteractive() const; + + void SetRoadmapComplete( bool _bComplete ); + bool IsRoadmapComplete() const; + + ItemIndex GetItemCount() const; + ItemId GetItemID( ItemIndex _nIndex ) const; + + void InsertRoadmapItem( ItemIndex Index, const OUString& RoadmapItem, ItemId _nUniqueId, bool _bEnabled ); + void ReplaceRoadmapItem( ItemIndex Index, const OUString& RoadmapItem, ItemId _nUniqueId, bool _bEnabled ); + void DeleteRoadmapItem( ItemIndex _nIndex ); + + ItemId GetCurrentRoadmapItemID() const; + bool SelectRoadmapItemByID(ItemId nItemID, bool bGrabFocus = true); + + void SetItemSelectHdl( const Link<LinkParamNone*,void>& _rHdl ); + Link<LinkParamNone*,void> const & GetItemSelectHdl( ) const; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + virtual void GetFocus() override; + virtual void ApplySettings( vcl::RenderContext& rRenderContext ) override; + +private: + bool PreNotify( NotifyEvent& rNEvt ) override; + + /// called when an item has been selected by any means + void Select(); + + DECL_DLLPRIVATE_LINK(ImplClickHdl, HyperLabel*, void); + + RoadmapItem* GetByIndex( ItemIndex _nItemIndex ); + const RoadmapItem* GetByIndex( ItemIndex _nItemIndex ) const; + + RoadmapItem* GetByID( ItemId _nID ); + const RoadmapItem* GetByID( ItemId _nID ) const; + RoadmapItem* GetPreviousHyperLabel( ItemIndex Index); + + void DrawHeadline(vcl::RenderContext& rRenderContext); + void DeselectOldRoadmapItems(); + ItemId GetNextAvailableItemId( ItemIndex NewIndex ); + ItemId GetPreviousAvailableItemId( ItemIndex NewIndex ); + RoadmapItem* GetByPointer(vcl::Window const * pWindow); + RoadmapItem* InsertHyperLabel( ItemIndex Index, const OUString& _aStr, ItemId RMID, bool _bEnabled, bool _bIncomplete ); + void UpdatefollowingHyperLabels( ItemIndex Index ); + + // Window overridables + void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& _rRect) override; + void implInit(vcl::RenderContext& rRenderContext); + + std::unique_ptr<RoadmapImpl> m_pImpl; +}; + +} // namespace vcl + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/spin.hxx b/include/vcl/toolkit/spin.hxx new file mode 100644 index 000000000..bc1e14109 --- /dev/null +++ b/include/vcl/toolkit/spin.hxx @@ -0,0 +1,98 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <config_options.h> +#include <vcl/dllapi.h> +#include <vcl/ctrl.hxx> +#include <vcl/timer.hxx> + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) SpinButton final : public Control +{ +private: + AutoTimer maRepeatTimer; + tools::Rectangle maUpperRect; + tools::Rectangle maLowerRect; + tools::Rectangle maFocusRect; + bool mbRepeat : 1; + bool mbUpperIn : 1; + bool mbLowerIn : 1; + bool mbInitialUp : 1; + bool mbInitialDown : 1; + bool mbHorz : 1; + bool mbUpperIsFocused : 1; + tools::Long mnMinRange; + tools::Long mnMaxRange; + tools::Long mnValue; + tools::Long mnValueStep; + + SAL_DLLPRIVATE tools::Rectangle* ImplFindPartRect( const Point& rPt ); + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + DECL_DLLPRIVATE_LINK( ImplTimeout, Timer*, void ); + +public: + explicit SpinButton( vcl::Window* pParent, WinBits nStyle ); + + void Up(); + void Down(); + + virtual void Resize() override; + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Draw( OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags ) override; + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void MouseButtonUp( const MouseEvent& rMEvt ) override; + virtual void MouseMove( const MouseEvent& rMEvt ) override; + virtual void KeyInput( const KeyEvent& rKEvt ) override; + virtual void StateChanged( StateChangedType nStateChange ) override; + virtual void GetFocus() override; + virtual void LoseFocus() override; + + void SetRangeMin( tools::Long nNewRange ); + tools::Long GetRangeMin() const { return mnMinRange; } + void SetRangeMax( tools::Long nNewRange ); + tools::Long GetRangeMax() const { return mnMaxRange; } + void SetRange( const Range& rRange ); + void SetValue( tools::Long nValue ); + tools::Long GetValue() const { return mnValue; } + void SetValueStep( tools::Long nNewStep ) { mnValueStep = nNewStep; } + tools::Long GetValueStep() const { return mnValueStep; } + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + +private: + // moves the focus to the upper or lower rect. Return sal_True if the focus rect actually changed. + SAL_DLLPRIVATE bool ImplMoveFocus( bool _bUpper ); + SAL_DLLPRIVATE void ImplCalcFocusRect( bool _bUpper ); + + SAL_DLLPRIVATE bool ImplIsUpperEnabled( ) const + { + return mnValue + mnValueStep <= mnMaxRange; + } + SAL_DLLPRIVATE bool ImplIsLowerEnabled( ) const + { + return mnValue >= mnMinRange + mnValueStep; + } +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/spinfld.hxx b/include/vcl/toolkit/spinfld.hxx new file mode 100644 index 000000000..d82348bd4 --- /dev/null +++ b/include/vcl/toolkit/spinfld.hxx @@ -0,0 +1,104 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <vcl/dllapi.h> +#include <vcl/toolkit/edit.hxx> +#include <vcl/timer.hxx> + +class VCL_DLLPUBLIC SpinField : public Edit +{ +public: + explicit SpinField( vcl::Window* pParent, WinBits nWinStyle, WindowType nType = WindowType::SPINFIELD ); + virtual ~SpinField() override; + virtual void dispose() override; + + virtual bool ShowDropDown( bool bShow ); + + virtual void Up(); + virtual void Down(); + virtual void First(); + virtual void Last(); + + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void MouseButtonUp( const MouseEvent& rMEvt ) override; + virtual void MouseMove( const MouseEvent& rMEvt ) override; + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Draw( OutputDevice* pDev, const Point& rPos,SystemTextColorFlags nFlags ) override; + virtual void Resize() override; + virtual void StateChanged( StateChangedType nType ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + + void SetUpHdl( const Link<SpinField&,void>& rLink ) { maUpHdlLink = rLink; } + void SetDownHdl( const Link<SpinField&,void>& rLink ) { maDownHdlLink = rLink; } + + virtual Size CalcMinimumSize() const override; + virtual Size CalcMinimumSizeForText(const OUString &rString) const override; + virtual Size GetOptimalSize() const override; + virtual Size CalcSize(sal_Int32 nChars) const override; + + virtual FactoryFunction GetUITestFactory() const override; + + SAL_DLLPRIVATE void SetUpperEnabled(bool bEnabled); + SAL_DLLPRIVATE void SetLowerEnabled(bool bEnabled); + SAL_DLLPRIVATE bool IsUpperEnabled() const { return mbUpperEnabled; } + SAL_DLLPRIVATE bool IsLowerEnabled() const { return mbLowerEnabled; } + +protected: + tools::Rectangle maUpperRect; + tools::Rectangle maLowerRect; + tools::Rectangle maDropDownRect; // not yet attached ... + + using Window::ImplInit; + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle ); + + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + + void EndDropDown(); + + virtual void FillLayoutData() const override; + tools::Rectangle * ImplFindPartRect( const Point& rPt ); + +private: + DECL_DLLPRIVATE_LINK( ImplTimeout, Timer*, void ); + SAL_DLLPRIVATE void ImplInitSpinFieldData(); + SAL_DLLPRIVATE void ImplCalcButtonAreas( const OutputDevice* pDev, const Size& rOutSz, tools::Rectangle& rDDArea, tools::Rectangle& rSpinUpArea, tools::Rectangle& rSpinDownArea ); + + VclPtr<Edit> mpEdit; + AutoTimer maRepeatTimer; + Link<SpinField&,void> maUpHdlLink; + Link<SpinField&,void> maDownHdlLink; + bool mbRepeat:1, + mbSpin:1, + mbInitialUp:1, + mbInitialDown:1, + mbUpperIn:1, + mbLowerIn:1, + mbInDropDown:1, + mbUpperEnabled:1, + mbLowerEnabled:1; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/svlbitm.hxx b/include/vcl/toolkit/svlbitm.hxx new file mode 100644 index 000000000..f02c4125a --- /dev/null +++ b/include/vcl/toolkit/svlbitm.hxx @@ -0,0 +1,287 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <memory> +#include <vcl/dllapi.h> +#include <tools/link.hxx> +#include <vcl/image.hxx> +#include <vcl/toolkit/treelistbox.hxx> +#include <o3tl/typed_flags_set.hxx> + +class SvTreeListEntry; +class SvLBoxButton; + + +enum class SvBmp +{ + UNCHECKED = 0, + CHECKED = 1, + TRISTATE = 2, + HIUNCHECKED = 3, + HICHECKED = 4, + HITRISTATE = 5 +}; + +enum class SvItemStateFlags +{ + NONE = 0x00, + UNCHECKED = 0x01, + CHECKED = 0x02, + TRISTATE = 0x04, + HILIGHTED = 0x08 +}; +namespace o3tl +{ + template<> struct typed_flags<SvItemStateFlags> : is_typed_flags<SvItemStateFlags, 0x0f> {}; +} + +struct SvLBoxButtonData_Impl; + +class SvLBoxButtonData +{ +private: + Link<SvLBoxButtonData*,void> aLink; + tools::Long nWidth; + tools::Long nHeight; + std::unique_ptr<SvLBoxButtonData_Impl> pImpl; + bool bDataOk; + std::vector<Image> aBmps; // indices s. constants BMP_... + + void SetWidthAndHeight(); + void InitData( bool _bRadioBtn, const Control* pControlForSettings ); +public: + // include creating default images (CheckBox or RadioButton) + SvLBoxButtonData( const Control* pControlForSettings, bool _bRadioBtn ); + + ~SvLBoxButtonData(); + + static SvBmp GetIndex( SvItemStateFlags nItemState ); + tools::Long Width(); + tools::Long Height(); + void SetLink( const Link<SvLBoxButtonData*,void>& rLink) { aLink=rLink; } + bool IsRadio() const; + // as buttons are not derived from LinkHdl + void CallLink(); + + void StoreButtonState(SvTreeListEntry* pActEntry, SvLBoxButton* pActBox); + static SvButtonState ConvertToButtonState( SvItemStateFlags nItemFlags ); + + SvTreeListEntry* GetActEntry() const; + SvLBoxButton* GetActBox() const; + + void SetImage(SvBmp nIndex, const Image& aImage) { aBmps[static_cast<int>(nIndex)] = aImage; } + Image& GetImage(SvBmp nIndex) { return aBmps[static_cast<int>(nIndex)]; } + + void SetDefaultImages( const Control* pControlForSettings ); + // set images according to the color scheme of the Control + // pControlForSettings == NULL: settings are taken from Application + bool HasDefaultImages() const; +}; + +// ********************************************************************** + +class VCL_DLLPUBLIC SvLBoxString : public SvLBoxItem +{ +private: + bool mbEmphasized; + bool mbCustom; + double mfAlign; +protected: + OUString maText; + +public: + SvLBoxString(const OUString& rText); + SvLBoxString(); + virtual ~SvLBoxString() override; + + virtual SvLBoxItemType GetType() const override; + virtual void InitViewData(SvTreeListBox* pView, + SvTreeListEntry* pEntry, + SvViewDataItem* pViewData = nullptr) override; + + virtual int CalcWidth(const SvTreeListBox* pView) const override; + + void Align(double fAlign) { mfAlign = fAlign; } + + void Emphasize(bool bEmphasize) { mbEmphasized = bEmphasize; } + bool IsEmphasized() const { return mbEmphasized; } + + void SetCustomRender() { mbCustom = true; } + + const OUString& GetText() const + { + return maText; + } + void SetText(const OUString& rText) + { + maText = rText; + } + + virtual void Paint(const Point& rPos, SvTreeListBox& rOutDev, + vcl::RenderContext& rRenderContext, + const SvViewDataEntry* pView, + const SvTreeListEntry& rEntry) override; + + virtual std::unique_ptr<SvLBoxItem> Clone(SvLBoxItem const * pSource) const override; +}; + +class SvLBoxButton final : public SvLBoxItem +{ + bool isVis; + SvLBoxButtonData* pData; + SvItemStateFlags nItemFlags; + + static void ImplAdjustBoxSize( Size& io_rCtrlSize, ControlType i_eType, vcl::RenderContext const & pRenderContext); +public: + // An SvLBoxButton can be of two different kinds: an + // enabled checkbox (the normal kind), or a static image + // (see SV_BMP_STATICIMAGE; nFlags are effectively ignored + // for that kind). + SvLBoxButton( SvLBoxButtonData* pBData ); + SvLBoxButton(); + virtual ~SvLBoxButton() override; + virtual void InitViewData(SvTreeListBox* pView, + SvTreeListEntry* pEntry, + SvViewDataItem* pViewData = nullptr) override; + + virtual SvLBoxItemType GetType() const override; + void ClickHdl( SvTreeListEntry* ); + + virtual void Paint(const Point& rPos, + SvTreeListBox& rOutDev, + vcl::RenderContext& rRenderContext, + const SvViewDataEntry* pView, + const SvTreeListEntry& rEntry) override; + + virtual std::unique_ptr<SvLBoxItem> Clone(SvLBoxItem const * pSource) const override; + + SvItemStateFlags GetButtonFlags() const + { + return nItemFlags; + } + bool IsStateChecked() const + { + return bool(nItemFlags & SvItemStateFlags::CHECKED); + } + bool IsStateUnchecked() const + { + return bool(nItemFlags & SvItemStateFlags::UNCHECKED); + } + bool IsStateTristate() const + { + return bool(nItemFlags & SvItemStateFlags::TRISTATE); + } + bool IsStateHilighted() const + { + return bool(nItemFlags & SvItemStateFlags::HILIGHTED); + } + void SetStateChecked(); + void SetStateUnchecked(); + void SetStateTristate(); + void SetStateHilighted(bool bHilight); +}; + +inline void SvLBoxButton::SetStateChecked() +{ + nItemFlags &= SvItemStateFlags::HILIGHTED; + nItemFlags |= SvItemStateFlags::CHECKED; +} + +inline void SvLBoxButton::SetStateUnchecked() +{ + nItemFlags &= SvItemStateFlags::HILIGHTED; + nItemFlags |= SvItemStateFlags::UNCHECKED; +} +inline void SvLBoxButton::SetStateTristate() +{ + nItemFlags &= SvItemStateFlags::HILIGHTED; + nItemFlags |= SvItemStateFlags::TRISTATE; +} +inline void SvLBoxButton::SetStateHilighted( bool bHilight ) +{ + if ( bHilight ) + nItemFlags |= SvItemStateFlags::HILIGHTED; + else + nItemFlags &= ~SvItemStateFlags::HILIGHTED; +} + +struct SvLBoxContextBmp_Impl; + +class VCL_DLLPUBLIC SvLBoxContextBmp : public SvLBoxItem +{ + std::unique_ptr<SvLBoxContextBmp_Impl> m_pImpl; +public: + SvLBoxContextBmp(const Image& aBmp1, + const Image& aBmp2, + bool bExpanded); + SvLBoxContextBmp(); + virtual ~SvLBoxContextBmp() override; + + virtual SvLBoxItemType GetType() const override; + virtual void InitViewData(SvTreeListBox* pView, + SvTreeListEntry* pEntry, + SvViewDataItem* pViewData = nullptr) override; + virtual void Paint(const Point& rPos, + SvTreeListBox& rOutDev, + vcl::RenderContext& rRenderContext, + const SvViewDataEntry* pView, + const SvTreeListEntry& rEntry) override; + + virtual std::unique_ptr<SvLBoxItem> Clone(SvLBoxItem const * pSource) const override; + + void SetModeImages(const Image& rBitmap1, const Image& rBitmap2); + + inline void SetBitmap1(const Image& rImage); + inline void SetBitmap2(const Image& rImage); + inline const Image& GetBitmap1() const; + inline const Image& GetBitmap2() const; + +private: + Image& implGetImageStore(bool bFirst); +}; + +inline void SvLBoxContextBmp::SetBitmap1(const Image& _rImage) +{ + implGetImageStore(true) = _rImage; +} + +inline void SvLBoxContextBmp::SetBitmap2(const Image& _rImage) +{ + implGetImageStore(false) = _rImage; +} + +inline const Image& SvLBoxContextBmp::GetBitmap1() const +{ + Image& rImage = const_cast<SvLBoxContextBmp*>(this)->implGetImageStore(true); + return rImage; +} + +inline const Image& SvLBoxContextBmp::GetBitmap2() const +{ + Image& rImage = const_cast<SvLBoxContextBmp*>(this)->implGetImageStore(false); + return rImage; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/svtabbx.hxx b/include/vcl/toolkit/svtabbx.hxx new file mode 100644 index 000000000..5d54cb1a0 --- /dev/null +++ b/include/vcl/toolkit/svtabbx.hxx @@ -0,0 +1,208 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <vcl/dllapi.h> +#include <vcl/toolkit/treelistbox.hxx> +#include <vcl/accessibletableprovider.hxx> + +#include <tools/debug.hxx> + +#include <memory> +#include <vector> + +enum class SvTabJustify +{ + AdjustRight = static_cast<int>(SvLBoxTabFlags::ADJUST_RIGHT), + AdjustLeft = static_cast<int>(SvLBoxTabFlags::ADJUST_LEFT), + AdjustCenter = static_cast<int>(SvLBoxTabFlags::ADJUST_CENTER) +}; + +class VCL_DLLPUBLIC SvTabListBox : public SvTreeListBox +{ +private: + std::vector<SvLBoxTab> mvTabList; + OUString aCurEntry; + +protected: + static std::u16string_view GetToken( std::u16string_view sStr, sal_Int32 &nIndex ); + + virtual void SetTabs() override; + virtual void InitEntry(SvTreeListEntry*, const OUString&, const Image&, const Image&) override; + + OUString GetTabEntryText( sal_uInt32 nPos, sal_uInt16 nCol ) const; + SvTreeListEntry* GetEntryOnPos( sal_uInt32 _nEntryPos ) const; + SvTreeListEntry* GetChildOnPos( SvTreeListEntry* _pParent, sal_uInt32 _nEntryPos, sal_uInt32& _rPos ) const; + +public: + SvTabListBox( vcl::Window* pParent, WinBits ); + virtual ~SvTabListBox() override; + virtual void dispose() override; + void SetTabs(sal_uInt16 nTabs, tools::Long const pTabPositions[], MapUnit = MapUnit::MapAppFont); + using SvTreeListBox::GetTab; + tools::Long GetLogicTab( sal_uInt16 nTab ); + + virtual SvTreeListEntry* InsertEntry( const OUString& rText, SvTreeListEntry* pParent = nullptr, + bool bChildrenOnDemand = false, + sal_uInt32 nPos=TREELIST_APPEND, void* pUserData = nullptr ) override; + + virtual SvTreeListEntry* InsertEntryToColumn( const OUString&, SvTreeListEntry* pParent, + sal_uInt32 nPos, sal_uInt16 nCol, void* pUserData = nullptr ); + + virtual OUString GetEntryText( SvTreeListEntry* pEntry ) const override; + static OUString GetEntryText( const SvTreeListEntry*, sal_uInt16 nCol ); + OUString GetEntryText( sal_uInt32 nPos, sal_uInt16 nCol = 0xffff ) const; + using SvTreeListBox::SetEntryText; + OUString GetCellText( sal_uInt32 nPos, sal_uInt16 nCol ) const; + sal_uInt32 GetEntryPos( const SvTreeListEntry* pEntry ) const; + + void SetTabJustify( sal_uInt16 nTab, SvTabJustify ); + void SetTabEditable( sal_uInt16 nTab, bool bEditable ); + + virtual void DumpAsPropertyTree(tools::JsonWriter& rJsonWriter) override; +}; + +// class SvHeaderTabListBox --------------------------------------------------- + +class HeaderBar; +namespace vcl { + struct SvHeaderTabListBoxImpl; +} + +class VCL_DLLPUBLIC SvHeaderTabListBox : public SvTabListBox, public vcl::IAccessibleTableProvider +{ +private: + typedef ::std::vector< css::uno::Reference< css::accessibility::XAccessible > > AccessibleChildren; + + bool m_bFirstPaint; + std::unique_ptr<::vcl::SvHeaderTabListBoxImpl> m_pImpl; + ::vcl::IAccessibleTabListBox* m_pAccessible; + AccessibleChildren m_aAccessibleChildren; + + DECL_DLLPRIVATE_LINK( ScrollHdl_Impl, SvTreeListBox*, void ); + DECL_DLLPRIVATE_LINK( CreateAccessibleHdl_Impl, HeaderBar*, void ); + + void RecalculateAccessibleChildren(); + +public: + SvHeaderTabListBox( vcl::Window* pParent, WinBits nBits ); + virtual ~SvHeaderTabListBox() override; + virtual void dispose() override; + + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& ) override; + + void InitHeaderBar(HeaderBar* pHeaderBar); + HeaderBar* GetHeaderBar(); + static bool IsItemChecked( SvTreeListEntry* pEntry, sal_uInt16 nCol ); + + virtual SvTreeListEntry* InsertEntryToColumn( const OUString&, SvTreeListEntry* pParent, + sal_uInt32 nPos, sal_uInt16 nCol, void* pUserData = nullptr ) override; + virtual sal_uInt32 Insert( SvTreeListEntry* pEnt,SvTreeListEntry* pPar,sal_uInt32 nPos=TREELIST_APPEND) override; + virtual sal_uInt32 Insert( SvTreeListEntry* pEntry, sal_uInt32 nRootPos = TREELIST_APPEND ) override; + + // Accessible ------------------------------------------------------------- + + bool IsCellCheckBox( sal_Int32 _nRow, sal_uInt16 _nColumn, TriState& _rState ) const; + + /** @return The count of the rows. */ + virtual sal_Int32 GetRowCount() const override; + /** @return The count of the columns. */ + virtual sal_uInt16 GetColumnCount() const override; + + /** @return The position of the current row. */ + virtual sal_Int32 GetCurrRow() const override; + /** @return The position of the current column. */ + virtual sal_uInt16 GetCurrColumn() const override; + + /** @return The description of a row. + @param _nRow The row which description is in demand. */ + virtual OUString GetRowDescription( sal_Int32 _nRow ) const override; + /** @return The description of a column. + @param _nColumn The column which description is in demand. */ + virtual OUString GetColumnDescription( sal_uInt16 _nColumn ) const override; + + /** @return <TRUE/>, if the object has a row header. */ + virtual bool HasRowHeader() const override; //GetColumnId + /** @return <TRUE/>, if the object can focus a cell. */ + virtual bool GoToCell( sal_Int32 _nRow, sal_uInt16 _nColumn ) override; + + virtual void SetNoSelection() override; + using SvTabListBox::SelectAll; + virtual void SelectAll() override; + virtual void SelectRow( sal_Int32 _nRow, bool _bSelect = true, bool bExpand = true ) override; + virtual void SelectColumn( sal_uInt16 _nColumn, bool _bSelect = true ) override; + virtual sal_Int32 GetSelectedRowCount() const override; + virtual sal_Int32 GetSelectedColumnCount() const override; + /** @return <TRUE/>, if the row is selected. */ + virtual bool IsRowSelected( sal_Int32 _nRow ) const override; + virtual bool IsColumnSelected( sal_Int32 _nColumn ) const override; + virtual void GetAllSelectedRows( css::uno::Sequence< sal_Int32 >& _rRows ) const override; + virtual void GetAllSelectedColumns( css::uno::Sequence< sal_Int32 >& _rColumns ) const override; + + /** @return <TRUE/>, if the cell is visible. */ + virtual bool IsCellVisible( sal_Int32 _nRow, sal_uInt16 _nColumn ) const override; + virtual OUString GetAccessibleCellText( sal_Int32 _nRow, sal_uInt16 _nColumnPos ) const override; + + virtual tools::Rectangle calcHeaderRect( bool _bIsColumnBar, bool _bOnScreen = true ) override; + virtual tools::Rectangle calcTableRect( bool _bOnScreen = true ) override; + virtual tools::Rectangle GetFieldRectPixelAbs( sal_Int32 _nRow, sal_uInt16 _nColumn, bool _bIsHeader, bool _bOnScreen = true ) override; + + virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessibleCell( sal_Int32 _nRow, sal_uInt16 _nColumn ) override; + virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessibleRowHeader( sal_Int32 _nRow ) override; + virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessibleColumnHeader( sal_uInt16 _nColumnPos ) override; + + virtual sal_Int32 GetAccessibleControlCount() const override; + virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessibleControl( sal_Int32 _nIndex ) override; + virtual bool ConvertPointToControlIndex( sal_Int32& _rnIndex, const Point& _rPoint ) override; + + virtual bool ConvertPointToCellAddress( sal_Int32& _rnRow, sal_uInt16& _rnColPos, const Point& _rPoint ) override; + virtual bool ConvertPointToRowHeader( sal_Int32& _rnRow, const Point& _rPoint ) override; + virtual bool ConvertPointToColumnHeader( sal_uInt16& _rnColPos, const Point& _rPoint ) override; + + virtual OUString GetAccessibleObjectName( AccessibleBrowseBoxObjType _eType, sal_Int32 _nPos = -1 ) const override; + virtual OUString GetAccessibleObjectDescription( AccessibleBrowseBoxObjType _eType, sal_Int32 _nPos = -1 ) const override; + virtual vcl::Window* GetWindowInstance() override; + + virtual void FillAccessibleStateSet( ::utl::AccessibleStateSetHelper& _rStateSet, AccessibleBrowseBoxObjType _eType ) const override; + virtual void FillAccessibleStateSetForCell( ::utl::AccessibleStateSetHelper& _rStateSet, sal_Int32 _nRow, sal_uInt16 _nColumn ) const override; + virtual void GrabTableFocus() override; + + // OutputDevice + virtual bool GetGlyphBoundRects( const Point& rOrigin, const OUString& rStr, int nIndex, int nLen, std::vector< tools::Rectangle >& rVector ) override; + + // Window + virtual tools::Rectangle GetWindowExtentsRelative(const vcl::Window *pRelativeWindow) const override; + virtual void GrabFocus() override; + virtual css::uno::Reference< css::accessibility::XAccessible > GetAccessible() override; + /** Creates and returns the accessible object of the whole BrowseBox. */ + virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessible() override; + virtual vcl::Window* GetAccessibleParentWindow() const override; + + virtual tools::Rectangle GetFieldCharacterBounds(sal_Int32 _nRow,sal_Int32 _nColumnPos,sal_Int32 nIndex) override; + virtual sal_Int32 GetFieldIndexAtPoint(sal_Int32 _nRow,sal_Int32 _nColumnPos,const Point& _rPoint) override; + + virtual void DumpAsPropertyTree(tools::JsonWriter& rJsonWriter) override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/tabdlg.hxx b/include/vcl/toolkit/tabdlg.hxx new file mode 100644 index 000000000..48fab3174 --- /dev/null +++ b/include/vcl/toolkit/tabdlg.hxx @@ -0,0 +1,49 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <config_options.h> +#include <vcl/dllapi.h> +#include <vcl/toolkit/dialog.hxx> + +class FixedLine; + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) TabDialog final : public Dialog +{ +private: + VclPtr<FixedLine> mpFixedLine; + bool mbPosControls; + + SAL_DLLPRIVATE void ImplInitTabDialogData(); + SAL_DLLPRIVATE void ImplPosControls(); + +public: + TabDialog( vcl::Window* pParent, WinBits nStyle ); + virtual ~TabDialog() override; + virtual void dispose() override; + + virtual void StateChanged( StateChangedType nStateChange ) override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/throbber.hxx b/include/vcl/toolkit/throbber.hxx new file mode 100644 index 000000000..ff1240074 --- /dev/null +++ b/include/vcl/toolkit/throbber.hxx @@ -0,0 +1,85 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <config_options.h> +#include <vcl/dllapi.h> +#include <vcl/toolkit/imgctrl.hxx> +#include <vcl/timer.hxx> + +#include <vector> + +class UNLESS_MERGELIBS(VCL_DLLPUBLIC) Throbber final : public ImageControl +{ +public: + enum class ImageSet + { + /// default images, 16x16 pixels + N16px, + /// default images, 32x32 pixels + N32px, + /// default images, 64x64 pixels + N64px, + }; + +public: + Throbber(vcl::Window* i_parentWindow, WinBits i_style); + virtual ~Throbber() override; + virtual void dispose() override; + + // Properties + void setStepTime( sal_Int32 nStepTime ) { mnStepTime = nStepTime; } + sal_Int32 getStepTime() const { return mnStepTime; } + + void setRepeat( bool bRepeat ) { mbRepeat = bRepeat; } + bool getRepeat() const { return mbRepeat; } + + // animation control + void start(); + void stop(); + bool isRunning() const; + + void setImageList( ::std::vector< Image > && i_images ); + + // default images + static ::std::vector< OUString > + getDefaultImageURLs( const ImageSet i_imageSet ); + +private: + // Window overridables + virtual void Resize() override; + + SAL_DLLPRIVATE void initImages(); + + ::std::vector< Image > maImageList; + + bool mbRepeat; + sal_Int32 mnStepTime; + sal_Int32 mnCurStep; + AutoTimer maWaitTimer; + + DECL_DLLPRIVATE_LINK( TimeOutHdl, Timer*, void ); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/treelist.hxx b/include/vcl/toolkit/treelist.hxx new file mode 100644 index 000000000..d4c6da101 --- /dev/null +++ b/include/vcl/toolkit/treelist.hxx @@ -0,0 +1,296 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <vcl/dllapi.h> +#include <vcl/toolkit/treelistentries.hxx> + +#include <tools/link.hxx> +#include <tools/contnr.hxx> + +#include <memory> + +enum class SvListAction +{ + INSERTED = 1, + REMOVING = 2, + REMOVED = 3, + MOVING = 4, + MOVED = 5, + CLEARING = 6, + INSERTED_TREE = 7, + INVALIDATE_ENTRY = 8, + RESORTING = 9, + RESORTED = 10, + CLEARED = 11 +}; + +class SvTreeListEntry; +class SvListView; +class SvViewDataEntry; + +enum class SvSortMode { Ascending, Descending, None }; + +// For the return values of Sortlink: +// See International::Compare( pLeft, pRight ) +// ( Compare(a,b) ==> b.Compare(a) ==> strcmp(a,b) ) +struct SvSortData +{ + const SvTreeListEntry* pLeft; + const SvTreeListEntry* pRight; +}; + +class VCL_DLLPUBLIC SvTreeList final +{ + friend class SvListView; + + SvListView& mrOwnerListView; + sal_uInt32 nEntryCount; + + Link<SvTreeListEntry*, SvTreeListEntry*> aCloneLink; + Link<const SvSortData&, sal_Int32> aCompareLink; + SvSortMode eSortMode; + + bool bAbsPositionsValid; + + bool mbEnableInvalidate; + + SvTreeListEntry* FirstVisible() const { return First(); } + SvTreeListEntry* NextVisible( const SvListView*,SvTreeListEntry* pEntry, sal_uInt16* pDepth=nullptr ) const; + SvTreeListEntry* PrevVisible( const SvListView*,SvTreeListEntry* pEntry ) const; + SvTreeListEntry* LastVisible( const SvListView* ) const; + SvTreeListEntry* NextVisible( const SvListView*,SvTreeListEntry* pEntry, sal_uInt16& rDelta ) const; + SvTreeListEntry* PrevVisible( const SvListView*,SvTreeListEntry* pEntry, sal_uInt16& rDelta ) const; + + bool IsEntryVisible( const SvListView*,SvTreeListEntry* pEntry ) const; + SvTreeListEntry* GetEntryAtVisPos( const SvListView*, sal_uInt32 nVisPos ) const; + sal_uInt32 GetVisiblePos( const SvListView*,SvTreeListEntry const * pEntry ) const; + sal_uInt32 GetVisibleCount( SvListView* ) const; + sal_uInt32 GetVisibleChildCount( const SvListView*,SvTreeListEntry* pParent ) const; + + SvTreeListEntry* FirstSelected( const SvListView*) const; + SvTreeListEntry* NextSelected( const SvListView*,SvTreeListEntry* pEntry ) const; + + sal_uInt32 GetChildSelectionCount( const SvListView*,SvTreeListEntry* pParent ) const; + + VCL_DLLPRIVATE void SetAbsolutePositions(); + + VCL_DLLPRIVATE void CloneChildren( + SvTreeListEntries& rDst, sal_uInt32& rCloneCount, SvTreeListEntries& rSrc, SvTreeListEntry& rNewParent) const; + + /** + * Invalidate the cached position data to have them re-generated before + * the next access. + */ + VCL_DLLPRIVATE static void SetListPositions( SvTreeListEntries& rEntries ); + + // rPos is not changed for SortModeNone + VCL_DLLPRIVATE void GetInsertionPos( + SvTreeListEntry const * pEntry, + SvTreeListEntry* pParent, + sal_uInt32& rPos + ); + + VCL_DLLPRIVATE void ResortChildren( SvTreeListEntry* pParent ); + + SvTreeList(const SvTreeList&) = delete; + SvTreeList& operator= (const SvTreeList&) = delete; + + std::unique_ptr<SvTreeListEntry> pRootItem; + +public: + + SvTreeList() = delete; + SvTreeList(SvListView&); + ~SvTreeList(); + + void Broadcast( + SvListAction nActionId, + SvTreeListEntry* pEntry1=nullptr, + SvTreeListEntry* pEntry2=nullptr, + sal_uInt32 nPos=0 + ); + + void EnableInvalidate( bool bEnable ); + bool IsEnableInvalidate() const { return mbEnableInvalidate; } + + // Notify all Listeners + void InvalidateEntry( SvTreeListEntry* ); + + sal_uInt32 GetEntryCount() const { return nEntryCount; } + SvTreeListEntry* First() const; + SvTreeListEntry* Next( SvTreeListEntry* pEntry, sal_uInt16* pDepth=nullptr ) const; + SvTreeListEntry* Prev( SvTreeListEntry* pEntry ) const; + SvTreeListEntry* Last() const; + + SvTreeListEntry* FirstChild( SvTreeListEntry* pParent ) const; + + sal_uInt32 Insert( SvTreeListEntry* pEntry,SvTreeListEntry* pPar,sal_uInt32 nPos = TREELIST_APPEND); + sal_uInt32 Insert( SvTreeListEntry* pEntry,sal_uInt32 nRootPos = TREELIST_APPEND ) + { return Insert(pEntry, pRootItem.get(), nRootPos ); } + + void InsertTree( SvTreeListEntry* pTree, SvTreeListEntry* pTargetParent, sal_uInt32 nListPos ); + + // Entries need to be in the same Model! + void Move( SvTreeListEntry* pSource, SvTreeListEntry* pTarget ); + + // Creates ChildList if needed + sal_uInt32 Move( SvTreeListEntry* pSource, SvTreeListEntry* pTargetParent, sal_uInt32 nListPos); + sal_uInt32 Copy( SvTreeListEntry* pSource, SvTreeListEntry* pTargetParent, sal_uInt32 nListPos); + + bool Remove( const SvTreeListEntry* pEntry ); + void Clear(); + + bool IsChild(const SvTreeListEntry* pParent, const SvTreeListEntry* pChild) const; + SvTreeListEntry* GetEntry( SvTreeListEntry* pParent, sal_uInt32 nPos ) const; + SvTreeListEntry* GetEntry( sal_uInt32 nRootPos ) const; + SvTreeListEntry* GetEntryAtAbsPos( sal_uInt32 nAbsPos ) const; + + const SvTreeListEntry* GetParent( const SvTreeListEntry* pEntry ) const; + SvTreeListEntry* GetParent( SvTreeListEntry* pEntry ); + + SvTreeListEntry* GetRootLevelParent( SvTreeListEntry* pEntry ) const; + const SvTreeListEntries& GetChildList( SvTreeListEntry* pParent ) const; + SvTreeListEntries& GetChildList( SvTreeListEntry* pParent ); + + sal_uInt32 GetAbsPos( const SvTreeListEntry* pEntry ) const; + static sal_uInt32 GetRelPos( const SvTreeListEntry* pChild ); + + sal_uInt32 GetChildCount( const SvTreeListEntry* pParent ) const; + sal_uInt16 GetDepth( const SvTreeListEntry* pEntry ) const; + bool IsAtRootDepth( const SvTreeListEntry* pEntry ) const; + + // The Model calls the Clone Link to clone Entries. + // Thus we do not need to derive from the Model if we derive from SvTreeListEntry. + // The Handler needs to return a SvTreeListEntry* + SvTreeListEntry* Clone( SvTreeListEntry* pEntry, sal_uInt32& nCloneCount ) const; + void SetCloneLink( const Link<SvTreeListEntry*,SvTreeListEntry*>& rLink ) + { aCloneLink=rLink; } + + const Link<SvTreeListEntry*,SvTreeListEntry*>& GetCloneLink() const + { return aCloneLink; } + + SvTreeListEntry* CloneEntry( SvTreeListEntry* pSource ) const; // Calls the Clone Link + + void SetSortMode( SvSortMode eMode ) { eSortMode = eMode; } + SvSortMode GetSortMode() const { return eSortMode; } + sal_Int32 Compare(const SvTreeListEntry* pLeft, const SvTreeListEntry* pRight) const; + void SetCompareHdl( const Link<const SvSortData&, sal_Int32>& rLink ) { aCompareLink = rLink; } + void Resort(); +}; + +class VCL_DLLPUBLIC SvListView +{ + friend class SvTreeList; + + struct SAL_DLLPRIVATE Impl; + std::unique_ptr<Impl> m_pImpl; + +protected: + std::unique_ptr<SvTreeList> pModel; + + void ExpandListEntry( SvTreeListEntry* pParent ); + void CollapseListEntry( SvTreeListEntry* pParent ); + bool SelectListEntry( SvTreeListEntry* pEntry, bool bSelect ); + +public: + SvListView(); // Sets the Model to 0 + void dispose(); + virtual ~SvListView(); + void Clear(); + virtual void ModelNotification( + SvListAction nActionId, + SvTreeListEntry* pEntry1, + SvTreeListEntry* pEntry2, + sal_uInt32 nPos + ); + + sal_uInt32 GetVisibleCount() const + { return pModel->GetVisibleCount( const_cast<SvListView*>(this) ); } + + SvTreeListEntry* FirstVisible() const + { return pModel->FirstVisible(); } + + SvTreeListEntry* NextVisible( SvTreeListEntry* pEntry ) const + { return pModel->NextVisible(this,pEntry); } + + SvTreeListEntry* PrevVisible( SvTreeListEntry* pEntry ) const + { return pModel->PrevVisible(this,pEntry); } + + SvTreeListEntry* LastVisible() const + { return pModel->LastVisible(this); } + + SvTreeListEntry* NextVisible( SvTreeListEntry* pEntry, sal_uInt16& rDelta ) const + { return pModel->NextVisible(this,pEntry,rDelta); } + + SvTreeListEntry* PrevVisible( SvTreeListEntry* pEntry, sal_uInt16& rDelta ) const + { return pModel->PrevVisible(this,pEntry,rDelta); } + + sal_uInt32 GetSelectionCount() const; + + SvTreeListEntry* FirstSelected() const + { return pModel->FirstSelected(this); } + + SvTreeListEntry* NextSelected( SvTreeListEntry* pEntry ) const + { return pModel->NextSelected(this,pEntry); } + + SvTreeListEntry* GetEntryAtAbsPos( sal_uInt32 nAbsPos ) const + { return pModel->GetEntryAtAbsPos(nAbsPos); } + + SvTreeListEntry* GetEntryAtVisPos( sal_uInt32 nVisPos ) const + { return pModel->GetEntryAtVisPos(this,nVisPos); } + + sal_uInt32 GetAbsPos( SvTreeListEntry const * pEntry ) const + { return pModel->GetAbsPos(pEntry); } + + sal_uInt32 GetVisiblePos( SvTreeListEntry const * pEntry ) const + { return pModel->GetVisiblePos(this,pEntry); } + + sal_uInt32 GetVisibleChildCount(SvTreeListEntry* pParent ) const + { return pModel->GetVisibleChildCount(this,pParent); } + + bool IsEntryVisible( SvTreeListEntry* pEntry ) const + { return pModel->IsEntryVisible(this,pEntry); } + + bool IsExpanded( SvTreeListEntry* pEntry ) const; + bool IsAllExpanded( SvTreeListEntry* pEntry) const; + bool IsSelected(const SvTreeListEntry* pEntry) const; + void SetEntryFocus( SvTreeListEntry* pEntry, bool bFocus ); + const SvViewDataEntry* GetViewData( const SvTreeListEntry* pEntry ) const; + SvViewDataEntry* GetViewData( SvTreeListEntry* pEntry ); + bool HasViewData() const; + + virtual void InitViewData( SvViewDataEntry*, SvTreeListEntry* pEntry ); + + virtual void ModelHasCleared(); + virtual void ModelHasInserted( SvTreeListEntry* pEntry ); + virtual void ModelHasInsertedTree( SvTreeListEntry* pEntry ); + virtual void ModelIsMoving( SvTreeListEntry* pSource ); + virtual void ModelHasMoved( SvTreeListEntry* pSource ); + virtual void ModelIsRemoving( SvTreeListEntry* pEntry ); + virtual void ModelHasRemoved( SvTreeListEntry* pEntry ); + virtual void ModelHasEntryInvalidated( SvTreeListEntry* pEntry ); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/treelistbox.hxx b/include/vcl/toolkit/treelistbox.hxx new file mode 100644 index 000000000..9ae148a94 --- /dev/null +++ b/include/vcl/toolkit/treelistbox.hxx @@ -0,0 +1,690 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <vcl/dllapi.h> + +#include <deque> +#include <memory> +#include <vector> + +#include <vcl/ctrl.hxx> +#include <vcl/quickselectionengine.hxx> +#include <vcl/image.hxx> +#include <tools/gen.hxx> +#include <tools/contnr.hxx> +#include <vcl/toolkit/treelist.hxx> +#include <vcl/transfer.hxx> +#include <o3tl/typed_flags_set.hxx> + +class SvTreeListBox; +class SvTreeListEntry; +struct SvViewDataItem; +class SvViewDataEntry; +class SvInplaceEdit2; +class SvLBoxString; +class SvImpLBox; +class SvLBoxButtonData; +class Timer; +class Edit; + +namespace utl { + class AccessibleStateSetHelper; +} + +enum class SvButtonState { Unchecked, Checked, Tristate }; + +// ********************************************************************* +// *************************** Tabulators ****************************** +// ********************************************************************* + +enum class SvLBoxTabFlags +{ + NONE = 0x0000, + DYNAMIC = 0x0001, // Item's output column changes according to the Child Depth + ADJUST_RIGHT = 0x0002, // Item's right margin at the tabulator + ADJUST_LEFT = 0x0004, // Left margin + ADJUST_CENTER = 0x0008, // Center the item at the tabulator + + SHOW_SELECTION = 0x0010, // Visualize selection state + // Item needs to be able to return the surrounding polygon (D'n'D cursor) + EDITABLE = 0x0020, // Item editable at the tabulator + FORCE = 0x0040, // Switch off the default calculation of the first tabulator + // (on which Abo Tabpage/Extras/Option/Customize, etc. rely on) + // The first tab's position corresponds precisely to the Flags set + // and column widths +}; +namespace o3tl +{ + template<> struct typed_flags<SvLBoxTabFlags> : is_typed_flags<SvLBoxTabFlags, 0x007f> {}; +} + +#define SV_TAB_BORDER 8 + +#define SV_ENTRYHEIGHTOFFS_PIXEL 2 + +enum class SvTreeFlags +{ + CHKBTN = 0x01, + USESEL = 0x02, + MANINS = 0x04, + RECALCTABS = 0x08, + FIXEDHEIGHT = 0x10, +}; +namespace o3tl +{ + template<> struct typed_flags<SvTreeFlags> : is_typed_flags<SvTreeFlags, 0x1f> {}; +} + +enum class SvLBoxItemType {String, Button, ContextBmp}; + +class SvLBoxTab +{ + tools::Long nPos; +public: + SvLBoxTab(); + SvLBoxTab( tools::Long nPos, SvLBoxTabFlags nFlags ); + SvLBoxTab( const SvLBoxTab& ); + + SvLBoxTabFlags nFlags; + + bool IsDynamic() const { return bool(nFlags & SvLBoxTabFlags::DYNAMIC); } + void SetPos( tools::Long nNewPos) { nPos = nNewPos; } + tools::Long GetPos() const { return nPos; } + tools::Long CalcOffset( tools::Long nItemLength, tools::Long nTabWidth ); + bool IsEditable() const { return bool(nFlags & SvLBoxTabFlags::EDITABLE); } +}; + +class VCL_DLLPUBLIC SvLBoxItem +{ +protected: + bool mbDisabled; + +public: + SvLBoxItem(); + virtual ~SvLBoxItem(); + virtual SvLBoxItemType GetType() const = 0; + virtual int CalcWidth(const SvTreeListBox* pView) const; + int GetWidth(const SvTreeListBox* pView, const SvTreeListEntry* pEntry) const; + int GetWidth(const SvTreeListBox* pView, const SvViewDataEntry* pData, sal_uInt16 nItemPos) const; + int GetHeight(const SvTreeListBox* pView, const SvTreeListEntry* pEntry) const; + static int GetHeight(const SvViewDataEntry* pData, sal_uInt16 nItemPos); + void Enable(bool bEnabled) { mbDisabled = !bEnabled; } + + virtual void Paint(const Point& rPos, SvTreeListBox& rOutDev, vcl::RenderContext& rRenderContext, const SvViewDataEntry* pView, const SvTreeListEntry& rEntry) = 0; + + virtual void InitViewData(SvTreeListBox* pView, SvTreeListEntry* pEntry, + // If != 0: this Pointer must be used! + // If == 0: it needs to be retrieved via the View + SvViewDataItem* pViewData = nullptr) = 0; + // View-dependent data is not cloned + virtual std::unique_ptr<SvLBoxItem> Clone(SvLBoxItem const * pSource) const = 0; +}; + +enum class DragDropMode +{ + NONE = 0x0000, + CTRL_MOVE = 0x0001, + APP_COPY = 0x0004, + // Entries may be dropped via the uppermost Entry + // The DropTarget is 0 in that case + ENABLE_TOP = 0x0010, + ALL = 0x0015, +}; +namespace o3tl +{ + template<> struct typed_flags<DragDropMode> : is_typed_flags<DragDropMode, 0x0015> {}; +} + +enum class SvTreeListBoxFlags +{ + NONE = 0x0000, + IN_EDT = 0x0001, + EDT_ENABLED = 0x0002, + TARGEMPH_VIS = 0x0004, + EDTEND_CALLED = 0x0008, +}; +namespace o3tl +{ + template<> struct typed_flags<SvTreeListBoxFlags> : is_typed_flags<SvTreeListBoxFlags, 0x000f> {}; +} + +struct SvTreeListBoxImpl; + +typedef std::pair<vcl::RenderContext&, const SvTreeListEntry&> svtree_measure_args; +typedef std::tuple<vcl::RenderContext&, const tools::Rectangle&, const SvTreeListEntry&> svtree_render_args; + +class VCL_DLLPUBLIC SvTreeListBox + :public Control + ,public SvListView + ,public DropTargetHelper + ,public DragSourceHelper + ,public vcl::ISearchableStringList +{ + friend class SvImpLBox; + friend class SvLBoxString; + friend class IconViewImpl; + friend class TreeControlPeer; + friend class SalInstanceIconView; + friend class SalInstanceTreeView; + friend class SalInstanceEntryTreeView; + + std::unique_ptr<SvTreeListBoxImpl> mpImpl; + Link<SvTreeListBox*,void> aScrolledHdl; + Link<SvTreeListBox*,void> aExpandedHdl; + Link<SvTreeListBox*,bool> aExpandingHdl; + Link<SvTreeListBox*,void> aSelectHdl; + Link<SvTreeListBox*,void> aDeselectHdl; + Link<const CommandEvent&, bool> aPopupMenuHdl; + Link<const HelpEvent&, bool> aTooltipHdl; + Link<svtree_render_args, void> aCustomRenderHdl; + Link<svtree_measure_args, Size> aCustomMeasureHdl; + + Image aPrevInsertedExpBmp; + Image aPrevInsertedColBmp; + Image aCurInsertedExpBmp; + Image aCurInsertedColBmp; + + short nContextBmpWidthMax; + short nEntryHeightOffs; + short nIndent; + short nFocusWidth; + sal_uInt16 nFirstSelTab; + sal_uInt16 nLastSelTab; + tools::Long mnCheckboxItemWidth; + bool mbContextBmpExpanded; + bool mbAlternatingRowColors; + bool mbUpdateAlternatingRows; + bool mbQuickSearch; // Enables type-ahead search in the check list box. + bool mbActivateOnSingleClick; // Make single click "activate" a row like a double-click normally does + bool mbHoverSelection; // Make mouse over a row "select" a row like a single-click normally does + bool mbSelectingByHover; // true during "Select" if it was due to hover + sal_Int8 mnClicksToToggle; // 0 == Click on a row not toggle its checkbox. + // 1 == Every click on row toggle its checkbox. + // 2 == First click select, second click toggle. + + SvTreeListEntry* pHdlEntry; + + DragDropMode nDragDropMode; + DragDropMode nOldDragMode; + SelectionMode eSelMode; + sal_Int32 nMinWidthInChars; + + sal_Int8 mnDragAction; + + SvTreeListEntry* pEdEntry; + SvLBoxItem* pEdItem; + + rtl::Reference<TransferDataContainer> m_xTransferHelper; + +protected: + std::unique_ptr<SvImpLBox> pImpl; + short nColumns; + short nEntryHeight; + short nEntryWidth; + bool mbCenterAndClipText; + + Link<SvTreeListBox*,bool> aDoubleClickHdl; + SvTreeListEntry* pTargetEntry; + SvLBoxButtonData* pCheckButtonData; + std::vector<std::unique_ptr<SvLBoxTab>> aTabs; + SvTreeFlags nTreeFlags; + SvTreeListBoxFlags nImpFlags; + // Move/CopySelection: Position of the current Entry in SelectionList + sal_uInt16 nCurEntrySelPos; + +private: + DECL_DLLPRIVATE_LINK( CheckButtonClick, SvLBoxButtonData *, void ); + DECL_DLLPRIVATE_LINK( TextEditEndedHdl_Impl, SvInplaceEdit2&, void ); + // Handler that is called by TreeList to clone an Entry + DECL_DLLPRIVATE_LINK( CloneHdl_Impl, SvTreeListEntry*, SvTreeListEntry* ); + + // Handler and methods for Drag - finished handler. + // The Handle retrieved by GetDragFinishedHdl can be set on the + // TransferDataContainer. This link is a callback for the DragFinished + // call. The AddBox method is called from the GetDragFinishedHdl() and the + // remove is called in the link callback and in the dtor. So it can't be + // called for a deleted object. + VCL_DLLPRIVATE static void AddBoxToDDList_Impl( const SvTreeListBox& rB ); + VCL_DLLPRIVATE static void RemoveBoxFromDDList_Impl( const SvTreeListBox& rB ); + DECL_DLLPRIVATE_LINK( DragFinishHdl_Impl, sal_Int8, void ); + + // after a checkbox entry is inserted, use this to get its width to support + // autowidth for the 1st checkbox column + VCL_DLLPRIVATE void CheckBoxInserted(SvTreeListEntry* pEntry); + + VCL_DLLPRIVATE void DrawCustomEntry(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect, const SvTreeListEntry& rEntry); + VCL_DLLPRIVATE Size MeasureCustomEntry(vcl::RenderContext& rRenderContext, const SvTreeListEntry& rEntry) const; + + /** Handles the given key event. + + At the moment this merely does typeahead if typeahead is enabled. + + @return + <TRUE/> if the event has been consumed, <FALSE/> otherwise. + */ + VCL_DLLPRIVATE bool HandleKeyInput(const KeyEvent& rKEvt); + + void UnsetDropTarget(); + +protected: + + bool CheckDragAndDropMode( SvTreeListBox const * pSource, sal_Int8 ); + void ImplShowTargetEmphasis( SvTreeListEntry* pEntry, bool bShow); + void EnableSelectionAsDropTarget( bool bEnable = true ); + // Standard impl returns 0; derived classes which support D'n'D must override + using Window::GetDropTarget; + virtual SvTreeListEntry* GetDropTarget( const Point& ); + + // Invalidate children on enable/disable + virtual void StateChanged( StateChangedType eType ) override; + + virtual sal_uInt32 Insert( SvTreeListEntry* pEnt,SvTreeListEntry* pPar,sal_uInt32 nPos=TREELIST_APPEND); + virtual sal_uInt32 Insert( SvTreeListEntry* pEntry,sal_uInt32 nRootPos = TREELIST_APPEND ); + + // In-place editing + std::unique_ptr<SvInplaceEdit2> pEdCtrl; + void EditText( const OUString&, const tools::Rectangle&,const Selection&); + void CancelTextEditing(); + + // InitViewData is called right after CreateViewData + // The Entry is has not yet been added to the View in InitViewData! + virtual void InitViewData( SvViewDataEntry*, SvTreeListEntry* pEntry ) override; + // Calls InitViewData for all Items + void RecalcViewData(); + + // Handler and methods for Drag - finished handler. This link can be set + // to the TransferDataContainer. The AddBox/RemoveBox methods must be + // called before the StartDrag call. + // The Remove will be called from the handler, which then calls DragFinish. + // The Remove is also called in the DTOR of the SvTreeListBox - + // so it can't be called for a deleted object. + Link<sal_Int8,void> GetDragFinishedHdl() const; + + // For asynchronous D'n'D + sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt, SvTreeListBox* pSourceView ); + + void OnCurrentEntryChanged(); + + // ISearchableStringList + virtual vcl::StringEntryIdentifier CurrentEntry( OUString& _out_entryText ) const override; + virtual vcl::StringEntryIdentifier NextEntry( vcl::StringEntryIdentifier _currentEntry, OUString& _out_entryText ) const override; + virtual void SelectEntry( vcl::StringEntryIdentifier _entry ) override; + +public: + + SvTreeListBox( vcl::Window* pParent, WinBits nWinStyle=0 ); + virtual ~SvTreeListBox() override; + virtual void dispose() override; + + SvTreeList* GetModel() const + { + return pModel.get(); + } + + sal_uInt32 GetEntryCount() const + { + return pModel ? pModel->GetEntryCount() : 0; + } + SvTreeListEntry* First() const + { + return pModel ? pModel->First() : nullptr; + } + SvTreeListEntry* Next( SvTreeListEntry* pEntry ) const + { + return pModel->Next(pEntry); + } + SvTreeListEntry* Prev( SvTreeListEntry* pEntry ) const + { + return pModel->Prev(pEntry); + } + SvTreeListEntry* Last() const + { + return pModel ? pModel->Last() : nullptr; + } + + SvTreeListEntry* FirstChild( SvTreeListEntry* pParent ) const; + + bool CopySelection( SvTreeListBox* pSource, SvTreeListEntry* pTarget ); + bool MoveSelectionCopyFallbackPossible( SvTreeListBox* pSource, SvTreeListEntry* pTarget, bool bAllowCopyFallback ); + void RemoveSelection(); + /** + * Removes the entry along with all of its descendants + */ + void RemoveEntry(SvTreeListEntry const * pEntry); + + DragDropMode GetDragDropMode() const { return nDragDropMode; } + SelectionMode GetSelectionMode() const { return eSelMode; } + + // pParent == 0 -> Root level + SvTreeListEntry* GetEntry( SvTreeListEntry* pParent, sal_uInt32 nPos ) const; + SvTreeListEntry* GetEntry( sal_uInt32 nRootPos ) const; + + SvTreeListEntry* GetEntryFromPath( const ::std::deque< sal_Int32 >& _rPath ) const; + void FillEntryPath( SvTreeListEntry* pEntry, ::std::deque< sal_Int32 >& _rPath ) const; + + using Window::GetParent; + SvTreeListEntry* GetParent( SvTreeListEntry* pEntry ) const; + + using Window::GetChildCount; + sal_uInt32 GetChildCount( SvTreeListEntry const * pParent ) const; + sal_uInt32 GetLevelChildCount( SvTreeListEntry* pParent ) const; + + SvViewDataEntry* GetViewDataEntry( SvTreeListEntry const * pEntry ) const; + SvViewDataItem* GetViewDataItem(SvTreeListEntry const *, SvLBoxItem const *); + const SvViewDataItem* GetViewDataItem(const SvTreeListEntry*, const SvLBoxItem*) const; + + bool IsInplaceEditingEnabled() const { return bool(nImpFlags & SvTreeListBoxFlags::EDT_ENABLED); } + bool IsEditingActive() const { return bool(nImpFlags & SvTreeListBoxFlags::IN_EDT); } + void EndEditing( bool bCancel = false ); + + void Clear(); + + bool TextCenterAndClipEnabled() const { return mbCenterAndClipText; } + + void SetSelectHdl( const Link<SvTreeListBox*,void>& rNewHdl ) {aSelectHdl=rNewHdl; } + void SetDeselectHdl( const Link<SvTreeListBox*,void>& rNewHdl ) {aDeselectHdl=rNewHdl; } + void SetDoubleClickHdl(const Link<SvTreeListBox*,bool>& rNewHdl) {aDoubleClickHdl=rNewHdl;} + void SetExpandingHdl(const Link<SvTreeListBox*,bool>& rNewHdl){aExpandingHdl=rNewHdl;} + void SetExpandedHdl(const Link<SvTreeListBox*,void>& rNewHdl){aExpandedHdl=rNewHdl;} + void SetPopupMenuHdl(const Link<const CommandEvent&, bool>& rLink) { aPopupMenuHdl = rLink; } + void SetTooltipHdl(const Link<const HelpEvent&, bool>& rLink) { aTooltipHdl = rLink; } + void SetCustomRenderHdl(const Link<svtree_render_args, void>& rLink) { aCustomRenderHdl = rLink; } + void SetCustomMeasureHdl(const Link<svtree_measure_args, Size>& rLink) { aCustomMeasureHdl = rLink; } + + void ExpandedHdl(); + bool ExpandingHdl(); + void SelectHdl(); + void DeselectHdl(); + bool DoubleClickHdl(); + SvTreeListEntry* GetHdlEntry() const { return pHdlEntry; } + + // Is called for an Entry that gets expanded with the Flag + // ENTRYFLAG_CHILDREN_ON_DEMAND set. + virtual void RequestingChildren( SvTreeListEntry* pParent ); + + // Drag & Drop + // New D'n'D API + virtual sal_Int8 AcceptDrop( const AcceptDropEvent& rEvt ) override; + virtual sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt ) override; + virtual void StartDrag( sal_Int8 nAction, const Point& rPosPixel ) override; + virtual DragDropMode NotifyStartDrag(); + virtual void DragFinished( sal_Int8 nDropAction ); + + SvTreeListEntry* CloneEntry( SvTreeListEntry* pSource ); + + // Return value: TRISTATE_TRUE == Ok, TRISTATE_FALSE == Cancel, TRISTATE_INDET == Ok and Make visible moved entry + TriState NotifyMoving( + SvTreeListEntry* pTarget, // D'n'D DropPosition in GetModel() + const SvTreeListEntry* pEntry, // Entry to be moved from GetSourceListBox()->GetModel() + SvTreeListEntry*& rpNewParent, // New TargetParent + sal_uInt32& rNewChildPos); // The TargetParent's position in Childlist + + // Return value: TRISTATE_TRUE == Ok, TRISTATE_FALSE == Cancel, TRISTATE_INDET == Ok and Make visible moved entry + TriState NotifyCopying( + SvTreeListEntry* pTarget, // D'n'D DropPosition in GetModel() + const SvTreeListEntry* pEntry, // Entry to be copied from GetSourceListBox()->GetModel() + SvTreeListEntry*& rpNewParent, // New TargetParent + sal_uInt32& rNewChildPos); // The TargetParent's position in Childlist + + // ACCESSIBILITY ========================================================== + + /** Creates and returns the accessible object of the Box. */ + virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessible() override; + + /** Fills the StateSet of one entry. */ + void FillAccessibleEntryStateSet( SvTreeListEntry* pEntry, ::utl::AccessibleStateSetHelper& rStateSet ) const; + + virtual OUString GetEntryAccessibleDescription(SvTreeListEntry* pEntry) const; + + /** Calculate and return the bounding rectangle of an entry. + @param pEntry + The entry. + @return The bounding rectangle of an entry. */ + tools::Rectangle GetBoundingRect(const SvTreeListEntry* pEntry); + + SvTreeFlags GetTreeFlags() const {return nTreeFlags;} + + static OUString SearchEntryTextWithHeadTitle(SvTreeListEntry* pEntry); + + void set_min_width_in_chars(sal_Int32 nChars); + + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + + VCL_DLLPRIVATE void SetCollapsedNodeBmp( const Image& ); + VCL_DLLPRIVATE void SetExpandedNodeBmp( const Image& ); + VCL_DLLPRIVATE Image const & GetExpandedNodeBmp( ) const; + +protected: + + virtual void CalcEntryHeight(SvTreeListEntry const* pEntry); + void AdjustEntryHeight( const Image& rBmp ); + VCL_DLLPRIVATE void AdjustEntryHeight(); + + VCL_DLLPRIVATE void ImpEntryInserted( SvTreeListEntry* pEntry ); + VCL_DLLPRIVATE void PaintEntry1( SvTreeListEntry&, tools::Long nLine, vcl::RenderContext& rRenderContext ); + + VCL_DLLPRIVATE void InitTreeView(); + VCL_DLLPRIVATE SvLBoxItem* GetItem_Impl( SvTreeListEntry*, tools::Long nX, SvLBoxTab** ppTab ); + VCL_DLLPRIVATE void ImplInitStyle(); + + void SetupDragOrigin(); + void EditItemText( SvTreeListEntry* pEntry, SvLBoxString* pItem, + const Selection& ); + void EditedText(const OUString&); + + // Recalculate all tabs depending on TreeListStyle and Bitmap sizes + // Is called automatically when inserting/changing Bitmaps, changing the Model etc. + virtual void SetTabs(); + void AddTab( tools::Long nPos, SvLBoxTabFlags nFlags ); + sal_uInt16 TabCount() const { return aTabs.size(); } + SvLBoxTab* GetFirstDynamicTab() const; + SvLBoxTab* GetFirstDynamicTab( sal_uInt16& rTabPos ) const; + SvLBoxTab* GetFirstTab( SvLBoxTabFlags nFlagMask, sal_uInt16& rTabPos ); + void GetLastTab( SvLBoxTabFlags nFlagMask, sal_uInt16& rTabPos ); + SvLBoxTab* GetTab( SvTreeListEntry const *, SvLBoxItem const * ) const; + void ClearTabList(); + + virtual void InitEntry(SvTreeListEntry*, const OUString&, const Image&, const Image&); + + void NotifyScrolled(); + void SetScrolledHdl( const Link<SvTreeListBox*,void>& rLink ) { aScrolledHdl = rLink; } + tools::Long GetXOffset() const { return GetMapMode().GetOrigin().X(); } + + virtual void Command( const CommandEvent& rCEvt ) override; + + virtual void RequestHelp( const HelpEvent& rHEvt ) override; + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + + void InitSettings(); + + virtual void ApplySettings(vcl::RenderContext& rRenderContext) override; + + void CallImplEventListeners(VclEventId nEvent, void* pData); + + void ImplEditEntry( SvTreeListEntry* pEntry ); + + void AdjustEntryHeightAndRecalc(); + + // true if rPos is over the SvTreeListBox body, i.e. not over a + // scrollbar + VCL_DLLPRIVATE bool PosOverBody(const Point& rPos) const; +public: + + void SetNoAutoCurEntry( bool b ); + + void EnableCheckButton( SvLBoxButtonData* ); + void SetCheckButtonData( SvLBoxButtonData* ); + + /** Returns the default image which clients should use for expanded nodes, to have a consistent user + interface experience in the whole product. + */ + static const Image& GetDefaultExpandedNodeImage( ); + + /** Returns the default image which clients should use for expanded nodes, to have a consistent user + interface experience in the whole product. + */ + static const Image& GetDefaultCollapsedNodeImage( ); + + /** Sets default bitmaps for collapsed and expanded nodes. + */ + void SetNodeDefaultImages(); + + virtual SvTreeListEntry* InsertEntry( const OUString& rText, SvTreeListEntry* pParent = nullptr, + bool bChildrenOnDemand = false, + sal_uInt32 nPos=TREELIST_APPEND, void* pUserData = nullptr); + + const Image& GetDefaultExpandedEntryBmp( ) const; + const Image& GetDefaultCollapsedEntryBmp( ) const; + + void SetDefaultExpandedEntryBmp( const Image& rBmp ); + void SetDefaultCollapsedEntryBmp( const Image& rBmp ); + + void SetCheckButtonState( SvTreeListEntry*, SvButtonState ); + SvButtonState GetCheckButtonState( SvTreeListEntry* ) const; + + void SetEntryText(SvTreeListEntry*, const OUString& ); + void SetExpandedEntryBmp( SvTreeListEntry* _pEntry, const Image& _rImage ); + void SetCollapsedEntryBmp( SvTreeListEntry* _pEntry, const Image& _rImage ); + + virtual OUString GetEntryText( SvTreeListEntry* pEntry ) const; + static const Image& GetExpandedEntryBmp(const SvTreeListEntry* _pEntry ); + static const Image& GetCollapsedEntryBmp(const SvTreeListEntry* _pEntry ); + + void CheckButtonHdl(); + + void SetSublistOpenWithLeftRight(); // open/close sublist with cursor left/right + + void EnableInplaceEditing( bool bEnable ); + // Edits the Entry's first StringItem, 0 == Cursor + void EditEntry( SvTreeListEntry* pEntry ); + virtual bool EditingEntry( SvTreeListEntry* pEntry ); + virtual bool EditedEntry( SvTreeListEntry* pEntry, const OUString& rNewText ); + + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void MouseButtonUp( const MouseEvent& rMEvt ) override; + virtual void MouseMove( const MouseEvent& rMEvt ) override; + virtual void KeyInput( const KeyEvent& rKEvt ) override; + virtual void Resize() override; + virtual void GetFocus() override; + virtual void LoseFocus() override; + void SetUpdateMode( bool ); + + virtual void ModelHasCleared() override; + virtual void ModelHasInserted( SvTreeListEntry* pEntry ) override; + virtual void ModelHasInsertedTree( SvTreeListEntry* pEntry ) override; + virtual void ModelIsMoving(SvTreeListEntry* pSource ) override; + virtual void ModelHasMoved(SvTreeListEntry* pSource ) override; + virtual void ModelIsRemoving( SvTreeListEntry* pEntry ) override; + virtual void ModelHasRemoved( SvTreeListEntry* pEntry ) override; + void ModelHasEntryInvalidated( SvTreeListEntry* pEntry ) override; + + void ScrollOutputArea( short nDeltaEntries ); + + short GetColumnsCount() const { return nColumns; } + short GetEntryHeight() const { return nEntryHeight; } + void SetEntryHeight( short nHeight ); + short GetEntryWidth() const { return nEntryWidth; } + void SetEntryWidth( short nWidth ); + Size GetOutputSizePixel() const; + short GetIndent() const { return nIndent; } + void SetSpaceBetweenEntries( short nSpace ); + Point GetEntryPosition(const SvTreeListEntry*) const; + void MakeVisible( SvTreeListEntry* pEntry ); + void MakeVisible( SvTreeListEntry* pEntry, bool bMoveToTop ); + + void SetFont( const vcl::Font& rFont ); + + SvTreeListEntry* GetEntry( const Point& rPos, bool bHit = false ) const; + + virtual tools::Rectangle GetFocusRect(const SvTreeListEntry*, tools::Long nLine ); + // Respects indentation + sal_IntPtr GetTabPos(const SvTreeListEntry*, const SvLBoxTab*) const; + void InvalidateEntry( SvTreeListEntry* ); + SvLBoxItem* GetItem( SvTreeListEntry*, tools::Long nX, SvLBoxTab** ppTab); + SvLBoxItem* GetItem( SvTreeListEntry*, tools::Long nX ); + std::pair<tools::Long, tools::Long> GetItemPos(SvTreeListEntry* pEntry, sal_uInt16 nTabIdx); + + void SetDragDropMode( DragDropMode ); + void SetSelectionMode( SelectionMode ); + + bool Expand( SvTreeListEntry* pParent ); + bool Collapse( SvTreeListEntry* pParent ); + bool Select( SvTreeListEntry* pEntry, bool bSelect=true ); + sal_uInt32 SelectChildren( SvTreeListEntry* pParent, bool bSelect ); + void SelectAll( bool bSelect ); + + void SetCurEntry( SvTreeListEntry* _pEntry ); + SvTreeListEntry* GetCurEntry() const; + + using Window::Invalidate; + virtual void Invalidate( InvalidateFlags nFlags = InvalidateFlags::NONE) override; + virtual void Invalidate( const tools::Rectangle&, InvalidateFlags nFlags = InvalidateFlags::NONE ) override; + + void SetHighlightRange(sal_uInt16 nFirstTab=0, sal_uInt16 nLastTab=0xffff); + + sal_Int32 DefaultCompare(const SvLBoxString* pLeftText, const SvLBoxString* pRightText); + + DECL_DLLPRIVATE_LINK( DefaultCompare, const SvSortData&, sal_Int32 ); + virtual void ModelNotification( SvListAction nActionId, SvTreeListEntry* pEntry1, + SvTreeListEntry* pEntry2, sal_uInt32 nPos ) override; + + SvTreeListEntry* GetFirstEntryInView() const; + SvTreeListEntry* GetNextEntryInView(SvTreeListEntry*) const; + void ScrollToAbsPos( tools::Long nPos ); + + tools::Long getPreferredDimensions(std::vector<tools::Long> &rWidths) const; + + virtual Size GetOptimalSize() const override; + + void SetAlternatingRowColors( const bool bEnable ); + + // Enables type-ahead search in the check list box. + void SetQuickSearch(bool bEnable) { mbQuickSearch = bEnable; } + + // Make single click "activate" a row like a double-click normally does + void SetActivateOnSingleClick(bool bEnable) { mbActivateOnSingleClick = bEnable; } + bool GetActivateOnSingleClick() const { return mbActivateOnSingleClick; } + + // Make mouse over a row "select" a row like a single-click normally does + void SetHoverSelection(bool bEnable) { mbHoverSelection = bEnable; } + bool GetHoverSelection() const { return mbHoverSelection; } + + // only true during Select if the Select is due to a Hover + bool IsSelectDueToHover() const { return mbSelectingByHover; } + + // Set when clicks toggle the checkbox of the row. + void SetClicksToToggle(sal_Int8 nCount) { mnClicksToToggle = nCount; } + + void SetForceMakeVisible(bool bEnable); + + virtual FactoryFunction GetUITestFactory() const override; + + void SetDragHelper(const rtl::Reference<TransferDataContainer>& rHelper, sal_uInt8 eDNDConstants); + + virtual void EnableRTL(bool bEnable = true) override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/treelistentries.hxx b/include/vcl/toolkit/treelistentries.hxx new file mode 100644 index 000000000..fdd86dbfa --- /dev/null +++ b/include/vcl/toolkit/treelistentries.hxx @@ -0,0 +1,23 @@ +/* -*- 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/. + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) \ + && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <vector> +#include <memory> + +class SvTreeListEntry; +typedef std::vector<std::unique_ptr<SvTreeListEntry>> SvTreeListEntries; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/treelistentry.hxx b/include/vcl/toolkit/treelistentry.hxx new file mode 100644 index 000000000..7a35e8e0b --- /dev/null +++ b/include/vcl/toolkit/treelistentry.hxx @@ -0,0 +1,131 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <vcl/dllapi.h> +#include <tools/color.hxx> +#include <vcl/toolkit/treelistbox.hxx> +#include <vcl/toolkit/treelistentries.hxx> +#include <o3tl/typed_flags_set.hxx> + +#include <optional> +#include <vector> +#include <memory> + +// flags related to the model +enum class SvTLEntryFlags +{ + NONE = 0x0000, + CHILDREN_ON_DEMAND = 0x0001, + DISABLE_DROP = 0x0002, + // is set if RequestingChildren has not set any children + NO_NODEBMP = 0x0004, + // is set if this is a separator line + IS_SEPARATOR = 0x0008, + // entry had or has children + HAD_CHILDREN = 0x0010, + SEMITRANSPARENT = 0x8000, // draw semi-transparent entry bitmaps +}; +namespace o3tl +{ + template<> struct typed_flags<SvTLEntryFlags> : is_typed_flags<SvTLEntryFlags, 0x801f> {}; +} + +class VCL_DLLPUBLIC SvTreeListEntry +{ + friend class SvTreeList; + friend class SvListView; + friend class SvTreeListBox; + + typedef std::vector<std::unique_ptr<SvLBoxItem>> ItemsType; + + SvTreeListEntry* pParent; + SvTreeListEntries m_Children; + sal_uInt32 nAbsPos; + sal_uInt32 nListPos; + sal_uInt32 mnExtraIndent; + ItemsType m_Items; + void* pUserData; + SvTLEntryFlags nEntryFlags; + Color maBackColor; + std::optional<Color> mxTextColor; + +private: + void ClearChildren(); + void SetListPositions(); + void InvalidateChildrensListPositions(); + + SvTreeListEntry(const SvTreeListEntry& r) = delete; + void operator=(SvTreeListEntry const&) = delete; + +public: + static const size_t ITEM_NOT_FOUND = SAL_MAX_SIZE; + + SvTreeListEntry(); + virtual ~SvTreeListEntry(); + + bool HasChildren() const; + bool HasChildListPos() const; + sal_uInt32 GetChildListPos() const; + + SvTreeListEntries& GetChildEntries() { return m_Children; } + const SvTreeListEntries& GetChildEntries() const { return m_Children; } + + void Clone(SvTreeListEntry* pSource); + + size_t ItemCount() const; + + // MAY ONLY BE CALLED IF THE ENTRY HAS NOT YET BEEN INSERTED INTO + // THE MODEL, AS OTHERWISE NO VIEW-DEPENDENT DATA ARE ALLOCATED + // FOR THE ITEM! + void AddItem(std::unique_ptr<SvLBoxItem> pItem); + void ReplaceItem(std::unique_ptr<SvLBoxItem> pNewItem, size_t nPos); + const SvLBoxItem& GetItem( size_t nPos ) const; + SvLBoxItem& GetItem( size_t nPos ); + const SvLBoxItem* GetFirstItem(SvLBoxItemType eType) const; + SvLBoxItem* GetFirstItem(SvLBoxItemType eType); + size_t GetPos( const SvLBoxItem* pItem ) const; + void* GetUserData() const { return pUserData;} + void SetUserData( void* pPtr ); + void EnableChildrenOnDemand( bool bEnable=true ); + bool HasChildrenOnDemand() const; + + SvTLEntryFlags GetFlags() const { return nEntryFlags;} + void SetFlags( SvTLEntryFlags nFlags ); + + void SetBackColor( const Color& rColor ) { maBackColor = rColor; } + const Color& GetBackColor() const { return maBackColor; } + + void SetTextColor( std::optional<Color> xColor ) { mxTextColor = xColor; } + std::optional<Color> const & GetTextColor() const { return mxTextColor; } + + void SetExtraIndent(sal_uInt32 nExtraIndent) { mnExtraIndent = nExtraIndent; } + sal_uInt32 GetExtraIndent() const { return mnExtraIndent; } + + SvTreeListEntry* NextSibling() const; + SvTreeListEntry* PrevSibling() const; + SvTreeListEntry* LastSibling() const; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/unowrap.hxx b/include/vcl/toolkit/unowrap.hxx new file mode 100644 index 000000000..edaeb9dc9 --- /dev/null +++ b/include/vcl/toolkit/unowrap.hxx @@ -0,0 +1,93 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <config_options.h> +#include <com/sun/star/uno/Reference.h> +#include <vcl/dllapi.h> +#include <vcl/vclptr.hxx> + +namespace vcl { class Window; } +class Menu; +class OutputDevice; +class PopupMenu; +namespace com::sun::star::awt { + class XGraphics; + class XPopupMenu; + class XToolkit; + class XWindow; + class XWindowPeer; +} +namespace com::sun::star::accessibility { + class XAccessible; +} + +class VCL_DLLPUBLIC UnoWrapperBase +{ +public: + virtual void Destroy() = 0; + + // Toolkit + virtual css::uno::Reference< css::awt::XToolkit > GetVCLToolkit() = 0; + + // Graphics + virtual css::uno::Reference< css::awt::XGraphics > CreateGraphics( OutputDevice* pOutDev ) = 0; + virtual void ReleaseAllGraphics( OutputDevice* pOutDev ) = 0; + + // Window + virtual css::uno::Reference<css::awt::XWindowPeer> GetWindowInterface( vcl::Window* pWindow ) = 0; + virtual void SetWindowInterface( vcl::Window* pWindow, const css::uno::Reference< css::awt::XWindowPeer > & xIFace ) = 0; + virtual VclPtr<vcl::Window> GetWindow(const css::uno::Reference<css::awt::XWindow>& rxWindow) = 0; + + // PopupMenu + virtual css::uno::Reference<css::awt::XPopupMenu> CreateMenuInterface( PopupMenu* pPopupMenu ) = 0; + + virtual void WindowDestroyed( vcl::Window* pWindow ) = 0; + + // Accessibility + virtual css::uno::Reference< css::accessibility::XAccessible > + CreateAccessible( Menu* pMenu, bool bIsMenuBar ) = 0; + + /** Get the application's UNO wrapper object. + + Note that this static function will only ever try to create UNO wrapper object once, and + if it fails then it will not ever try again, even if the function is called multiple times. + + @param bCreateIfNotExists Create the UNO wrapper object if it doesn't exist when true. + + @return UNO wrapper object. + */ + static UnoWrapperBase* GetUnoWrapper( bool bCreateIfNotExists = true ); + + /** Sets the application's UNO Wrapper object. + + @param pWrapper Pointer to UNO wrapper object. + */ + static void SetUnoWrapper( UnoWrapperBase* pWrapper ); + +protected: + ~UnoWrapperBase() {} +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/vclmedit.hxx b/include/vcl/toolkit/vclmedit.hxx new file mode 100644 index 000000000..3a7c4e274 --- /dev/null +++ b/include/vcl/toolkit/vclmedit.hxx @@ -0,0 +1,173 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <tools/lineend.hxx> +#include <tools/wintypes.hxx> +#include <vcl/toolkit/edit.hxx> +#include <vcl/dllapi.h> +#include <vcl/timer.hxx> +#include <memory> + +class ImpVclMEdit; +class ExtTextEngine; +class TextView; + +class TextWindow final : public vcl::Window +{ +private: + VclPtr<Edit> mxParent; + std::unique_ptr<ExtTextEngine> mpExtTextEngine; + std::unique_ptr<TextView> mpExtTextView; + + bool mbInMBDown; + bool mbFocusSelectionHide; + bool mbIgnoreTab; + bool mbActivePopup; + bool mbSelectOnTab; + +public: + explicit TextWindow(Edit* pParent); + virtual ~TextWindow() override; + virtual void dispose() override; + + ExtTextEngine* GetTextEngine() const { return mpExtTextEngine.get(); } + TextView* GetTextView() const { return mpExtTextView.get(); } + + virtual void MouseMove( const MouseEvent& rMEvt ) override; + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void MouseButtonUp( const MouseEvent& rMEvt ) override; + virtual void KeyInput( const KeyEvent& rKEvent ) override; + + virtual void Command( const CommandEvent& rCEvt ) override; + + virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override; + virtual void Resize() override; + + virtual void GetFocus() override; + virtual void LoseFocus() override; + + void SetAutoFocusHide( bool bAutoHide ) { mbFocusSelectionHide = bAutoHide; } + + void SetIgnoreTab( bool bIgnore ) { mbIgnoreTab = bIgnore; } + + void DisableSelectionOnFocus() { mbSelectOnTab = false; } +}; + +class VCL_DLLPUBLIC VclMultiLineEdit : public Edit +{ + friend class VCLXAccessibleEdit; + +private: + std::unique_ptr<ImpVclMEdit> pImpVclMEdit; + + Link<Edit&,void> aModifyHdlLink; + +protected: + + void StateChanged( StateChangedType nType ) override; + void DataChanged( const DataChangedEvent& rDCEvt ) override; + virtual bool PreNotify( NotifyEvent& rNEvt ) override; + virtual bool EventNotify( NotifyEvent& rNEvt ) override; + using Control::ImplInitSettings; + void ImplInitSettings( bool bBackground ); + static WinBits ImplInitStyle( WinBits nStyle ); + + TextView* GetTextView() const; + ExtTextEngine* GetTextEngine() const; + + virtual void ApplySettings(vcl::RenderContext& rRenderContext) override; +public: + VclMultiLineEdit( vcl::Window* pParent, + WinBits nWinStyle ); + virtual ~VclMultiLineEdit() override; + virtual void dispose() override; + + void SelectionChanged(); + void CaretChanged(); + virtual void Modify() override; + + virtual void SetModifyFlag() override; + + virtual void SetReadOnly( bool bReadOnly = true ) override; + virtual bool IsReadOnly() const override; + + void EnableFocusSelectionHide( bool bHide ); + + virtual void SetMaxTextLen(sal_Int32 nMaxLen) override; + virtual sal_Int32 GetMaxTextLen() const override; + + void SetMaxTextWidth(tools::Long nMaxWidth); + + virtual void SetSelection( const Selection& rSelection ) override; + virtual const Selection& GetSelection() const override; + + virtual void ReplaceSelected( const OUString& rStr ) override; + virtual void DeleteSelected() override; + virtual OUString GetSelected() const override; + OUString GetSelected( LineEnd aSeparator ) const; + + bool CanUp() const; + bool CanDown() const; + + virtual void Cut() override; + virtual void Copy() override; + virtual void Paste() override; + + virtual void SetText( const OUString& rStr ) override; + virtual void SetText( const OUString& rStr, const Selection& rNewSelection ) override + { SetText( rStr ); SetSelection( rNewSelection ); } + OUString GetText() const override; + OUString GetText( LineEnd aSeparator ) const; + OUString GetTextLines( LineEnd aSeparator ) const; + + void SetModifyHdl( const Link<Edit&,void>& rLink ) override { aModifyHdlLink = rLink; } + const Link<Edit&,void>& GetModifyHdl() const override { return aModifyHdlLink; } + + virtual void Resize() override; + virtual void GetFocus() override; + + virtual Size CalcMinimumSize() const override; + Size CalcAdjustedSize( const Size& rPrefSize ) const; + Size CalcBlockSize( sal_uInt16 nColumns, sal_uInt16 nLines ) const; + void GetMaxVisColumnsAndLines( sal_uInt16& rnCols, sal_uInt16& rnLines ) const; + + void Draw( OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags ) override; + + void DisableSelectionOnFocus(); + + void EnableCursor( bool bEnable ); + + ScrollBar& GetVScrollBar() const; + + TextWindow* GetTextWindow(); + + virtual FactoryFunction GetUITestFactory() const override; + + virtual bool set_property(const OString &rKey, const OUString &rValue) override; + + virtual void DumpAsPropertyTree(tools::JsonWriter&) override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/toolkit/viewdataentry.hxx b/include/vcl/toolkit/viewdataentry.hxx new file mode 100644 index 000000000..b34a8e3ef --- /dev/null +++ b/include/vcl/toolkit/viewdataentry.hxx @@ -0,0 +1,85 @@ +/* -*- 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 . + */ + +#pragma once + +#if !defined(VCL_DLLIMPLEMENTATION) && !defined(TOOLKIT_DLLIMPLEMENTATION) && !defined(VCL_INTERNALS) +#error "don't use this in new code" +#endif + +#include <sal/types.h> +#include <vector> + +class SvTreeListBox; + +struct SvViewDataItem +{ + int mnWidth = 0; + int mnHeight = 0; +}; + +/** + * View-dependent data for a tree list entry created in the virtual function + * SvTreeListBox::CreateViewData(). The item array contains the same number + * of items as that of the items in its corresponding tree list entry. + * + * When an entry is selected, it is logically selected and visually + * highlighted. When an entry is only highlighted, it looks visually + * highlighted, but not logically selected. + */ +class SvViewDataEntry +{ + friend class SvTreeList; + + std::vector<SvViewDataItem> maItems; + sal_uInt32 nVisPos; + bool mbSelected:1; + bool mbHighlighted:1; + bool mbExpanded:1; + bool mbFocused:1; + bool mbSelectable:1; + bool mbDragTarget:1; + +public: + SvViewDataEntry(); + SvViewDataEntry( const SvViewDataEntry& ); + ~SvViewDataEntry(); + + bool IsSelected() const { return mbSelected;} + bool IsHighlighted() const { return mbHighlighted;} + bool IsExpanded() const { return mbExpanded;} + bool HasFocus() const { return mbFocused;} + bool IsSelectable() const { return mbSelectable;} + bool IsDragTarget() const { return mbDragTarget;} + void SetFocus( bool bFocus ); + void SetSelected( bool bSelected ); + void SetExpanded( bool bExpanded ); + void SetSelectable( bool bSelectable ); + void SetDragTarget( bool bDragTarget ) + { + mbDragTarget = bDragTarget; + } + + void Init(size_t nSize); + + const SvViewDataItem& GetItem(size_t nPos) const; + SvViewDataItem& GetItem(size_t nPos); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/transfer.hxx b/include/vcl/transfer.hxx new file mode 100644 index 000000000..58b43426e --- /dev/null +++ b/include/vcl/transfer.hxx @@ -0,0 +1,521 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_TRANSFER_HXX +#define INCLUDED_VCL_TRANSFER_HXX + +#include <vcl/dllapi.h> +#include <tools/globname.hxx> +#include <tools/gen.hxx> +#include <tools/solar.h> +#include <sot/formats.hxx> +#include <sot/exchange.hxx> +#include <cppuhelper/implbase.hxx> +#include <com/sun/star/frame/XTerminateListener.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/lang/XUnoTunnel.hpp> +#include <com/sun/star/datatransfer/XTransferable2.hpp> +#include <com/sun/star/datatransfer/clipboard/XClipboard.hpp> +#include <com/sun/star/datatransfer/clipboard/XClipboardOwner.hpp> +#include <com/sun/star/datatransfer/dnd/DNDConstants.hpp> +#include <com/sun/star/datatransfer/dnd/XDragGestureListener.hpp> +#include <com/sun/star/datatransfer/dnd/DropTargetDragEvent.hpp> +#include <com/sun/star/datatransfer/dnd/DropTargetDropEvent.hpp> +#include <com/sun/star/datatransfer/dnd/XDragSourceListener.hpp> +#include <com/sun/star/datatransfer/dnd/XDropTargetListener.hpp> +#include <com/sun/star/embed/Aspects.hpp> +#include <memory> +#include <mutex> + +namespace com::sun::star::datatransfer::dnd { class XDragGestureRecognizer; } +namespace com::sun::star::io { class XInputStream; } +namespace com::sun::star::datatransfer::dnd { class XDropTarget; } + +namespace tools { template <typename T> class SvRef; } +template <typename Arg, typename Ret> class Link; + +class BitmapEx; +class GDIMetaFile; +class Graphic; +class ImageMap; +class INetBookmark; +class INetImage; +class FileList; +class SotStorageStream; +class SotTempStream; +namespace vcl { class Window; } + +// Drag&Drop defines + +#define DND_ACTION_NONE css::datatransfer::dnd::DNDConstants::ACTION_NONE +#define DND_ACTION_COPY css::datatransfer::dnd::DNDConstants::ACTION_COPY +#define DND_ACTION_MOVE css::datatransfer::dnd::DNDConstants::ACTION_MOVE +#define DND_ACTION_COPYMOVE css::datatransfer::dnd::DNDConstants::ACTION_COPY_OR_MOVE +#define DND_ACTION_LINK css::datatransfer::dnd::DNDConstants::ACTION_LINK + +#define DND_POINTER_NONE 0 +#define DND_IMAGE_NONE 0 + +struct TransferableObjectDescriptor +{ + SvGlobalName maClassName; + sal_uInt16 mnViewAspect; + Point maDragStartPos; + Size maSize; + OUString maTypeName; + OUString maDisplayName; + + TransferableObjectDescriptor() + : mnViewAspect(css::embed::Aspects::MSOLE_CONTENT) + {} + + VCL_DLLPUBLIC friend SvStream& WriteTransferableObjectDescriptor( SvStream& rOStm, const TransferableObjectDescriptor& rObjDesc ); +}; + +struct AcceptDropEvent +{ + Point maPosPixel; + const css::datatransfer::dnd::DropTargetDragEvent maDragEvent; + sal_Int8 mnAction; + bool mbLeaving; + bool mbDefault; + + AcceptDropEvent() : + mnAction( DND_ACTION_NONE ), + mbLeaving( false ), + mbDefault( false ) {} + + AcceptDropEvent( sal_Int8 nAction, + const Point& rPosPixel, + const css::datatransfer::dnd::DropTargetDragEvent& rDragEvent ) : + maPosPixel( rPosPixel ), + maDragEvent( rDragEvent ), + mnAction( nAction ), + mbLeaving( false ), + mbDefault( false ) {} +}; + +struct ExecuteDropEvent +{ + Point maPosPixel; + const css::datatransfer::dnd::DropTargetDropEvent maDropEvent; + sal_Int8 mnAction; + bool mbDefault; + + ExecuteDropEvent( sal_Int8 nAction, + const Point& rPosPixel, + const css::datatransfer::dnd::DropTargetDropEvent& rDropEvent ) : + maPosPixel( rPosPixel ), + maDropEvent( rDropEvent ), + mnAction( nAction ), + mbDefault( false ) {} +}; + +class VCL_DLLPUBLIC TransferableHelper : public cppu::WeakImplHelper< css::datatransfer::XTransferable2, + css::datatransfer::clipboard::XClipboardOwner, + css::datatransfer::dnd::XDragSourceListener, + css::lang::XUnoTunnel > +{ +private: + + // nested class to implement the XTerminateListener interface + class VCL_DLLPRIVATE TerminateListener final : public cppu::WeakImplHelper< css::frame::XTerminateListener, css::lang::XServiceInfo > + { + private: + + TransferableHelper& mrParent; + + private: + + // XEventListener + virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override; + + // XTerminateListener + virtual void SAL_CALL queryTermination( const css::lang::EventObject& aEvent ) override; + virtual void SAL_CALL notifyTermination( const css::lang::EventObject& aEvent ) override; + + // XServiceInfo + virtual OUString SAL_CALL getImplementationName() override; + virtual sal_Bool SAL_CALL supportsService( const OUString& sServiceName ) override; + virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override; + + public: + + TerminateListener( TransferableHelper& rDropTargetHelper ); + virtual ~TerminateListener() override; + }; + + friend class TransferableHelper::TerminateListener; + +private: + + css::uno::Any maAny; + OUString maLastFormat; + mutable css::uno::Reference< css::datatransfer::clipboard::XClipboard > mxClipboard; + css::uno::Reference< css::frame::XTerminateListener > mxTerminateListener; + DataFlavorExVector maFormats; + std::unique_ptr<TransferableObjectDescriptor> mxObjDesc; + +protected: + ~TransferableHelper(); + + const css::uno::Reference< css::datatransfer::clipboard::XClipboard >& + getOwnClipboard() const { return mxClipboard; } + +public: + + // XTransferable + virtual css::uno::Any SAL_CALL getTransferData( const css::datatransfer::DataFlavor& rFlavor ) override; + virtual css::uno::Sequence< css::datatransfer::DataFlavor > SAL_CALL getTransferDataFlavors() override; + virtual sal_Bool SAL_CALL isDataFlavorSupported( const css::datatransfer::DataFlavor& rFlavor ) override; + + // Transferable2 + virtual css::uno::Any SAL_CALL getTransferData2( + const css::datatransfer::DataFlavor& rFlavor, const OUString& rDestDoc ) override; + virtual sal_Bool SAL_CALL isComplex() override; + +private: + + // XEventListener + virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override; + + // XDragSourceListener + virtual void SAL_CALL dragDropEnd( const css::datatransfer::dnd::DragSourceDropEvent& dsde ) override; + virtual void SAL_CALL dragEnter( const css::datatransfer::dnd::DragSourceDragEvent& dsde ) override; + virtual void SAL_CALL dragExit( const css::datatransfer::dnd::DragSourceEvent& dse ) override; + virtual void SAL_CALL dragOver( const css::datatransfer::dnd::DragSourceDragEvent& dsde ) override; + virtual void SAL_CALL dropActionChanged( const css::datatransfer::dnd::DragSourceDragEvent& dsde ) override; + + // XClipboardOwner + virtual void SAL_CALL lostOwnership( const css::uno::Reference< css::datatransfer::clipboard::XClipboard >& xClipboard, const css::uno::Reference< css::datatransfer::XTransferable >& xTrans ) override; + +protected: + // derivees need to access lostOwnership in case hey override it + // on windows, changing the access rights to a method gives unresolved externals, so we introduce + // this impl-method here 'til the next incompatible update + void implCallOwnLostOwnership( + const css::uno::Reference< css::datatransfer::clipboard::XClipboard >& _rxClipboard, + const css::uno::Reference< css::datatransfer::XTransferable >& _rxTrans + ) + { + TransferableHelper::lostOwnership( _rxClipboard, _rxTrans ); + } + + +private: + + VCL_DLLPRIVATE void ImplFlush(); + +protected: + + void AddFormat( SotClipboardFormatId nFormat ); + void AddFormat( const css::datatransfer::DataFlavor& rFlavor ); + void RemoveFormat( SotClipboardFormatId nFormat ); + void RemoveFormat( const css::datatransfer::DataFlavor& rFlavor ); + bool HasFormat( SotClipboardFormatId nFormat ); + void ClearFormats(); + + bool SetAny( const css::uno::Any& rAny ); + bool SetString( const OUString& rString ); + bool SetBitmapEx( const BitmapEx& rBitmap, const css::datatransfer::DataFlavor& rFlavor ); + bool SetGDIMetaFile( const GDIMetaFile& rMtf ); + bool SetGraphic( const Graphic& rGraphic ); + bool SetImageMap( const ImageMap& rIMap ); + bool SetTransferableObjectDescriptor( const TransferableObjectDescriptor& rDesc ); + bool SetINetBookmark( const INetBookmark& rBmk, const css::datatransfer::DataFlavor& rFlavor ); + bool SetINetImage( const INetImage& rINtImg, const css::datatransfer::DataFlavor& rFlavor ); + bool SetObject( void* pUserObject, sal_uInt32 nUserObjectId, const css::datatransfer::DataFlavor& rFlavor ); + +protected: + + virtual void AddSupportedFormats() = 0; + virtual bool GetData( const css::datatransfer::DataFlavor& rFlavor, const OUString& rDestDoc ) = 0; + virtual bool WriteObject( tools::SvRef<SotTempStream>& rxOStm, void* pUserObject, sal_uInt32 nUserObjectId, const css::datatransfer::DataFlavor& rFlavor ); + virtual void DragFinished( sal_Int8 nDropAction ); + virtual void ObjectReleased(); + + void CopyToSelection(const css::uno::Reference<css::datatransfer::clipboard::XClipboard> &rClipboard) const; +public: + + void PrepareOLE( const TransferableObjectDescriptor& rObjDesc ); + + void CopyToClipboard(const css::uno::Reference<css::datatransfer::clipboard::XClipboard> &rClipboard) const; + + // convenience versions of the above which extract the XClipboard from the pWindow + void CopyToClipboard( vcl::Window *pWindow ) const; + void CopyToPrimarySelection() const; + + void StartDrag( vcl::Window* pWindow, sal_Int8 nDragSourceActions ); + + static void ClearPrimarySelection(); + + static const css::uno::Sequence< sal_Int8 >& getUnoTunnelId(); + +public: + + virtual sal_Int64 SAL_CALL getSomething( const css::uno::Sequence< sal_Int8 >& rId ) override; +}; + +struct TransferableDataHelper_Impl; + +class VCL_DLLPUBLIC TransferableDataHelper final +{ + friend class DropTargetHelper; + + css::uno::Reference< css::datatransfer::XTransferable > mxTransfer; + css::uno::Reference< css::datatransfer::clipboard::XClipboard > mxClipboard; + DataFlavorExVector maFormats; + std::unique_ptr<TransferableObjectDescriptor> mxObjDesc; + std::unique_ptr<TransferableDataHelper_Impl> mxImpl; + + void InitFormats(); + +public: + + static void FillDataFlavorExVector( const css::uno::Sequence< css::datatransfer::DataFlavor >& rDataFlavorSeq, + DataFlavorExVector& rDataFlavorExVector ); + + TransferableDataHelper(); + TransferableDataHelper( const TransferableDataHelper& rDataHelper ); + TransferableDataHelper( TransferableDataHelper&& rDataHelper ) noexcept; + TransferableDataHelper( const css::uno::Reference< css::datatransfer::XTransferable >& rxTransferable ); + ~TransferableDataHelper(); + + TransferableDataHelper& operator=( const TransferableDataHelper& rDataHelper ); + TransferableDataHelper& operator=( TransferableDataHelper&& rDataHelper ); + + const css::uno::Reference< css::datatransfer::XTransferable >& GetTransferable() const { return mxTransfer; } + css::uno::Reference< css::datatransfer::XTransferable > GetXTransferable() const; + + bool HasFormat( SotClipboardFormatId nFormat ) const; + bool HasFormat( const css::datatransfer::DataFlavor& rFlavor ) const; + + sal_uInt32 GetFormatCount() const; + + SotClipboardFormatId GetFormat( sal_uInt32 nFormat ) const; + css::datatransfer::DataFlavor GetFormatDataFlavor( sal_uInt32 nFormat ) const; + + const DataFlavorExVector& GetDataFlavorExVector() const {return maFormats; } + + bool StartClipboardListening( ); + void StopClipboardListening( ); + + void Rebind( const css::uno::Reference< css::datatransfer::XTransferable >& _rxNewData ); + + css::uno::Any GetAny( SotClipboardFormatId nFormat, const OUString& rDestDoc ) const; + css::uno::Any GetAny( const css::datatransfer::DataFlavor& rFlavor, const OUString& rDestDoc ) const; + + bool GetString( SotClipboardFormatId nFormat, OUString& rStr ) const; + bool GetString( const css::datatransfer::DataFlavor& rFlavor, OUString& rStr ) const; + + bool GetBitmapEx( SotClipboardFormatId nFormat, BitmapEx& rBmp ) const; + bool GetBitmapEx( const css::datatransfer::DataFlavor& rFlavor, BitmapEx& rBmp ) const; + + /** Return as GDI metafile. + + @param nMaxAction Allows you to limit the amount of actions; defaults to 0 which means no limit. + + When you eg. Ctrl+a in Excel, you can get the entire sheet as + metafile, with over 3 million (!) actions; which is just too large for + any reasonable handling - and you need to set a limit. + */ + bool GetGDIMetaFile( SotClipboardFormatId nFormat, GDIMetaFile& rMtf, size_t nMaxActions = 0 ) const; + bool GetGDIMetaFile( const css::datatransfer::DataFlavor& rFlavor, GDIMetaFile& rMtf ) const; + + bool GetGraphic( SotClipboardFormatId nFormat, Graphic& rGraphic ) const; + bool GetGraphic( const css::datatransfer::DataFlavor& rFlavor, Graphic& rGraphic ) const; + + bool GetImageMap( SotClipboardFormatId nFormat, ImageMap& rIMap ) const; + bool GetImageMap( const css::datatransfer::DataFlavor& rFlavor, ImageMap& rImap ) const; + + bool GetTransferableObjectDescriptor( SotClipboardFormatId nFormat, TransferableObjectDescriptor& rDesc ); + bool GetTransferableObjectDescriptor( TransferableObjectDescriptor& rDesc ); + + bool GetINetBookmark( SotClipboardFormatId nFormat, INetBookmark& rBmk ) const; + bool GetINetBookmark( const css::datatransfer::DataFlavor& rFlavor, INetBookmark& rBmk ) const; + + bool GetINetImage( SotClipboardFormatId nFormat, INetImage& rINtImg ) const; + bool GetINetImage( const css::datatransfer::DataFlavor& rFlavor, INetImage& rINtImg ) const; + + bool GetFileList( SotClipboardFormatId nFormat, FileList& rFileList ) const; + bool GetFileList( FileList& rFileList ) const; + + css::uno::Sequence<sal_Int8> GetSequence( SotClipboardFormatId nFormat, const OUString& rDestDoc ) const; + css::uno::Sequence<sal_Int8> GetSequence( const css::datatransfer::DataFlavor& rFlavor, const OUString& rDestDoc ) const; + + bool GetSotStorageStream( SotClipboardFormatId nFormat, tools::SvRef<SotTempStream>& rStreamRef ) const; + bool GetSotStorageStream( const css::datatransfer::DataFlavor& rFlavor, tools::SvRef<SotTempStream>& rStreamRef ) const; + + css::uno::Reference<css::io::XInputStream> GetInputStream( SotClipboardFormatId nFormat, const OUString& rDestDoc ) const; + css::uno::Reference<css::io::XInputStream> GetInputStream( const css::datatransfer::DataFlavor& rFlavor, const OUString& rDestDoc ) const; + + static TransferableDataHelper CreateFromClipboard(const css::uno::Reference<css::datatransfer::clipboard::XClipboard>& rClipboard); + static TransferableDataHelper CreateFromSystemClipboard( vcl::Window * pWindow ); + static TransferableDataHelper CreateFromPrimarySelection(); + static bool IsEqual( const css::datatransfer::DataFlavor& rInternalFlavor, + const css::datatransfer::DataFlavor& rRequestFlavor ); +}; + +class VCL_DLLPUBLIC DragSourceHelper +{ +private: + + // nested class to implement the XDragGestureListener interface + class SAL_DLLPRIVATE DragGestureListener final : public cppu::WeakImplHelper< css::datatransfer::dnd::XDragGestureListener > + { + private: + + DragSourceHelper& mrParent; + + private: + + // XEventListener + virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override; + + // XDragGestureListener + virtual void SAL_CALL dragGestureRecognized( const css::datatransfer::dnd::DragGestureEvent& rDGE ) override; + + public: + + DragGestureListener( DragSourceHelper& rDragSourceHelper ); + virtual ~DragGestureListener() override; + }; + + friend class DragSourceHelper::DragGestureListener; + +private: + std::mutex maMutex; + css::uno::Reference< css::datatransfer::dnd::XDragGestureRecognizer > mxDragGestureRecognizer; + + css::uno::Reference< css::datatransfer::dnd::XDragGestureListener > mxDragGestureListener; + + DragSourceHelper& operator=( const DragSourceHelper& rDragSourceHelper ) = delete; + bool operator==( const DragSourceHelper& rDragSourceHelper ) const = delete; + +public: + + // to be overridden by the application + virtual void StartDrag( sal_Int8 nAction, const Point& rPosPixel ); + + DragSourceHelper( vcl::Window* pWindow ); + void dispose(); + virtual ~DragSourceHelper(); +}; + +class VCL_DLLPUBLIC DropTargetHelper +{ +private: + + // nested class to implement the XDropTargetListener interface + class SAL_DLLPRIVATE DropTargetListener final : public cppu::WeakImplHelper< css::datatransfer::dnd::XDropTargetListener > + { + private: + + DropTargetHelper& mrParent; + std::unique_ptr<AcceptDropEvent> mpLastDragOverEvent; + + // XEventListener + virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override; + + // XDropTargetListener + virtual void SAL_CALL drop( const css::datatransfer::dnd::DropTargetDropEvent& dtde ) override; + virtual void SAL_CALL dragEnter( const css::datatransfer::dnd::DropTargetDragEnterEvent& dtdee ) override; + virtual void SAL_CALL dragExit( const css::datatransfer::dnd::DropTargetEvent& dte ) override; + virtual void SAL_CALL dragOver( const css::datatransfer::dnd::DropTargetDragEvent& dtde ) override; + virtual void SAL_CALL dropActionChanged( const css::datatransfer::dnd::DropTargetDragEvent& dtde ) override; + + public: + + DropTargetListener( DropTargetHelper& rDropTargetHelper ); + virtual ~DropTargetListener() override; + }; + + friend class DropTargetHelper::DropTargetListener; + +private: + std::mutex maMutex; + css::uno::Reference< css::datatransfer::dnd::XDropTarget > mxDropTarget; + + css::uno::Reference< css::datatransfer::dnd::XDropTargetListener > mxDropTargetListener; + DataFlavorExVector maFormats; + + DropTargetHelper() = delete; + DropTargetHelper& operator=( const DropTargetHelper& rDropTargetHelper ) = delete; + bool operator==( const DropTargetHelper& rDropTargetHelper ) const = delete; + + void ImplConstruct(); + + // called by our own implementation of XDropTargetListener (DropTargetListener instance) + void ImplBeginDrag( const css::uno::Sequence< css::datatransfer::DataFlavor >& rSupportedDataFlavors ); + void ImplEndDrag(); + +public: + + // to be overridden by the application + virtual sal_Int8 AcceptDrop( const AcceptDropEvent& rEvt ); + virtual sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt ); + + DropTargetHelper( vcl::Window* pWindow ); + DropTargetHelper( const css::uno::Reference< css::datatransfer::dnd::XDropTarget >& rxDropTarget ); + + void dispose(); + virtual ~DropTargetHelper(); + + // typically called by the application in ::AcceptDrop and ::ExecuteDrop and (see above) + bool IsDropFormatSupported(SotClipboardFormatId nFormat) const; + + const DataFlavorExVector& GetDataFlavorExVector() const {return maFormats; } + +}; + +struct TransferDataContainer_Impl; + +class VCL_DLLPUBLIC TransferDataContainer : public TransferableHelper +{ + std::unique_ptr<TransferDataContainer_Impl> pImpl; + + virtual void AddSupportedFormats() override; + virtual bool GetData( const css::datatransfer::DataFlavor& rFlavor, const OUString& rDestDoc ) override; + +public: + + TransferDataContainer(); + virtual ~TransferDataContainer() override; + + void CopyINetBookmark( const INetBookmark& rBkmk ); + void CopyString( const OUString& rStr ); + void CopyString( SotClipboardFormatId nFmt, const OUString& rStr ); + + void CopyByteString( SotClipboardFormatId nFormatId, const OString& rStr ); + void CopyAnyData( SotClipboardFormatId nFormatId, const char* pData, sal_uLong nLen ); + + bool HasAnyData() const; + + using TransferableHelper::StartDrag; + void StartDrag( vcl::Window* pWindow, sal_Int8 nDragSourceActions, + const Link<sal_Int8,void>& rCallback ); + virtual void DragFinished( sal_Int8 nDropAction ) override; +}; + +css::uno::Reference<css::datatransfer::clipboard::XClipboard> VCL_DLLPUBLIC GetSystemClipboard(); +css::uno::Reference<css::datatransfer::clipboard::XClipboard> VCL_DLLPUBLIC GetSystemPrimarySelection(); + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/txtattr.hxx b/include/vcl/txtattr.hxx new file mode 100644 index 000000000..186fbe1ad --- /dev/null +++ b/include/vcl/txtattr.hxx @@ -0,0 +1,189 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_TXTATTR_HXX +#define INCLUDED_VCL_TXTATTR_HXX + +#include <tools/color.hxx> +#include <tools/debug.hxx> +#include <tools/fontenum.hxx> +#include <vcl/dllapi.h> +#include <memory> + +namespace vcl { class Font; } + +#define TEXTATTR_FONTCOLOR 1 +#define TEXTATTR_FONTWEIGHT 3 + +#define TEXTATTR_USER_START 1000 //start id for user defined text attributes +#define TEXTATTR_PROTECTED 4 + + +class VCL_DLLPUBLIC TextAttrib +{ +private: + sal_uInt16 const mnWhich; + +protected: + TextAttrib( sal_uInt16 nWhich ) : mnWhich(nWhich) {} + TextAttrib( const TextAttrib& ) = default; + +public: + + virtual ~TextAttrib(); + + sal_uInt16 Which() const { return mnWhich; } + virtual void SetFont( vcl::Font& rFont ) const = 0; + virtual std::unique_ptr<TextAttrib> Clone() const = 0; + + virtual bool operator==( const TextAttrib& rAttr ) const = 0; + bool operator!=( const TextAttrib& rAttr ) const + { return !(*this == rAttr ); } +}; + + +class VCL_DLLPUBLIC TextAttribFontColor final : public TextAttrib +{ +private: + Color maColor; + +public: + TextAttribFontColor( const Color& rColor ); + + const Color& GetColor() const { return maColor; } + + virtual void SetFont( vcl::Font& rFont ) const override; + virtual std::unique_ptr<TextAttrib> Clone() const override; + virtual bool operator==( const TextAttrib& rAttr ) const override; + +}; + +class VCL_DLLPUBLIC TextAttribFontWeight final : public TextAttrib +{ +private: + FontWeight meWeight; + +public: + TextAttribFontWeight( FontWeight eWeight ); + + virtual void SetFont( vcl::Font& rFont ) const override; + virtual std::unique_ptr<TextAttrib> Clone() const override; + virtual bool operator==( const TextAttrib& rAttr ) const override; + + FontWeight getFontWeight() const { return meWeight; } +}; + +class TextAttribProtect final : public TextAttrib +{ +public: + TextAttribProtect(); + + virtual void SetFont( vcl::Font& rFont ) const override; + virtual std::unique_ptr<TextAttrib> Clone() const override; + virtual bool operator==( const TextAttrib& rAttr ) const override; + +}; + + +class TextCharAttrib +{ +private: + std::unique_ptr<TextAttrib> + mpAttr; + sal_Int32 mnStart; + sal_Int32 mnEnd; + +public: + TextCharAttrib( const TextAttrib& rAttr, sal_Int32 nStart, sal_Int32 nEnd ); + TextCharAttrib( const TextCharAttrib& rTextCharAttrib ); + + const TextAttrib& GetAttr() const { return *mpAttr; } + + sal_uInt16 Which() const { return mpAttr->Which(); } + + sal_Int32 GetStart() const { return mnStart; } + void SetStart(sal_Int32 n) { mnStart = n; } + + sal_Int32 GetEnd() const { return mnEnd; } + void SetEnd(sal_Int32 n) { mnEnd = n; } + + inline sal_Int32 GetLen() const; + + inline void MoveForward( sal_Int32 nDiff ); + inline void MoveBackward( sal_Int32 nDiff ); + + inline void Expand( sal_Int32 nDiff ); + inline void Collaps( sal_Int32 nDiff ); + + inline bool IsIn( sal_Int32 nIndex ) const; + inline bool IsInside( sal_Int32 nIndex ) const; + inline bool IsEmpty() const; + +}; + +inline sal_Int32 TextCharAttrib::GetLen() const +{ + DBG_ASSERT( mnEnd >= mnStart, "TextCharAttrib: nEnd < nStart!" ); + return mnEnd-mnStart; +} + +inline void TextCharAttrib::MoveForward( sal_Int32 nDiff ) +{ + DBG_ASSERT( nDiff <= SAL_MAX_INT32-mnEnd, "TextCharAttrib: MoveForward?!" ); + mnStart = mnStart + nDiff; + mnEnd = mnEnd + nDiff; +} + +inline void TextCharAttrib::MoveBackward( sal_Int32 nDiff ) +{ + DBG_ASSERT( mnStart >= nDiff, "TextCharAttrib: MoveBackward?!" ); + mnStart = mnStart - nDiff; + mnEnd = mnEnd - nDiff; +} + +inline void TextCharAttrib::Expand( sal_Int32 nDiff ) +{ + DBG_ASSERT( nDiff <= SAL_MAX_INT32-mnEnd, "TextCharAttrib: Expand?!" ); + mnEnd = mnEnd + nDiff; +} + +inline void TextCharAttrib::Collaps( sal_Int32 nDiff ) +{ + DBG_ASSERT( mnEnd-mnStart >= nDiff, "TextCharAttrib: Collaps?!" ); + mnEnd = mnEnd - nDiff; +} + +inline bool TextCharAttrib::IsIn( sal_Int32 nIndex ) const +{ + return ( ( mnStart <= nIndex ) && ( mnEnd >= nIndex ) ); +} + +inline bool TextCharAttrib::IsInside( sal_Int32 nIndex ) const +{ + return ( ( mnStart < nIndex ) && ( mnEnd > nIndex ) ); +} + +inline bool TextCharAttrib::IsEmpty() const +{ + return mnStart == mnEnd; +} + +#endif // INCLUDED_VCL_TXTATTR_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/uitest/eventdescription.hxx b/include/vcl/uitest/eventdescription.hxx new file mode 100644 index 000000000..47bf9e117 --- /dev/null +++ b/include/vcl/uitest/eventdescription.hxx @@ -0,0 +1,24 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_UITEST_EVENTDESCRIPTION_HXX +#define INCLUDED_VCL_UITEST_EVENTDESCRIPTION_HXX + +#include <rtl/ustring.hxx> +#include <map> + +struct EventDescription +{ + OUString aKeyWord, aAction, aID, aParent; + std::map<OUString, OUString> aParameters; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/uitest/factory.hxx b/include/vcl/uitest/factory.hxx new file mode 100644 index 000000000..e51427876 --- /dev/null +++ b/include/vcl/uitest/factory.hxx @@ -0,0 +1,27 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_UITEST_FACTORY_HXX +#define INCLUDED_VCL_UITEST_FACTORY_HXX + +#include <memory> +#include <functional> + +namespace vcl +{ +class Window; +} + +class UIObject; + +typedef std::function<std::unique_ptr<UIObject>(vcl::Window*)> FactoryFunction; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/uitest/formattedfielduiobject.hxx b/include/vcl/uitest/formattedfielduiobject.hxx new file mode 100644 index 000000000..0bbc95c75 --- /dev/null +++ b/include/vcl/uitest/formattedfielduiobject.hxx @@ -0,0 +1,37 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_UITEST_FORMATTEDFIELDUIOBJECT_HXX +#define INCLUDED_VCL_UITEST_FORMATTEDFIELDUIOBJECT_HXX + +#include <vcl/uitest/uiobject.hxx> + +class FormattedField; + +class FormattedFieldUIObject final : public SpinFieldUIObject +{ + VclPtr<FormattedField> mxFormattedField; + +public: + FormattedFieldUIObject(const VclPtr<FormattedField>& xEdit); + virtual ~FormattedFieldUIObject() override; + + virtual void execute(const OUString& rAction, const StringMap& rParameters) override; + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + +private: + virtual OUString get_name() const override; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/uitest/logger.hxx b/include/vcl/uitest/logger.hxx new file mode 100644 index 000000000..c810b7eb7 --- /dev/null +++ b/include/vcl/uitest/logger.hxx @@ -0,0 +1,68 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_UITEST_LOGGER_HXX +#define INCLUDED_VCL_UITEST_LOGGER_HXX + +#include <sal/config.h> + +#include <string_view> + +#include <vcl/dllapi.h> + +#include <tools/stream.hxx> +#include <vcl/vclevent.hxx> + +namespace com::sun::star::beans +{ +struct PropertyValue; +} +namespace com::sun::star::uno +{ +template <class E> class Sequence; +} +struct EventDescription; +class Control; +class KeyEvent; + +class UITEST_DLLPUBLIC UITestLogger +{ +private: + SvFileStream maStream; + + bool mbValid; + + OUString app_name; + +public: + UITestLogger(); + + void logCommand(std::u16string_view rAction, + const css::uno::Sequence<css::beans::PropertyValue>& rArgs); + + void logAction(VclPtr<Control> const& xUIElement, VclEventId nEvent); + + void logAction(vcl::Window* const& xUIWin, VclEventId nEvent); + + void log(std::u16string_view rString); + + void logKeyInput(VclPtr<vcl::Window> const& xUIElement, const KeyEvent& rEvent); + + void logEvent(const EventDescription& rDescription); + + static UITestLogger& getInstance(); + + void setAppName(OUString name) { app_name = name; } + + const OUString& getAppName() const { return app_name; } +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/uitest/metricfielduiobject.hxx b/include/vcl/uitest/metricfielduiobject.hxx new file mode 100644 index 000000000..f45da7723 --- /dev/null +++ b/include/vcl/uitest/metricfielduiobject.hxx @@ -0,0 +1,37 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_UITEST_METRICFIELDUIOBJECT_HXX +#define INCLUDED_VCL_UITEST_METRICFIELDUIOBJECT_HXX + +#include <vcl/uitest/uiobject.hxx> + +class MetricField; + +class MetricFieldUIObject final : public SpinFieldUIObject +{ + VclPtr<MetricField> mxMetricField; + +public: + MetricFieldUIObject(const VclPtr<MetricField>& xEdit); + virtual ~MetricFieldUIObject() override; + + virtual void execute(const OUString& rAction, const StringMap& rParameters) override; + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + +private: + virtual OUString get_name() const override; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/uitest/uiobject.hxx b/include/vcl/uitest/uiobject.hxx new file mode 100644 index 000000000..c9a932ec6 --- /dev/null +++ b/include/vcl/uitest/uiobject.hxx @@ -0,0 +1,589 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_UITEST_UIOBJECT_HXX +#define INCLUDED_VCL_UITEST_UIOBJECT_HXX + +#include <rtl/ustring.hxx> +#include <map> +#include <memory> + +#include <vcl/vclevent.hxx> +#include <vcl/vclptr.hxx> +#include <vcl/dllapi.h> +#include <vcl/window.hxx> + +#include <set> + +class Button; +class CheckBox; +class ComboBox; +class Dialog; +class Edit; +class IconView; +class ListBox; +class RadioButton; +class TabControl; +class TabPage; +class SvTreeListBox; +class SvTreeListEntry; +class SpinButton; +class SpinField; +class VerticalTabControl; +class VclExpander; +class VclDrawingArea; +class VclMultiLineEdit; +class MenuButton; +class ToolBox; +namespace vcl { class Window; } +namespace weld { class CustomWidgetController; } + +typedef std::map<OUString, OUString> StringMap; + +/** + * This class wraps a UI object like vcl::Window and provides + * an interface for the UI testing. + * + * This class should only have virtual methods. + */ +class UITEST_DLLPUBLIC UIObject +{ + UIObject(UIObject const &) = delete; + UIObject& operator =(UIObject const &) = delete; + +public: + UIObject() = default; + + virtual ~UIObject(); + + /** + * Returns the state of the wrapped UI object as a + * string key value map. + */ + virtual StringMap get_state(); + + /** + * Executes an action on the wrapped UI object, + * possibly with some additional parameters + */ + virtual void execute(const OUString& rAction, + const StringMap& rParameters); + + /** + * Returns the type of the UIObject. Additional information might + * be available through UIObject::get_state(). + */ + virtual OUString get_type() const; + + /** + * Returns the child of the current UIObject with the corresponding id. + * If no object with that id is being found returns a nullptr. + * + */ + virtual std::unique_ptr<UIObject> get_child(const OUString& rID); + + /** + * Returns a set containing all descendants of the object. + */ + virtual std::set<OUString> get_children() const; + + /** + * Currently an internal method to dump the state of the current UIObject as represented by get_state(). + * + * This method should not be exposed to the outside world. + * + */ + virtual OUString dumpState() const; + + /** + * Currently an internal method to dump the parent-child relationship starting from the current top focus window. + * + * This method should not be exposed to the outside world. + * + */ + virtual OUString dumpHierarchy() const; + + /** + * Gets the corresponding Action string for the event. + */ + virtual OUString get_action(VclEventId nEvent) const; +}; + +class UITEST_DLLPUBLIC WindowUIObject : public UIObject +{ + VclPtr<vcl::Window> mxWindow; + +public: + + WindowUIObject(const VclPtr<vcl::Window>& xWindow); + + virtual StringMap get_state() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + virtual OUString get_type() const override; + + virtual std::unique_ptr<UIObject> get_child(const OUString& rID) override; + + std::unique_ptr<UIObject> get_visible_child(const OUString& rID); + + virtual std::set<OUString> get_children() const override; + + virtual OUString dumpState() const override; + + virtual OUString dumpHierarchy() const override; + + virtual OUString get_action(VclEventId nEvent) const override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + +protected: + + virtual OUString get_name() const; + +}; + +// TODO: moggi: what about push buttons? +class ButtonUIObject final : public WindowUIObject +{ + VclPtr<Button> mxButton; +public: + + ButtonUIObject(const VclPtr<Button>& xButton); + virtual ~ButtonUIObject() override; + + virtual StringMap get_state() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + + virtual OUString get_action(VclEventId nEvent) const override; + +private: + + virtual OUString get_name() const override; +}; + +class DialogUIObject final : public WindowUIObject +{ + VclPtr<Dialog> mxDialog; + +public: + + DialogUIObject(const VclPtr<Dialog>& xDialog); + virtual ~DialogUIObject() override; + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + +private: + + virtual OUString get_name() const override; +}; + +class EditUIObject : public WindowUIObject +{ + VclPtr<Edit> mxEdit; + +public: + + EditUIObject(const VclPtr<Edit>& xEdit); + virtual ~EditUIObject() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + + virtual OUString get_action(VclEventId nEvent) const override; + +protected: + + virtual OUString get_name() const override; +}; + +class MultiLineEditUIObject final : public WindowUIObject +{ + VclPtr<VclMultiLineEdit> mxEdit; + +public: + + MultiLineEditUIObject(const VclPtr<VclMultiLineEdit>& xEdit); + virtual ~MultiLineEditUIObject() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + +private: + + virtual OUString get_name() const override; +}; + +class ExpanderUIObject : public WindowUIObject +{ + VclPtr<VclExpander> mxExpander; + +public: + + ExpanderUIObject(const VclPtr<VclExpander>& xExpander); + virtual ~ExpanderUIObject() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); +private: + + virtual OUString get_name() const override; +}; + + +// TODO: moggi: maybe let it inherit from the button case +class CheckBoxUIObject final : public WindowUIObject +{ +private: + VclPtr<CheckBox> mxCheckBox; + +public: + CheckBoxUIObject(const VclPtr<CheckBox>& xCheckbox); + virtual ~CheckBoxUIObject() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + + virtual OUString get_action(VclEventId nEvent) const override; + +private: + + virtual OUString get_name() const override; +}; + +class RadioButtonUIObject final : public WindowUIObject +{ +private: + VclPtr<RadioButton> mxRadioButton; + +public: + RadioButtonUIObject(const VclPtr<RadioButton>& xCheckbox); + virtual ~RadioButtonUIObject() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + + virtual OUString get_action(VclEventId nEvent) const override; + +private: + + virtual OUString get_name() const override; +}; + +class TabPageUIObject final : public WindowUIObject +{ +private: + VclPtr<TabPage> mxTabPage; +public: + TabPageUIObject(const VclPtr<TabPage>& xTabPage); + virtual ~TabPageUIObject() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + +private: + + virtual OUString get_name() const override; +}; + +class ListBoxUIObject final : public WindowUIObject +{ +private: + VclPtr<ListBox> mxListBox; + +public: + + ListBoxUIObject(const VclPtr<ListBox>& xListBox); + virtual ~ListBoxUIObject() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + + virtual OUString get_action(VclEventId nEvent) const override; + +private: + + virtual OUString get_name() const override; +}; + +// TODO: moggi: should it inherit from EditUIObject? +class ComboBoxUIObject final : public WindowUIObject +{ +private: + VclPtr<ComboBox> mxComboBox; + +public: + + ComboBoxUIObject(const VclPtr<ComboBox>& xListBox); + virtual ~ComboBoxUIObject() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + + virtual OUString get_action(VclEventId nEvent) const override; + +private: + + virtual OUString get_name() const override; +}; + +class SpinUIObject final : public WindowUIObject +{ +private: + VclPtr<SpinButton> mxSpinButton; + +public: + + SpinUIObject(const VclPtr<SpinButton>& xSpinButton); + virtual ~SpinUIObject() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + + virtual OUString get_action(VclEventId nEvent) const override; + +private: + + virtual OUString get_name() const override; +}; + +class SpinFieldUIObject : public EditUIObject +{ + VclPtr<SpinField> mxSpinField; + +public: + + SpinFieldUIObject(const VclPtr<SpinField>& xEdit); + virtual ~SpinFieldUIObject() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + + virtual OUString get_action(VclEventId nEvent) const override; + +private: + + virtual OUString get_name() const override; +}; + +class TabControlUIObject final : public WindowUIObject +{ +private: + VclPtr<TabControl> mxTabControl; + +public: + + TabControlUIObject(const VclPtr<TabControl>& mxTabControl); + virtual ~TabControlUIObject() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + + virtual OUString get_action(VclEventId nEvent) const override; + +private: + + virtual OUString get_name() const override; +}; + +class VerticalTabControlUIObject final : public WindowUIObject +{ +private: + VclPtr<VerticalTabControl> mxTabControl; + +public: + + VerticalTabControlUIObject(const VclPtr<VerticalTabControl>& mxTabControl); + virtual ~VerticalTabControlUIObject() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + +private: + + virtual OUString get_name() const override; +}; + +class TreeListUIObject : public WindowUIObject +{ +public: + TreeListUIObject(const VclPtr<SvTreeListBox>& xTreeList); + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + virtual std::unique_ptr<UIObject> get_child(const OUString& rID) override; + + virtual std::set<OUString> get_children() const override; + +protected: + + virtual OUString get_name() const override; + + VclPtr<SvTreeListBox> mxTreeList; +}; + +class TreeListEntryUIObject final : public UIObject +{ +public: + + TreeListEntryUIObject(const VclPtr<SvTreeListBox>& xTreeList, SvTreeListEntry* pEntry); + + virtual StringMap get_state() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + virtual std::unique_ptr<UIObject> get_child(const OUString& rID) override; + + virtual std::set<OUString> get_children() const override; + + virtual OUString get_type() const override; + +private: + + VclPtr<SvTreeListBox> mxTreeList; + + SvTreeListEntry* const mpEntry; +}; + +class IconViewUIObject final : public TreeListUIObject +{ +public: + IconViewUIObject(const VclPtr<SvTreeListBox>& xIconView); + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + +private: + + virtual OUString get_name() const override; +}; + +class ToolBoxUIObject final : public WindowUIObject +{ +private: + VclPtr<ToolBox> mxToolBox; + +public: + + ToolBoxUIObject(const VclPtr<ToolBox>& mxToolBox); + virtual ~ToolBoxUIObject() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + virtual StringMap get_state() override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + + virtual OUString get_action(VclEventId nEvent) const override; + +private: + + virtual OUString get_name() const override; +}; + +class MenuButtonUIObject final : public WindowUIObject +{ + VclPtr<MenuButton> mxMenuButton; + +public: + + MenuButtonUIObject(const VclPtr<MenuButton>& xMenuButton); + virtual ~MenuButtonUIObject() override; + + virtual StringMap get_state() override; + + virtual void execute(const OUString& rAction, + const StringMap& rParameters) override; + + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); + +private: + + virtual OUString get_name() const override; +}; + +class UITEST_DLLPUBLIC DrawingAreaUIObject : public WindowUIObject +{ +private: + VclPtr<VclDrawingArea> mxDrawingArea; +protected: + weld::CustomWidgetController* mpController; +public: + DrawingAreaUIObject(const VclPtr<vcl::Window>& rDrawingArea); + virtual ~DrawingAreaUIObject() override; + virtual void execute(const OUString& rAction, const StringMap& rParameters) override; + static std::unique_ptr<UIObject> create(vcl::Window* pWindow); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/uitest/uitest.hxx b/include/vcl/uitest/uitest.hxx new file mode 100644 index 000000000..53bdded59 --- /dev/null +++ b/include/vcl/uitest/uitest.hxx @@ -0,0 +1,40 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_UITEST_UITEST_HXX +#define INCLUDED_VCL_UITEST_UITEST_HXX + +#include <rtl/ustring.hxx> + +#include <memory> + +namespace com::sun::star::beans { struct PropertyValue; } +namespace com::sun::star::uno { template <typename > class Sequence; } + +class UIObject; + +class UITest +{ +public: + + static bool executeCommand(const OUString& rCommand); + + static bool executeCommandWithParameters(const OUString& rCommand, + const css::uno::Sequence< css::beans::PropertyValue >& rArgs); + + static bool executeDialog(const OUString& rCommand); + + static std::unique_ptr<UIObject> getFocusTopWindow(); + + static std::unique_ptr<UIObject> getFloatWindow(); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/unohelp.hxx b/include/vcl/unohelp.hxx new file mode 100644 index 000000000..c7b9dcc06 --- /dev/null +++ b/include/vcl/unohelp.hxx @@ -0,0 +1,50 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_UNOHELP_HXX +#define INCLUDED_VCL_UNOHELP_HXX + +#include <com/sun/star/uno/Reference.h> +#include <com/sun/star/awt/FontSlant.hpp> +#include <tools/fontenum.hxx> +#include <vcl/dllapi.h> + +namespace com::sun::star::i18n { + class XBreakIterator; + class XCharacterClassification; +} +namespace com::sun::star::accessibility { + struct AccessibleEventObject; +} + +namespace vcl::unohelper +{ +VCL_DLLPUBLIC css::uno::Reference < css::i18n::XBreakIterator > CreateBreakIterator(); +css::uno::Reference < css::i18n::XCharacterClassification> CreateCharacterClassification(); +VCL_DLLPUBLIC float ConvertFontWidth( FontWidth eWidth ); +VCL_DLLPUBLIC FontWidth ConvertFontWidth( float f ); +VCL_DLLPUBLIC float ConvertFontWeight( FontWeight eWeight ); +VCL_DLLPUBLIC FontWeight ConvertFontWeight( float f ); +VCL_DLLPUBLIC css::awt::FontSlant ConvertFontSlant( FontItalic eWeight ); +VCL_DLLPUBLIC FontItalic ConvertFontSlant( css::awt::FontSlant ); +} // namespace vcl::unohelper + +#endif // INCLUDED_VCL_UNOHELP_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/unohelp2.hxx b/include/vcl/unohelp2.hxx new file mode 100644 index 000000000..978c31ecf --- /dev/null +++ b/include/vcl/unohelp2.hxx @@ -0,0 +1,68 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_UNOHELP2_HXX +#define INCLUDED_VCL_UNOHELP2_HXX + +#include <com/sun/star/datatransfer/XTransferable.hpp> +#include <cppuhelper/weak.hxx> +#include <rtl/ustring.hxx> +#include <vcl/dllapi.h> +#include <vcl/IDialogRenderable.hxx> + +namespace com::sun::star::datatransfer::clipboard { + class XClipboard; +} + +namespace vcl::unohelper { + + class VCL_DLLPUBLIC TextDataObject final : + public css::datatransfer::XTransferable, + public ::cppu::OWeakObject + { + private: + OUString maText; + + public: + TextDataObject( const OUString& rText ); + virtual ~TextDataObject() override; + + // css::uno::XInterface + css::uno::Any SAL_CALL queryInterface( const css::uno::Type & rType ) override; + void SAL_CALL acquire() noexcept override { OWeakObject::acquire(); } + void SAL_CALL release() noexcept override { OWeakObject::release(); } + + // css::datatransfer::XTransferable + css::uno::Any SAL_CALL getTransferData( const css::datatransfer::DataFlavor& aFlavor ) override; + css::uno::Sequence< css::datatransfer::DataFlavor > SAL_CALL getTransferDataFlavors( ) override; + sal_Bool SAL_CALL isDataFlavorSupported( const css::datatransfer::DataFlavor& aFlavor ) override; + + /// copies a given string to a given clipboard + static void CopyStringTo( + const OUString& rContent, + const css::uno::Reference< css::datatransfer::clipboard::XClipboard >& rxClipboard, + const vcl::ILibreOfficeKitNotifier* pNotifier = nullptr + ); + }; + +} // namespace vcl::unohelper + +#endif // INCLUDED_VCL_UNOHELP2_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/vclenum.hxx b/include/vcl/vclenum.hxx new file mode 100644 index 000000000..6e0359fa2 --- /dev/null +++ b/include/vcl/vclenum.hxx @@ -0,0 +1,418 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_VCLENUM_HXX +#define INCLUDED_VCL_VCLENUM_HXX + +#include <sal/types.h> +#include <o3tl/typed_flags_set.hxx> + +enum class SelectionMode { NONE, Single, Range, Multiple }; + +enum class TimeFieldFormat : sal_Int32 { F_NONE, F_SEC, F_SEC_CS }; + +enum class MenuItemType { DONTKNOW, STRING, IMAGE, STRINGIMAGE, SEPARATOR }; + +enum class MenuItemBits : sal_Int16 +{ + NONE = 0x0000, + CHECKABLE = 0x0001, + RADIOCHECK = 0x0002, + AUTOCHECK = 0x0004, + HELP = 0x0010, + POPUPSELECT = 0x0020, + // These have been said to be a preliminary (sic) solution since 2007 + NOSELECT = 0x0040, + ICON = 0x0080, + TEXT = 0x0100, +}; +namespace o3tl +{ + template<> struct typed_flags<MenuItemBits> : is_typed_flags<MenuItemBits, 0x1f7> {}; +} + +enum class ToolBoxItemBits +{ + NONE = 0x0000, + CHECKABLE = 0x0001, + RADIOCHECK = 0x0002, + AUTOCHECK = 0x0004, + LEFT = 0x0008, + AUTOSIZE = 0x0010, + DROPDOWN = 0x0020, + REPEAT = 0x0040, + DROPDOWNONLY = 0x00a0, // 0x0080 | DROPDOWN + TEXT_ONLY = 0x0100, + ICON_ONLY = 0x0200 +}; +namespace o3tl +{ + template<> struct typed_flags<ToolBoxItemBits> : is_typed_flags<ToolBoxItemBits, 0x3ff> {}; +} + +enum class ToolBoxItemType { DONTKNOW, BUTTON, SPACE, SEPARATOR, BREAK }; + +enum class ButtonType { SYMBOLONLY, TEXT, SYMBOLTEXT }; + +enum class SymbolType : sal_uInt16 +{ + DONTKNOW = 0, + IMAGE = 1, + ARROW_UP = 2, + ARROW_DOWN = 3, + ARROW_LEFT = 4, + ARROW_RIGHT = 5, + SPIN_UP = 6, + SPIN_DOWN = 7, + SPIN_LEFT = 8, + SPIN_RIGHT = 9, + FIRST = 10, + LAST = 11, + PREV = 12, + NEXT = 13, + PAGEUP = 14, + PAGEDOWN = 15, + PLAY = 16, + STOP = 19, + CLOSE = 25, + CHECKMARK = 28, + RADIOCHECKMARK = 29, + FLOAT = 31, + DOCK = 32, + HIDE = 33, + HELP = 34, + PLUS = 35, + MENU = SymbolType::SPIN_DOWN +}; + + +// Border styles for SetBorder() +enum class WindowBorderStyle : sal_Int16 +{ + NONE = 0x0000, + NORMAL = 0x0001, + MONO = 0x0002, + MENU = 0x0010, + NWF = 0x0020, + NOBORDER = 0x1000, + REMOVEBORDER = 0x2000 +}; +namespace o3tl +{ + template<> struct typed_flags<WindowBorderStyle> : is_typed_flags<WindowBorderStyle, 0x3033> {}; +} + +enum class WindowStateMask { + NONE = 0x0000, + X = 0x0001, + Y = 0x0002, + Width = 0x0004, + Height = 0x0008, + State = 0x0010, + Minimized = 0x0020, + MaximizedX = 0x0100, + MaximizedY = 0x0200, + MaximizedWidth = 0x0400, + MaximizedHeight = 0x0800, + Pos = X | Y, + Size = Width | Height, + All = X | Y | Width | Height | MaximizedX | MaximizedY | MaximizedWidth | MaximizedHeight | State | Minimized +}; +namespace o3tl +{ + template<> struct typed_flags<WindowStateMask> : is_typed_flags<WindowStateMask, 0x0f3f> {}; +} + +enum class TimeFormat +{ + Hour12, Hour24 +}; + +enum class ExtTimeFieldFormat +{ + /** the first 4 of these are only used by base/dbaccess */ + Short24H, Long24H, + Short12H, Long12H, + ShortDuration, LongDuration +}; + +enum class ExtDateFieldFormat +{ + SystemShort, SystemShortYY, SystemShortYYYY, + SystemLong, + ShortDDMMYY, ShortMMDDYY, ShortYYMMDD, + ShortDDMMYYYY, ShortMMDDYYYY, ShortYYYYMMDD, + ShortYYMMDD_DIN5008, ShortYYYYMMDD_DIN5008, + FORCE_EQUAL_SIZE=SAL_MAX_ENUM +}; + +// this appears to be a direct copy of css::awt::GradientStyle +enum class GradientStyle +{ + Linear = 0, + Axial = 1, + Radial = 2, + Elliptical = 3, + Square = 4, + Rect = 5, + FORCE_EQUAL_SIZE = SAL_MAX_ENUM +}; + +enum class HatchStyle +{ + Single = 0, + Double = 1, + Triple = 2, + FORCE_EQUAL_SIZE = SAL_MAX_ENUM +}; + +enum class LineStyle +{ + NONE = 0, + Solid = 1, + Dash = 2, + FORCE_EQUAL_SIZE = SAL_MAX_ENUM +}; + +typedef sal_uInt32 sal_UCS4; // TODO: this should be moved to rtl + +enum class OutDevSupportType { TransparentRect, B2DDraw }; + +struct ItalicMatrix +{ + double xx, xy, yx, yy; + ItalicMatrix() : xx(1), xy(0), yx(0), yy(1) {} +}; + +inline bool operator ==(const ItalicMatrix& a, const ItalicMatrix& b) +{ + return a.xx == b.xx && a.xy == b.xy && a.yx == b.yx && a.yy == b.yy; +} + +inline bool operator !=(const ItalicMatrix& a, const ItalicMatrix& b) +{ + return !(a == b); +} + +enum class VclAlign +{ + Fill, + Start, + End, + Center +}; + +enum class VclPackType +{ + Start = 0, + End = 1, + LAST = End +}; + +// Return Values from Dialog::Execute +//!!! in case of changes adjust /basic/source/runtime/methods.cxx msgbox + +enum VclResponseType +{ + RET_CANCEL = 0, + RET_OK = 1, + RET_YES = 2, + RET_NO = 3, + RET_RETRY = 4, + RET_IGNORE = 5, + RET_CLOSE = 7, + RET_HELP = 10 +}; + +enum class VclButtonsType +{ + NONE, + Ok, + Close, + Cancel, + YesNo, + OkCancel +}; + +enum class VclMessageType +{ + Info, + Warning, + Question, + Error, + Other +}; + +enum class VclSizeGroupMode +{ + NONE, + Horizontal, + Vertical, + Both +}; + +enum class VclPolicyType +{ + ALWAYS, + AUTOMATIC, + NEVER +}; + +enum class WizardButtonFlags : sal_Int16 +{ + NONE = 0x0000, + NEXT = 0x0001, + PREVIOUS = 0x0002, + FINISH = 0x0004, + CANCEL = 0x0008, + HELP = 0x0010, +}; + +namespace o3tl +{ + template<> struct typed_flags<WizardButtonFlags> : is_typed_flags<WizardButtonFlags, 0x001f> {}; +} + +// small, large, size32 force an exact toolbox size for proper alignment +// DontCare will let the toolbox decide about its size +enum class ToolBoxButtonSize +{ + DontCare, + Small, + Large, + Size32, +}; + +enum class WindowStateState { + NONE = 0x0000, + Normal = 0x0001, + Minimized = 0x0002, + Maximized = 0x0004, + // Rollup is no longer used, but retained because WindowStateState is serialized + // from/to strings describing window state that are stored in a users config + Rollup = 0x0008, + MaximizedHorz = 0x0010, + MaximizedVert = 0x0020, + FullScreen = 0x0040, + SystemMask = 0xffff +}; +namespace o3tl +{ + template<> struct typed_flags<WindowStateState> : is_typed_flags<WindowStateState, 0xffff> {}; +} + +namespace vcl +{ + // The exact sizes of the icons in each size grouping are not necessarily + // the exact size indicated by the name, but the upper limit of their size. + // e.g. many Size26 icons are often 24x24px and only some 26x26px + enum class ImageType + { + Size16, + Size26, + Size32, + Small = Size16, + LAST = Size32, + }; +} + +enum class DrawFrameStyle +{ + NONE = 0x0000, + In = 0x0001, + Out = 0x0002, + Group = 0x0003, + DoubleIn = 0x0004, + DoubleOut = 0x0005, + NWF = 0x0006, +}; + +// Flags for DrawFrame() +enum class DrawFrameFlags +{ + NONE = 0x0000, + Menu = 0x0010, + WindowBorder = 0x0020, + BorderWindowBorder = 0x0040, + Mono = 0x1000, + NoDraw = 0x8000, +}; +namespace o3tl +{ + template<> struct typed_flags<DrawFrameFlags> : is_typed_flags<DrawFrameFlags, 0x9070> {}; +} + +enum class TxtAlign +{ + Left, + Center, + Right +}; + +enum class FloatWinPopupFlags +{ + NONE = 0x000000, + AllowTearOff = 0x000001, + Down = 0x000002, + Up = 0x000004, + Left = 0x000008, + Right = 0x000010, + NoKeyClose = 0x000020, + AllMouseButtonClose = 0x000040, + NoAppFocusClose = 0x000080, + NewLevel = 0x000100, + NoMouseUpClose = 0x000200, + GrabFocus = 0x000400, + NoHorzPlacement = 0x000800, +}; +namespace o3tl +{ + template<> struct typed_flags<FloatWinPopupFlags> : is_typed_flags<FloatWinPopupFlags, 0x0fff> {}; +} + +// Flags for Window::Show() +enum class ShowFlags +{ + NONE = 0x0000, + NoFocusChange = 0x0002, + NoActivate = 0x0004, + ForegroundTask = 0x0008, +}; +namespace o3tl +{ + template<> struct typed_flags<ShowFlags> : is_typed_flags<ShowFlags, 0x000e> {}; +} + +enum class TrackingEventFlags +{ + NONE = 0x0000, + Cancel = 0x0001, + Key = 0x0002, + Focus = 0x0004, + Repeat = 0x0100, + End = 0x1000, +}; +namespace o3tl +{ + template<> struct typed_flags<TrackingEventFlags> : is_typed_flags<TrackingEventFlags, 0x1107> {}; +} + +#endif // INCLUDED_VCL_VCLENUM_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/vclevent.hxx b/include/vcl/vclevent.hxx new file mode 100644 index 000000000..a0a11c6a0 --- /dev/null +++ b/include/vcl/vclevent.hxx @@ -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 . + */ + +#ifndef INCLUDED_VCL_VCLEVENT_HXX +#define INCLUDED_VCL_VCLEVENT_HXX + +#include <vcl/dllapi.h> +#include <vcl/vclptr.hxx> + +class Menu; + +namespace com::sun::star::accessibility { + class XAccessible; +} + +namespace vcl +{ + class Window; +} + +enum class VclEventId +{ + NONE, + ApplicationDataChanged, // pData = DataChangedEvent* + ButtonClick, + CheckboxToggle, + ComboboxDeselect, + ComboboxDoubleClick, + ComboboxItemAdded, // pData = itempos + ComboboxItemRemoved, // pData = itempos, -1=All + ComboboxSelect, + ComboboxSetText, + ControlGetFocus, + ControlLoseFocus, + DropdownClose, + DropdownOpen, + DropdownPreOpen, + DropdownSelect, + EditCaretChanged, + EditModify, + EditSelectionChanged, + ExtTextInput, + EndExtTextInput, + ItemCollapsed, + ItemExpanded, + ListboxDoubleClick, + ListboxFocus, + ListboxItemAdded, // pData = itempos + ListboxItemRemoved, // pData = itempos, -1=All + ListboxScrolled, + ListboxSelect, + ListboxTreeFocus, + ListboxTreeSelect, + MenuAccessibleNameChanged, + MenuActivate, + MenuDeactivate, + MenuDehighlight, + MenuDisable, + MenuEnable, + MenuHide, + MenuHighlight, + MenuInsertItem, + MenuItemChecked, + MenuItemTextChanged, + MenuItemUnchecked, + MenuRemoveItem, + MenuSelect, + MenuShow, + MenuSubmenuActivate, + MenuSubmenuChanged, + MenuSubmenuDeactivate, + ObjectDying, + PushbuttonToggle, + RadiobuttonToggle, + RoadmapItemSelected, + ScrollbarEndScroll, + ScrollbarScroll, + SpinbuttonDown, + SpinbuttonUp, + SpinfieldDown, + SpinfieldFirst, + SpinfieldLast, + SpinfieldUp, + StatusbarAllItemsRemoved, + StatusbarDrawItem, // pData = itemid + StatusbarHideItem, // pData = itemid + StatusbarItemAdded, // pData = itemid + StatusbarItemRemoved, // pData = itemid + StatusbarNameChanged, // pData = itemid + StatusbarShowItem, // pData = itemid + TabbarPageActivated, // pData = pageid + TabbarPageDeactivated, // pData = pageid + TabbarPageInserted, // pData = pageid + TabbarPageMoved, // pData = Pair( pagepos_old, pagepos_new ) + TabbarPageRemoved, // pData = pageid + TabbarPageSelected, // pData = pageid + TabbarPageTextChanged, // pData = pageid + TableRowSelect, + TabpageActivate, // pData = pageid + TabpageDeactivate, // pData = pageid + TabpageInserted, // pData = pageid + TabpagePageTextChanged, // pData = pageid + TabpageRemoved, // pData = pageid + TabpageRemovedAll, + ToolboxActivate, + ToolboxAllItemsChanged, + ToolboxButtonStateChanged, // pData = itempos + ToolboxClick, + ToolboxDeactivate, + ToolboxDoubleClick, + ToolboxFormatChanged, // request new layout + ToolboxHighlight, + ToolboxHighlightOff, // pData = itempos + ToolboxItemAdded, // pData = itempos + ToolboxItemDisabled, // pData = itempos + ToolboxItemEnabled, // pData = itempos + ToolboxItemRemoved, // pData = itempos + ToolboxItemTextChanged, // pData = itempos + ToolboxItemUpdated, + ToolboxItemWindowChanged, + ToolboxSelect, + WindowActivate, + WindowChildDestroyed, // pData = vcl::Window* + WindowClose, + WindowCommand, // pData = CommandEvent* + WindowDataChanged, // pData = DataChangedEvent* + WindowDeactivate, // pData = vcl::Window* = pPrevActiveWindow + WindowDisabled, + WindowDocking, + WindowEnabled, + WindowEndDocking, // pData = EndDockingData + WindowEndPopupMode, // pData = EndPopupModeData + WindowFrameTitleChanged,// pData = OUString* = oldTitle + WindowGetFocus, + WindowHide, + WindowKeyInput, // pData = KeyEvent* + WindowKeyUp, // pData = KeyEvent* + WindowLoseFocus, + WindowMenubarAdded, // pData = pMenuBar + WindowMenubarRemoved, // pData = pMenuBar + WindowMinimize, + WindowMouseButtonDown, // pData = MouseEvent* + WindowMouseButtonUp, // pData = MouseEvent* + WindowMouseMove, // pData = MouseEvent* + WindowMove, + WindowNormalize, + WindowPaint, // pData = Rectangle* + WindowPrepareToggleFloating, // pData = bool + WindowResize, + WindowShow, + WindowStartDocking, // pData = DockingData + WindowToggleFloating, + WindowGestureEvent, +}; + +class VCL_DLLPUBLIC VclSimpleEvent +{ +private: + VclEventId nId; + + VclSimpleEvent(VclSimpleEvent const &) = delete; + VclSimpleEvent& operator =(VclSimpleEvent const &) = delete; + +public: + VclSimpleEvent( VclEventId n ) { nId = n; } + virtual ~VclSimpleEvent() {} + + VclEventId GetId() const { return nId; } +}; + +class VCL_DLLPUBLIC VclWindowEvent final : public VclSimpleEvent +{ +private: + VclPtr<vcl::Window> pWindow; + void* pData; + +public: + VclWindowEvent( vcl::Window* pWin, VclEventId n, void* pDat ); + virtual ~VclWindowEvent() override; + + vcl::Window* GetWindow() const { return pWindow; } + void* GetData() const { return pData; } +}; + +class VCL_DLLPUBLIC VclMenuEvent final : public VclSimpleEvent +{ +private: + VclPtr<Menu> pMenu; + sal_uInt16 mnPos; + + VclMenuEvent(VclMenuEvent const &) = delete; + VclMenuEvent& operator =(VclMenuEvent const &) = delete; + +public: + VclMenuEvent( Menu* pM, VclEventId n, sal_uInt16 nPos ); + virtual ~VclMenuEvent() override; + + Menu* GetMenu() const; + sal_uInt16 GetItemPos() const { return mnPos; } +}; + +#endif // INCLUDED_VCL_VCLEVENT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/vcllayout.hxx b/include/vcl/vcllayout.hxx new file mode 100644 index 000000000..0fa25116e --- /dev/null +++ b/include/vcl/vcllayout.hxx @@ -0,0 +1,125 @@ +/* -*- 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 . + */ + +#pragma once + +#include <basegfx/polygon/b2dpolypolygon.hxx> +#include <tools/gen.hxx> +#include <tools/degree.hxx> + +#include <vcl/devicecoordinate.hxx> +#include <vcl/glyphitem.hxx> +#include <vcl/dllapi.h> + +class LogicalFontInstance; +namespace vcl::text { class ImplLayoutArgs; } +namespace vcl::font { class PhysicalFontFace; } +class SalGraphics; +class GlyphItem; + +// all positions/widths are in font units +// one exception: drawposition is in pixel units + +// Unfortunately there is little documentation to help implementors of +// new classes derived from SalLayout ("layout engines"), and the code +// and data structures are far from obvious. + +// For instance, I *think* the important virtual functions in the +// layout engines are called in this order: + +// * InitFont() +// * LayoutText() +// * AdjustLayout(), any number of times (but presumably +// usually not at all or just once) +// * Optionally, DrawText() + +// Functions that just return information like GetTexWidth() and +// FillDXArray() are called after LayoutText() and before DrawText(). + +// Another important questions is which parts of an ImplLayoutArgs can +// be changed by callers between LayoutText() and AdjustLayout() +// calls. It probably makes sense only if one assumes that the "string +// related inputs" part are not changed after LayoutText(). + +// But why use the same ImplLayoutArgs structure as parameter for both +// LayoutText() and AdjustLayout() in the first place? And why +// duplicate some of the fields in both SalLayout and ImplLayoutArgs +// (mnMinCharPos, mnEndCharPos, mnLayoutFlags==mnFlags, +// mnOrientation)? Lost in history... + +class VCL_DLLPUBLIC SalLayout +{ +public: + virtual ~SalLayout(); + // used by upper layers + DevicePoint& DrawBase() { return maDrawBase; } + const DevicePoint& DrawBase() const { return maDrawBase; } + Point& DrawOffset() { return maDrawOffset; } + const Point& DrawOffset() const { return maDrawOffset; } + DevicePoint GetDrawPosition( const DevicePoint& rRelative = DevicePoint(0,0) ) const; + + virtual bool LayoutText( vcl::text::ImplLayoutArgs&, const SalLayoutGlyphsImpl* ) = 0; // first step of layouting + virtual void AdjustLayout( vcl::text::ImplLayoutArgs& ); // adjusting after fallback etc. + virtual void InitFont() const {} + virtual void DrawText( SalGraphics& ) const = 0; + + Degree10 GetOrientation() const { return mnOrientation; } + + void SetTextRenderModeForResolutionIndependentLayout(bool bTextRenderModeForResolutionIndependentLayout) + { + mbTextRenderModeForResolutionIndependentLayout = bTextRenderModeForResolutionIndependentLayout; + } + + // methods using string indexing + virtual sal_Int32 GetTextBreak(DeviceCoordinate nMaxWidth, DeviceCoordinate nCharExtra, int nFactor) const = 0; + virtual DeviceCoordinate FillDXArray( std::vector<DeviceCoordinate>* pDXArray ) const = 0; + virtual DeviceCoordinate GetTextWidth() const { return FillDXArray( nullptr ); } + virtual void GetCaretPositions( int nArraySize, sal_Int32* pCaretXArray ) const = 0; + virtual bool IsKashidaPosValid ( int /*nCharPos*/ ) const { return true; } // i60594 + + // methods using glyph indexing + virtual bool GetNextGlyph(const GlyphItem** pGlyph, DevicePoint& rPos, int& nStart, + const LogicalFontInstance** ppGlyphFont = nullptr, + const vcl::font::PhysicalFontFace** pFallbackFont = nullptr) const = 0; + virtual bool GetOutline(basegfx::B2DPolyPolygonVector&) const; + bool GetBoundRect(tools::Rectangle&) const; + + virtual SalLayoutGlyphs GetGlyphs() const; + +protected: + // used by layout engines + SalLayout(); + +private: + SalLayout(const SalLayout&) = delete; + SalLayout& operator=(const SalLayout&) = delete; + +protected: + int mnMinCharPos; + int mnEndCharPos; + + Degree10 mnOrientation; + + mutable Point maDrawOffset; + DevicePoint maDrawBase; + + bool mbTextRenderModeForResolutionIndependentLayout; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/vclmain.hxx b/include/vcl/vclmain.hxx new file mode 100644 index 000000000..6572d6d30 --- /dev/null +++ b/include/vcl/vclmain.hxx @@ -0,0 +1,33 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_VCLMAIN_HXX +#define INCLUDED_VCL_VCLMAIN_HXX + +#include <sal/config.h> + +#ifdef DBG_UTIL +#include <vcl/dllapi.h> +#endif + +namespace vclmain +{ +// Function called from vclmain's implementation of main, needs to be +// implemented by the application and needs to instantiate a (static, derived) +// instance of Application (where the Application constructor takes care to link +// that instance to ImplSVData.mpApp): +void createApplication(); +#ifdef DBG_UTIL +VCL_DLLPUBLIC bool isAlive(); +#endif +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/vclptr.hxx b/include/vcl/vclptr.hxx new file mode 100644 index 000000000..3775034ff --- /dev/null +++ b/include/vcl/vclptr.hxx @@ -0,0 +1,442 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_PTR_HXX +#define INCLUDED_VCL_PTR_HXX + +#include <sal/config.h> + +#include <rtl/ref.hxx> + +#include <utility> +#include <type_traits> + +#ifdef DBG_UTIL +#ifndef _WIN32 +#include <vcl/vclmain.hxx> +#endif +#endif + +class VclReferenceBase; + +namespace vcl::detail { + +template<typename> +constexpr bool isIncompleteOrDerivedFromVclReferenceBase(...) { return true; } + +template<typename T> constexpr bool isIncompleteOrDerivedFromVclReferenceBase( + int (*)[sizeof(T)]) +{ return std::is_base_of<VclReferenceBase, T>::value; } + +} // namespace vcl::detail + +/** + * A thin wrapper around rtl::Reference to implement the acquire and dispose semantics we want for references to vcl::Window subclasses. + * + * For more details on the design please see vcl/README.lifecycle + * + * @param reference_type must be a subclass of vcl::Window + */ +template <class reference_type> +class VclPtr +{ + static_assert( + vcl::detail::isIncompleteOrDerivedFromVclReferenceBase<reference_type>( + nullptr), + "template argument type must be derived from VclReferenceBase"); + + ::rtl::Reference<reference_type> m_rInnerRef; + +public: + /** Constructor... + */ + VclPtr() + : m_rInnerRef() + {} + + /** Constructor... + */ + VclPtr (reference_type * pBody) + : m_rInnerRef(pBody) + {} + + /** Constructor... that doesn't take a ref. + */ + VclPtr (reference_type * pBody, __sal_NoAcquire) + : m_rInnerRef(pBody, SAL_NO_ACQUIRE) + {} + + /** Up-casting conversion constructor: Copies interface reference. + + Does not work for up-casts to ambiguous bases. For the special case of + up-casting to Reference< XInterface >, see the corresponding conversion + operator. + + @param rRef another reference + */ + template< class derived_type > + VclPtr( + const VclPtr< derived_type > & rRef, + typename std::enable_if< + std::is_base_of<reference_type, derived_type>::value, int>::type + = 0 ) + : m_rInnerRef( static_cast<reference_type*>(rRef) ) + { + } + +#if defined(DBG_UTIL) && !defined(_WIN32) + ~VclPtr() + { + assert(m_rInnerRef.get() == nullptr || vclmain::isAlive()); + // We can be one of the intermediate counts, but if we are the last + // VclPtr keeping this object alive, then something forgot to call dispose(). + assert((!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) + && "someone forgot to call dispose()"); + } + VclPtr(VclPtr const &) = default; + VclPtr(VclPtr &&) = default; + VclPtr & operator =(VclPtr const &) = default; + VclPtr & operator =(VclPtr &&) = default; +#endif + + /** + * A construction helper for VclPtr. Since VclPtr types are created + * with a reference-count of one - to help fit into the existing + * code-flow; this helps us to construct them easily. + * + * For more details on the design please see vcl/README.lifecycle + * + * @tparam reference_type must be a subclass of vcl::Window + */ + template<typename... Arg> [[nodiscard]] static VclPtr< reference_type > Create(Arg &&... arg) + { + return VclPtr< reference_type >( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE ); + } + + /** Probably most common used: handle->someBodyOp(). + */ + reference_type * operator->() const + { + return m_rInnerRef.get(); + } + + /** Get the body. Can be used instead of operator->(). + I.e. handle->someBodyOp() and handle.get()->someBodyOp() + are the same. + */ + reference_type * get() const + { + return m_rInnerRef.get(); + } + + void set(reference_type *pBody) + { + m_rInnerRef.set(pBody); + } + + void reset(reference_type *pBody) + { + m_rInnerRef.set(pBody); + } + + /** Up-casting copy assignment operator. + + Does not work for up-casts to ambiguous bases. + + @param rRef another reference + */ + template<typename derived_type> + typename std::enable_if< + std::is_base_of<reference_type, derived_type>::value, + VclPtr &>::type + operator =(VclPtr<derived_type> const & rRef) + { + m_rInnerRef.set(rRef.get()); + return *this; + } + + VclPtr & operator =(reference_type * pBody) + { + m_rInnerRef.set(pBody); + return *this; + } + + operator reference_type * () const + { + return m_rInnerRef.get(); + } + + explicit operator bool () const + { + return m_rInnerRef.get() != nullptr; + } + + void clear() + { + m_rInnerRef.clear(); + } + + void reset() + { + m_rInnerRef.clear(); + } + + void disposeAndClear() + { + // hold it alive for the lifetime of this method + ::rtl::Reference<reference_type> aTmp(m_rInnerRef); + m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-) + if (aTmp.get()) { + aTmp->disposeOnce(); + } + } + + /** Needed to place VclPtr's into STL collection. + */ + bool operator< (const VclPtr<reference_type> & handle) const + { + return (m_rInnerRef < handle.m_rInnerRef); + } +}; // class VclPtr + +template<typename T1, typename T2> +inline bool operator ==(VclPtr<T1> const & p1, VclPtr<T2> const & p2) { + return p1.get() == p2.get(); +} + +template<typename T> inline bool operator ==(VclPtr<T> const & p1, T const * p2) +{ + return p1.get() == p2; +} + +template<typename T> inline bool operator ==(VclPtr<T> const & p1, T * p2) { + return p1.get() == p2; +} + +template<typename T> inline bool operator ==(T const * p1, VclPtr<T> const & p2) +{ + return p1 == p2.get(); +} + +template<typename T> inline bool operator ==(T * p1, VclPtr<T> const & p2) { + return p1 == p2.get(); +} + +template<typename T1, typename T2> +inline bool operator !=(VclPtr<T1> const & p1, VclPtr<T2> const & p2) { + return !(p1 == p2); +} + +template<typename T> inline bool operator !=(VclPtr<T> const & p1, T const * p2) +{ + return !(p1 == p2); +} + +template<typename T> inline bool operator !=(VclPtr<T> const & p1, T * p2) { + return !(p1 == p2); +} + +template<typename T> inline bool operator !=(T const * p1, VclPtr<T> const & p2) +{ + return !(p1 == p2); +} + +template<typename T> inline bool operator !=(T * p1, VclPtr<T> const & p2) { + return !(p1 == p2); +} + +/** + * A construction helper for a temporary VclPtr. Since VclPtr types + * are created with a reference-count of one - to help fit into + * the existing code-flow; this helps us to construct them easily. + * see also VclPtr::Create and ScopedVclPtr + * + * For more details on the design please see vcl/README.lifecycle + * + * @param reference_type must be a subclass of vcl::Window + */ +template <class reference_type> +class SAL_WARN_UNUSED VclPtrInstance final : public VclPtr<reference_type> +{ +public: + template<typename... Arg> VclPtrInstance(Arg &&... arg) + : VclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE ) + { + } + + /** + * Override and disallow this, to prevent people accidentally calling it and actually + * getting VclPtr::Create and getting a naked VclPtr<> instance + */ + template<typename... Arg> static VclPtrInstance< reference_type > Create(Arg &&... ) = delete; +}; + +template <class reference_type> +class ScopedVclPtr : public VclPtr<reference_type> +{ +public: + /** Constructor... + */ + ScopedVclPtr() + : VclPtr<reference_type>() + {} + + /** Constructor + */ + ScopedVclPtr (reference_type * pBody) + : VclPtr<reference_type>(pBody) + {} + + /** Copy constructor... + */ + ScopedVclPtr (const VclPtr<reference_type> & handle) + : VclPtr<reference_type>(handle) + {} + + /** + Assignment that releases the last reference. + */ + void disposeAndReset(reference_type *pBody) + { + if (pBody != this->get()) { + VclPtr<reference_type>::disposeAndClear(); + VclPtr<reference_type>::set(pBody); + } + } + + /** + Assignment that releases the last reference. + */ + ScopedVclPtr<reference_type>& operator = (reference_type * pBody) + { + disposeAndReset(pBody); + return *this; + } + + /** Up-casting conversion constructor: Copies interface reference. + + Does not work for up-casts to ambiguous bases. For the special case of + up-casting to Reference< XInterface >, see the corresponding conversion + operator. + + @param rRef another reference + */ + template< class derived_type > + ScopedVclPtr( + const VclPtr< derived_type > & rRef, + typename std::enable_if< + std::is_base_of<reference_type, derived_type>::value, int>::type + = 0 ) + : VclPtr<reference_type>( rRef ) + { + } + + /** Up-casting assignment operator. + + Does not work for up-casts to ambiguous bases. + + @param rRef another VclPtr + */ + template<typename derived_type> + typename std::enable_if< + std::is_base_of<reference_type, derived_type>::value, + ScopedVclPtr &>::type + operator =(VclPtr<derived_type> const & rRef) + { + disposeAndReset(rRef.get()); + return *this; + } + + /** + * Override and disallow this, to prevent people accidentally calling it and actually + * getting VclPtr::Create and getting a naked VclPtr<> instance + */ + template<typename... Arg> static ScopedVclPtr< reference_type > Create(Arg &&... ) = delete; + + ~ScopedVclPtr() + { + VclPtr<reference_type>::disposeAndClear(); + assert(VclPtr<reference_type>::get() == nullptr); // make sure there are no lingering references + } + +private: + // Most likely we don't want this default copy-constructor. + ScopedVclPtr (const ScopedVclPtr<reference_type> &) = delete; + // And certainly we don't want a default assignment operator. + ScopedVclPtr<reference_type>& operator = (const ScopedVclPtr<reference_type> &) = delete; + // And disallow reset as that doesn't call disposeAndClear on the original reference + void reset() = delete; + void reset(reference_type *pBody) = delete; + +protected: + ScopedVclPtr (reference_type * pBody, __sal_NoAcquire) + : VclPtr<reference_type>(pBody, SAL_NO_ACQUIRE) + {} +}; + +/** + * A construction helper for ScopedVclPtr. Since VclPtr types are created + * with a reference-count of one - to help fit into the existing + * code-flow; this helps us to construct them easily. + * + * For more details on the design please see vcl/README.lifecycle + * + * @param reference_type must be a subclass of vcl::Window + */ +#if defined _MSC_VER +#pragma warning(push) +#pragma warning(disable: 4521) // " multiple copy constructors specified" +#endif +template <class reference_type> +class SAL_WARN_UNUSED ScopedVclPtrInstance final : public ScopedVclPtr<reference_type> +{ +public: + template<typename... Arg> ScopedVclPtrInstance(Arg &&... arg) + : ScopedVclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE ) + { + } + + /** + * Override and disallow this, to prevent people accidentally calling it and actually + * getting VclPtr::Create and getting a naked VclPtr<> instance + */ + template<typename... Arg> static ScopedVclPtrInstance< reference_type > Create(Arg &&...) = delete; + +private: + // Prevent the above perfect forwarding ctor from hijacking (accidental) + // attempts at ScopedVclPtrInstance copy construction (where the hijacking + // would typically lead to somewhat obscure error messages); both non-const + // and const variants are needed here, as the ScopedVclPtr base class has a + // const--variant copy ctor, so the implicitly declared copy ctor for + // ScopedVclPtrInstance would also be the const variant, so non-const copy + // construction attempts would be hijacked by the perfect forwarding ctor; + // but if we only declared a non-const variant here, the const variant would + // no longer be implicitly declared (as there would already be an explicitly + // declared copy ctor), so const copy construction attempts would then be + // hijacked by the perfect forwarding ctor: + ScopedVclPtrInstance(ScopedVclPtrInstance &) = delete; + ScopedVclPtrInstance(ScopedVclPtrInstance const &) = delete; +}; +#if defined _MSC_VER +#pragma warning(pop) +#endif + +#endif // INCLUDED_VCL_PTR_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/vclreferencebase.hxx b/include/vcl/vclreferencebase.hxx new file mode 100644 index 000000000..2ba39026a --- /dev/null +++ b/include/vcl/vclreferencebase.hxx @@ -0,0 +1,72 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_VCL_Reference_HXX +#define INCLUDED_VCL_Reference_HXX + +#include <vcl/dllapi.h> +#include <osl/interlck.h> + +class VclBuilder; + +class VCL_DLLPUBLIC VclReferenceBase +{ + mutable oslInterlockedCount mnRefCnt; + + template<typename T> friend class VclPtr; + friend class ::VclBuilder; // needed by ::delete_by_window(vcl::Window *pWindow) + +public: + void acquire() const + { + osl_atomic_increment(&mnRefCnt); + } + + void release() const + { + if (osl_atomic_decrement(&mnRefCnt) == 0) + delete this; + } +#ifdef DBG_UTIL +#ifndef _WIN32 + sal_Int32 getRefCount() const { return mnRefCnt; } +#endif +#endif + + +private: + VclReferenceBase(const VclReferenceBase&) = delete; + VclReferenceBase& operator=(const VclReferenceBase&) = delete; + + bool mbDisposed : 1; + +protected: + VclReferenceBase(); + virtual ~VclReferenceBase(); + + // This is only supposed to be called from disposeOnce + virtual void dispose(); + +public: + // This is normally supposed to be called from VclPtr::disposeAndClear + void disposeOnce(); + + bool isDisposed() const { return mbDisposed; } + +}; +#endif diff --git a/include/vcl/vectorgraphicdata.hxx b/include/vcl/vectorgraphicdata.hxx new file mode 100644 index 000000000..465690c56 --- /dev/null +++ b/include/vcl/vectorgraphicdata.hxx @@ -0,0 +1,139 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_VECTORGRAPHICDATA_HXX +#define INCLUDED_VCL_VECTORGRAPHICDATA_HXX + +#include <basegfx/range/b2drange.hxx> +#include <com/sun/star/uno/Sequence.hxx> +#include <vcl/bitmapex.hxx> +#include <vcl/BinaryDataContainer.hxx> +#include <rtl/ustring.hxx> +#include <deque> +#include <memory> +#include <algorithm> +#include <optional> + +namespace com::sun::star::graphic { class XPrimitive2D; } + +typedef css::uno::Sequence<sal_Int8> VectorGraphicDataArray; + + +// helper to convert any Primitive2DSequence to a good quality BitmapEx, +// using default parameters and graphic::XPrimitive2DRenderer + +BitmapEx VCL_DLLPUBLIC convertPrimitive2DSequenceToBitmapEx( + const std::deque< css::uno::Reference< css::graphic::XPrimitive2D > >& rSequence, + const basegfx::B2DRange& rTargetRange, + const sal_uInt32 nMaximumQuadraticPixels = 500000, + const o3tl::Length eTargetUnit = o3tl::Length::mm100, + const std::optional<Size>& rTargetDPI = std::nullopt); + + +enum class VectorGraphicDataType +{ + Svg = 0, + Emf = 1, + Wmf = 2, + Pdf = 3 +}; + +class VCL_DLLPUBLIC VectorGraphicData +{ +private: + // the file and length + BinaryDataContainer maDataContainer; + + // on demand created content + bool mbSequenceCreated; + basegfx::B2DRange maRange; + std::deque< css::uno::Reference< css::graphic::XPrimitive2D > > maSequence; + BitmapEx maReplacement; + size_t mNestedBitmapSize; + VectorGraphicDataType meType; + + /// If the vector format has more pages this denotes which page to render + sal_Int32 mnPageIndex; + + /// Useful for PDF, which is vector-based, but still rendered to a bitmap. + basegfx::B2DTuple maSizeHint; + + bool mbEnableEMFPlus = true; + + // on demand creators + void ensurePdfReplacement(); + void ensureReplacement(); + void ensureSequenceAndRange(); + + VectorGraphicData(const VectorGraphicData&) = delete; + VectorGraphicData& operator=(const VectorGraphicData&) = delete; + +public: + VectorGraphicData(const OUString& rPath, VectorGraphicDataType eVectorDataType); + VectorGraphicData( + const BinaryDataContainer& rDataContainer, + VectorGraphicDataType eVectorDataType, + sal_Int32 nPageIndex = -1); + ~VectorGraphicData(); + + /// compare op + bool operator==(const VectorGraphicData& rCandidate) const; + + /// data read + const BinaryDataContainer& getBinaryDataContainer() const + { + return maDataContainer; + } + + enum class State { UNPARSED, PARSED }; + std::pair<State, size_t> getSizeBytes() const; + + const VectorGraphicDataType& getType() const { return meType; } + + /// data read and evtl. on demand creation + const basegfx::B2DRange& getRange() const; + const std::deque<css::uno::Reference<css::graphic::XPrimitive2D>>& getPrimitive2DSequence() const; + const BitmapEx& getReplacement() const; + BitmapChecksum GetChecksum() const; + + sal_Int32 getPageIndex() const + { + return std::max(sal_Int32(0), mnPageIndex); + } + + void setPageIndex(sal_Int32 nPageIndex) + { + mnPageIndex = nPageIndex; + } + + void setSizeHint(const basegfx::B2DTuple& rSizeHint) + { + maSizeHint = rSizeHint; + } + + const basegfx::B2DTuple& getSizeHint() const { return maSizeHint; } + + void setEnableEMFPlus(bool bEnableEMFPlus) { mbEnableEMFPlus = bEnableEMFPlus; } + + bool isPrimitiveSequenceCreated() const { return mbSequenceCreated; } +}; + +#endif // INCLUDED_VCL_VECTORGRAPHICDATA_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/virdev.hxx b/include/vcl/virdev.hxx new file mode 100644 index 000000000..b611e7f8a --- /dev/null +++ b/include/vcl/virdev.hxx @@ -0,0 +1,189 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_VIRDEV_HXX +#define INCLUDED_VCL_VIRDEV_HXX + +#include <vcl/dllapi.h> +#include <vcl/outdev.hxx> +#include <vcl/salgtype.hxx> +#include <memory> + +class SalVirtualDevice; +struct SystemGraphicsData; +typedef struct _cairo_surface cairo_surface_t; + +class SAL_WARN_UNUSED VCL_DLLPUBLIC VirtualDevice : public OutputDevice +{ + friend class Application; + friend class ::OutputDevice; + friend class Printer; + friend cairo_surface_t* get_underlying_cairo_surface(const VirtualDevice&); +public: + // reference device modes for different compatibility levels + enum class RefDevMode { NONE = 0, + Dpi600 = 1, // 600 dpi + MSO1 = 3, + PDF1 = 4, + Custom = 5 + }; + +private: + std::unique_ptr<SalVirtualDevice> mpVirDev; + VclPtr<VirtualDevice> mpPrev; + VclPtr<VirtualDevice> mpNext; + sal_uInt16 mnBitCount; + bool mbScreenComp; + const DeviceFormat meFormat; + const DeviceFormat meAlphaFormat; + RefDevMode meRefDevMode; + bool mbForceZeroExtleadBug; + + SAL_DLLPRIVATE void ImplInitVirDev( const OutputDevice* pOutDev, tools::Long nDX, tools::Long nDY, const SystemGraphicsData *pData = nullptr ); + SAL_DLLPRIVATE bool InnerImplSetOutputSizePixel( const Size& rNewSize, bool bErase, + sal_uInt8* pBuffer ); + SAL_DLLPRIVATE bool ImplSetOutputSizePixel( const Size& rNewSize, bool bErase, + sal_uInt8* pBuffer ); + + VirtualDevice (const VirtualDevice &) = delete; + VirtualDevice & operator= (const VirtualDevice &) = delete; + + /** Used for alpha VDev, to set areas to opaque + + @since \#i32109# + */ + SAL_DLLPRIVATE void ImplFillOpaqueRectangle( const tools::Rectangle& rRect ); + +protected: + virtual bool AcquireGraphics() const override; + virtual void ReleaseGraphics( bool bRelease = true ) override; + + /** Create a virtual device of size 1x1 + + @param pCompDev + The generated vdev will be compatible to this device. + If it's the nullptr, it uses Application::GetDefaultDevice(). + + @param eFormat + Device format of the generated virtual device. Use DeviceFormat::DEFAULT here, to + indicate: take default screen depth. + + @param eAlphaFormat + Device format of the generated virtual device. Use DeviceFormat::DEFAULT here, to + indicate: take default screen depth. + + @param eOutDevType + This real virtual output device type. + */ + explicit VirtualDevice(const OutputDevice* pCompDev, DeviceFormat eFormat, + DeviceFormat eAlphaFormat, OutDevType eOutDevType); + +public: + + /** Create a virtual device of size 1x1 + + @param eFormat + Device format of the generated virtual device. Use DeviceFormat::DEFAULT here, to + indicate: take default screen depth. + + @param eAlphaFormat + Device format of the generated virtual device. Use DeviceFormat::DEFAULT here, to + indicate: take default screen depth. + */ + explicit VirtualDevice(DeviceFormat eFormat = DeviceFormat::DEFAULT, DeviceFormat eAlphaFormat = DeviceFormat::NONE) + : VirtualDevice(nullptr, eFormat, eAlphaFormat, OUTDEV_VIRDEV) {} + + /** Create a virtual device of size 1x1 + + @param rCompDev + The generated vdev will be compatible to this device. + + @param eFormat + Device format of the generated virtual device. Use DeviceFormat::DEFAULT here, to + indicate: take default screen depth. + */ + explicit VirtualDevice(const OutputDevice& rCompDev, + DeviceFormat eFormat = DeviceFormat::DEFAULT) + : VirtualDevice(&rCompDev, eFormat, DeviceFormat::NONE, OUTDEV_VIRDEV) {} + + /** Create a virtual device of size 1x1 with alpha channel + + @param rCompDev + The generated vdev will be compatible to this device. + + @param eFormat + Device format of the generated virtual device. Use DeviceFormat::DEFAULT here, to + indicate: take default screen depth. + + @param eAlphaFormat + Device format of the generated virtual device. Use DeviceFormat::DEFAULT here, to + indicate: take default screen depth. + */ + explicit VirtualDevice(const OutputDevice& rCompDev, + DeviceFormat eFormat, DeviceFormat eAlphaFormat) + : VirtualDevice(&rCompDev, eFormat, eAlphaFormat, OUTDEV_VIRDEV) {} + + /** Create a virtual device using an existing system dependent device or graphics context + Any rendering will happen directly on the context and not on any intermediate bitmap. + Note: This might not be supported on all platforms ! + */ + explicit VirtualDevice(const SystemGraphicsData& rData, const Size &rSize, + DeviceFormat eFormat); + + virtual ~VirtualDevice() override; + virtual void dispose() override; + + bool CanEnableNativeWidget() const override; + + virtual void EnableRTL( bool bEnable = true ) override; + + bool SetOutputSizePixel( const Size& rNewSize, bool bErase = true ); + bool SetOutputSizePixelScaleOffsetAndLOKBuffer( const Size& rNewSize, + const Fraction& rScale, + const Point& rNewOffset, + sal_uInt8* pBuffer); + + bool SetOutputSize( const Size& rNewSize ) + { return SetOutputSizePixel( LogicToPixel( rNewSize ) ); } + + void SetReferenceDevice( RefDevMode ); + + void Compat_ZeroExtleadBug(); // enable workaround for #i60495# + + void SetReferenceDevice( sal_Int32 i_nDPIX, sal_Int32 i_nDPIY ); + + virtual sal_uInt16 GetBitCount() const override; + + bool IsVirtual() const override; + + bool IsScreenComp() const override { return mbScreenComp; } + +private: + SAL_DLLPRIVATE void ImplSetReferenceDevice( RefDevMode, sal_Int32 i_nDPIX, sal_Int32 i_nDPIY ); + +protected: + virtual bool UsePolyPolygonForComplexGradient() override; + + virtual tools::Long GetFontExtLeading() const override; + +}; + +#endif // INCLUDED_VCL_VIRDEV_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/wall.hxx b/include/vcl/wall.hxx new file mode 100644 index 000000000..474d2afe5 --- /dev/null +++ b/include/vcl/wall.hxx @@ -0,0 +1,117 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_WALL_HXX +#define INCLUDED_VCL_WALL_HXX + +#include <tools/color.hxx> +#include <tools/gen.hxx> +#include <vcl/bitmapex.hxx> +#include <vcl/gradient.hxx> +#include <vcl/dllapi.h> +#include <optional> + +class Gradient; +class BitmapEx; +class ImplWallpaper; + +enum class WallpaperStyle +{ + NONE, + Tile, + Center, + Scale, + TopLeft, + Top, + TopRight, + Left, + Right, + BottomLeft, + Bottom, + BottomRight, + ApplicationGradient // defines a gradient that internally covers the whole application + // and uses a color derived from the face color +}; + +class VCL_DLLPUBLIC Wallpaper +{ +public: + SAL_DLLPRIVATE void ImplSetCachedBitmap( const BitmapEx& rBmp ) const; + SAL_DLLPRIVATE const BitmapEx* ImplGetCachedBitmap() const; + SAL_DLLPRIVATE void ImplReleaseCachedBitmap() const; + +private: + SAL_DLLPRIVATE static Gradient ImplGetApplicationGradient(); + +public: + Wallpaper(); + Wallpaper( const Wallpaper& rWallpaper ); + Wallpaper( Wallpaper&& rWallpaper ); + Wallpaper( const Color& rColor ); + explicit Wallpaper( const BitmapEx& rBmpEx ); + ~Wallpaper(); + + void SetColor( const Color& rColor ); + const Color& GetColor() const { return maColor; } + + void SetStyle( WallpaperStyle eStyle ); + WallpaperStyle GetStyle() const { return meStyle; } + + void SetBitmap( const BitmapEx& rBitmap ); + const BitmapEx & GetBitmap() const; + bool IsBitmap() const; + + void SetGradient( const Gradient& rGradient ); + Gradient GetGradient() const; + bool IsGradient() const; + + void SetRect( const tools::Rectangle& rRect ) { maRect = rRect; } + const tools::Rectangle & GetRect() const { return maRect; } + bool IsRect() const; + + bool IsFixed() const; + bool IsScrollable() const; + + Wallpaper& operator=( const Wallpaper& rWallpaper ); + Wallpaper& operator=( Wallpaper&& rWallpaper ); + + bool operator==( const Wallpaper& rWallpaper ) const; + bool operator!=( const Wallpaper& rWallpaper ) const + { return !(Wallpaper::operator==( rWallpaper )); } + + bool IsEmpty() const + { + return GetStyle() == WallpaperStyle::NONE && GetColor() == COL_TRANSPARENT && + !IsBitmap() && !IsGradient() && !IsRect(); + } + + friend SvStream& ReadWallpaper( SvStream& rIStm, Wallpaper& rWallpaper ); + friend SvStream& WriteWallpaper( SvStream& rOStm, const Wallpaper& rWallpaper ); +private: + tools::Rectangle maRect; + BitmapEx maBitmap; + mutable BitmapEx maCache; + std::optional<Gradient> mpGradient; + Color maColor; + WallpaperStyle meStyle; +}; + +#endif // INCLUDED_VCL_WALL_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/weld.hxx b/include/vcl/weld.hxx new file mode 100644 index 000000000..34f22ac57 --- /dev/null +++ b/include/vcl/weld.hxx @@ -0,0 +1,2637 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_WELD_HXX +#define INCLUDED_VCL_WELD_HXX + +#include <basegfx/range/b2irange.hxx> +#include <rtl/ustring.hxx> +#include <tools/color.hxx> +#include <tools/date.hxx> +#include <tools/fldunit.hxx> +#include <tools/gen.hxx> +#include <tools/link.hxx> +#include <vcl/dllapi.h> +#include <vcl/vclenum.hxx> +#include <vcl/font.hxx> +#include <vcl/vclptr.hxx> +#include <vcl/uitest/factory.hxx> + +#include <com/sun/star/accessibility/XAccessibleRelationSet.hpp> +#include <com/sun/star/accessibility/XAccessible.hpp> + +#include <assert.h> +#include <memory> +#include <vector> + +namespace com::sun::star::awt +{ +class XWindow; +} +namespace com::sun::star::datatransfer::clipboard +{ +class XClipboard; +} +namespace com::sun::star::datatransfer::dnd +{ +class XDropTarget; +} +namespace com::sun::star::graphic +{ +class XGraphic; +} +typedef css::uno::Reference<css::accessibility::XAccessible> a11yref; +typedef css::uno::Reference<css::accessibility::XAccessibleRelationSet> a11yrelationset; +enum class PointerStyle; +class CommandEvent; +class Formatter; +class InputContext; +class KeyEvent; +class MouseEvent; +class SvNumberFormatter; +class TransferDataContainer; +class OutputDevice; +class VirtualDevice; +struct SystemEnvData; + +namespace vcl +{ +class ILibreOfficeKitNotifier; +typedef OutputDevice RenderContext; +} +namespace tools +{ +class JsonWriter; +} + +class LOKTrigger; + +namespace weld +{ +class Container; +class DialogController; + +class VCL_DLLPUBLIC Widget +{ + friend class ::LOKTrigger; + +protected: + Link<Widget&, void> m_aFocusInHdl; + Link<Widget&, void> m_aFocusOutHdl; + Link<Widget&, bool> m_aMnemonicActivateHdl; + Link<const Size&, void> m_aSizeAllocateHdl; + Link<const KeyEvent&, bool> m_aKeyPressHdl; + Link<const KeyEvent&, bool> m_aKeyReleaseHdl; + Link<const MouseEvent&, bool> m_aMousePressHdl; + Link<const MouseEvent&, bool> m_aMouseMotionHdl; + Link<const MouseEvent&, bool> m_aMouseReleaseHdl; + +public: + virtual void set_sensitive(bool sensitive) = 0; + virtual bool get_sensitive() const = 0; + + /* visibility */ + + virtual void show() = 0; + virtual void hide() = 0; + + // This function simply calls show() or hide() but is convenient when the + // visibility depends on some condition + virtual void set_visible(bool visible) + { + if (visible) + show(); + else + hide(); + } + + // return if this widget's visibility is true + virtual bool get_visible() const = 0; + + // return if this widget's visibility and that of all its parents is true + virtual bool is_visible() const = 0; + + /* focus */ + + // sets if this widget can own the keyboard focus + virtual void set_can_focus(bool bCanFocus) = 0; + + // causes this widget to have the keyboard focus + virtual void grab_focus() = 0; + + // returns if this widget has the keyboard focus + virtual bool has_focus() const = 0; + + // if the widget that has focus is a child, which includes toplevel popup + // children, of this widget. So an Entry with an active popup (or dialog) + // has has_child_focus of true, but has_focus of false, while its popup is + // shown + virtual bool has_child_focus() const = 0; + + // return if this widget has the keyboard focus within the active window + // TODO: review if this has any practical difference from has_focus() + virtual bool is_active() const = 0; + + /* size */ + virtual void set_size_request(int nWidth, int nHeight) = 0; + virtual Size get_size_request() const = 0; + virtual Size get_preferred_size() const = 0; + + /* measure */ + virtual float get_approximate_digit_width() const = 0; + virtual int get_text_height() const = 0; + virtual Size get_pixel_size(const OUString& rText) const = 0; + + // The name of the widget in the GtkBuilder UI definition used to construct it. + virtual OString get_buildable_name() const = 0; + /* + Typically there is no need to change the buildable name at runtime, changing + the id in .ui file itself is preferred. + + But for ui-testing purposes it can sometimes be useful to rename + different widgets, that were loaded from the same .ui, to unique names + in order to distinguish between them + */ + virtual void set_buildable_name(const OString& rName) = 0; + + /* + The help id of the widget used to identify help for this widget. + + By default the help id of a widget is a path-like sequence of (load-time) + buildable-names from the widgets UI definition ancestor to this widget, + e.g. grandparent/parent/widget. + + The default can be overwritten with set_help_id + */ + virtual OString get_help_id() const = 0; + virtual void set_help_id(const OString& rName) = 0; + + virtual void set_grid_left_attach(int nAttach) = 0; + virtual int get_grid_left_attach() const = 0; + virtual void set_grid_width(int nCols) = 0; + virtual void set_grid_top_attach(int nAttach) = 0; + virtual int get_grid_top_attach() const = 0; + + virtual void set_hexpand(bool bExpand) = 0; + virtual bool get_hexpand() const = 0; + virtual void set_vexpand(bool bExpand) = 0; + virtual bool get_vexpand() const = 0; + + virtual void set_margin_top(int nMargin) = 0; + virtual void set_margin_bottom(int nMargin) = 0; + virtual void set_margin_start(int nMargin) = 0; + virtual void set_margin_end(int nMargin) = 0; + + virtual int get_margin_top() const = 0; + virtual int get_margin_bottom() const = 0; + virtual int get_margin_start() const = 0; + virtual int get_margin_end() const = 0; + + /* + * Report the extents of this widget relative to the rRelative target widget. + * + * To succeed, both widgets must be realized, and must share a common toplevel. + * + * returns false if the relative extents could not be determined, e.g. if + * either widget was not realized, or there was no common ancestor. + * Otherwise true. + */ + virtual bool get_extents_relative_to(const Widget& rRelative, int& x, int& y, int& width, + int& height) const = 0; + + virtual void set_accessible_name(const OUString& rName) = 0; + virtual void set_accessible_description(const OUString& rDescription) = 0; + virtual OUString get_accessible_name() const = 0; + + virtual OUString get_accessible_description() const = 0; + + // After this call this widget is only accessibility labelled by pLabel and + // pLabel only accessibility labels this widget + virtual void set_accessible_relation_labeled_by(weld::Widget* pLabel) = 0; + + virtual void set_tooltip_text(const OUString& rTip) = 0; + virtual OUString get_tooltip_text() const = 0; + + virtual void connect_focus_in(const Link<Widget&, void>& rLink) + { + assert(!m_aFocusInHdl.IsSet() || !rLink.IsSet()); + m_aFocusInHdl = rLink; + } + + virtual void connect_focus_out(const Link<Widget&, void>& rLink) + { + assert(!m_aFocusOutHdl.IsSet() || !rLink.IsSet()); + m_aFocusOutHdl = rLink; + } + + // rLink is called when the mnemonic for the Widget is called. + // If rLink returns true the Widget will not automatically gain + // focus as normally occurs + virtual void connect_mnemonic_activate(const Link<Widget&, bool>& rLink) + { + assert(!m_aMnemonicActivateHdl.IsSet() || !rLink.IsSet()); + m_aMnemonicActivateHdl = rLink; + } + + virtual void connect_size_allocate(const Link<const Size&, void>& rLink) + { + assert(!m_aSizeAllocateHdl.IsSet() || !rLink.IsSet()); + m_aSizeAllocateHdl = rLink; + } + + virtual void connect_key_press(const Link<const KeyEvent&, bool>& rLink) + { + assert(!m_aKeyPressHdl.IsSet() || !rLink.IsSet()); + m_aKeyPressHdl = rLink; + } + + virtual void connect_key_release(const Link<const KeyEvent&, bool>& rLink) + { + assert(!m_aKeyReleaseHdl.IsSet() || !rLink.IsSet()); + m_aKeyReleaseHdl = rLink; + } + + virtual void connect_mouse_press(const Link<const MouseEvent&, bool>& rLink) + { + assert(!m_aMousePressHdl.IsSet() || !rLink.IsSet()); + m_aMousePressHdl = rLink; + } + + virtual void connect_mouse_move(const Link<const MouseEvent&, bool>& rLink) + { + assert(!m_aMouseMotionHdl.IsSet() || !rLink.IsSet()); + m_aMouseMotionHdl = rLink; + } + + virtual void connect_mouse_release(const Link<const MouseEvent&, bool>& rLink) + { + assert(!m_aMouseReleaseHdl.IsSet() || !rLink.IsSet()); + m_aMouseReleaseHdl = rLink; + } + + virtual void grab_add() = 0; + virtual bool has_grab() const = 0; + virtual void grab_remove() = 0; + + // font size is in points, not pixels, e.g. see Window::[G]etPointFont + virtual vcl::Font get_font() = 0; + + //true for rtl, false otherwise + virtual bool get_direction() const = 0; + virtual void set_direction(bool bRTL) = 0; + + /* Increases the freeze count on widget. + + If the freeze count is non-zero, emission of the widget's notifications + is stopped. The notifications are queued until the freeze count is + decreased to zero. Duplicate notifications may be squashed together. + */ + virtual void freeze() = 0; + + /* Reverts the effect of a previous call to freeze. + + The freeze count is decreased on the widget and when it reaches zero, + queued notifications are emitted. + */ + virtual void thaw() = 0; + + /* push/pop busy mouse cursor state + + bBusy of true to push a busy state onto the stack and false + to pop it off, calls to this should balance. + + see weld::WaitObject */ + virtual void set_busy_cursor(bool bBusy) = 0; + + virtual void queue_resize() = 0; + + virtual std::unique_ptr<Container> weld_parent() const = 0; + + //iterate upwards through the hierarchy starting at this widgets parent, + //calling func with their helpid until func returns true or we run out of + //parents + virtual void help_hierarchy_foreach(const std::function<bool(const OString&)>& func) = 0; + + virtual OUString strip_mnemonic(const OUString& rLabel) const = 0; + + virtual VclPtr<VirtualDevice> create_virtual_device() const = 0; + + //do something transient to attract the attention of the user to the widget + virtual void call_attention_to() = 0; + + //make this widget look like a page in a notebook + virtual void set_stack_background() = 0; + //make this widget look like it has a highlighted background + virtual void set_highlight_background() = 0; + //make this widget suitable as parent for a title + virtual void set_title_background() = 0; + //make this widget suitable for use in a toolbar + virtual void set_toolbar_background() = 0; + //trying to use a custom color for a background is generally a bad idea. If your need + //fits one of the above categories then that's a somewhat better choice + virtual void set_background(const Color& rBackColor) = 0; + + virtual css::uno::Reference<css::datatransfer::dnd::XDropTarget> get_drop_target() = 0; + virtual css::uno::Reference<css::datatransfer::clipboard::XClipboard> get_clipboard() const = 0; + + virtual void connect_get_property_tree(const Link<tools::JsonWriter&, void>& rLink) = 0; + virtual void get_property_tree(tools::JsonWriter& rJsonWriter) = 0; + + // render the widget to an output device + virtual void draw(OutputDevice& rOutput, const Point& rPos, const Size& rSizePixel) = 0; + + virtual ~Widget() {} +}; + +class VCL_DLLPUBLIC Container : virtual public Widget +{ +protected: + Link<Container&, void> m_aContainerFocusChangedHdl; + + void signal_container_focus_changed() { m_aContainerFocusChangedHdl.Call(*this); } + +public: + // remove and add in one go + virtual void move(weld::Widget* pWidget, weld::Container* pNewParent) = 0; + // create an XWindow as a child of this container. The XWindow is + // suitable to contain css::awt::XControl items + virtual css::uno::Reference<css::awt::XWindow> CreateChildFrame() = 0; + // rLink is called when the focus transitions from a widget outside the container + // to a widget inside the container or vice versa + virtual void connect_container_focus_changed(const Link<Container&, void>& rLink) + { + m_aContainerFocusChangedHdl = rLink; + } + // causes a child of the container to have the keyboard focus + virtual void child_grab_focus() = 0; +}; + +class VCL_DLLPUBLIC Box : virtual public Container +{ +public: + // Moves child to a new position in the list of children + virtual void reorder_child(weld::Widget* pWidget, int position) = 0; + // Sort ok/cancel etc buttons in platform order + virtual void sort_native_button_order() = 0; +}; + +class VCL_DLLPUBLIC Paned : virtual public Container +{ +public: + // set pixel position of divider + virtual void set_position(int nPos) = 0; + // get pixel position of divider + virtual int get_position() const = 0; +}; + +class VCL_DLLPUBLIC ScrolledWindow : virtual public Container +{ +protected: + Link<ScrolledWindow&, void> m_aVChangeHdl; + Link<ScrolledWindow&, void> m_aHChangeHdl; + + void signal_vadjustment_changed() { m_aVChangeHdl.Call(*this); } + void signal_hadjustment_changed() { m_aHChangeHdl.Call(*this); } + +public: + virtual void hadjustment_configure(int value, int lower, int upper, int step_increment, + int page_increment, int page_size) + = 0; + virtual int hadjustment_get_value() const = 0; + virtual void hadjustment_set_value(int value) = 0; + virtual int hadjustment_get_upper() const = 0; + virtual void hadjustment_set_upper(int upper) = 0; + virtual int hadjustment_get_page_size() const = 0; + virtual void hadjustment_set_page_size(int size) = 0; + virtual void hadjustment_set_page_increment(int size) = 0; + virtual void hadjustment_set_step_increment(int size) = 0; + virtual void set_hpolicy(VclPolicyType eHPolicy) = 0; + virtual VclPolicyType get_hpolicy() const = 0; + void connect_hadjustment_changed(const Link<ScrolledWindow&, void>& rLink) + { + m_aHChangeHdl = rLink; + } + + virtual void vadjustment_configure(int value, int lower, int upper, int step_increment, + int page_increment, int page_size) + = 0; + virtual int vadjustment_get_value() const = 0; + virtual void vadjustment_set_value(int value) = 0; + virtual int vadjustment_get_upper() const = 0; + virtual void vadjustment_set_upper(int upper) = 0; + virtual int vadjustment_get_page_size() const = 0; + virtual void vadjustment_set_page_size(int size) = 0; + virtual void vadjustment_set_page_increment(int size) = 0; + virtual void vadjustment_set_step_increment(int size) = 0; + virtual int vadjustment_get_lower() const = 0; + virtual void vadjustment_set_lower(int upper) = 0; + virtual void set_vpolicy(VclPolicyType eVPolicy) = 0; + virtual VclPolicyType get_vpolicy() const = 0; + void connect_vadjustment_changed(const Link<ScrolledWindow&, void>& rLink) + { + m_aVChangeHdl = rLink; + } + virtual int get_scroll_thickness() const = 0; + virtual void set_scroll_thickness(int nThickness) = 0; + + //trying to use custom color for a scrollbar is generally a bad idea. + virtual void customize_scrollbars(const Color& rBackgroundColor, const Color& rShadowColor, + const Color& rFaceColor) + = 0; +}; + +class Label; + +class VCL_DLLPUBLIC Frame : virtual public Container +{ +public: + virtual void set_label(const OUString& rText) = 0; + virtual OUString get_label() const = 0; + virtual std::unique_ptr<Label> weld_label_widget() const = 0; +}; + +class VCL_DLLPUBLIC Notebook : virtual public Widget +{ +protected: + Link<const OString&, bool> m_aLeavePageHdl; + Link<const OString&, void> m_aEnterPageHdl; + +public: + virtual int get_current_page() const = 0; + virtual int get_page_index(const OString& rIdent) const = 0; + virtual OString get_page_ident(int nPage) const = 0; + virtual OString get_current_page_ident() const = 0; + virtual void set_current_page(int nPage) = 0; + virtual void set_current_page(const OString& rIdent) = 0; + virtual void remove_page(const OString& rIdent) = 0; + virtual void insert_page(const OString& rIdent, const OUString& rLabel, int nPos) = 0; + void append_page(const OString& rIdent, const OUString& rLabel) + { + insert_page(rIdent, rLabel, -1); + } + virtual void set_tab_label_text(const OString& rIdent, const OUString& rLabel) = 0; + virtual OUString get_tab_label_text(const OString& rIdent) const = 0; + virtual void set_show_tabs(bool bShow) = 0; + virtual int get_n_pages() const = 0; + virtual weld::Container* get_page(const OString& rIdent) const = 0; + + void connect_leave_page(const Link<const OString&, bool>& rLink) { m_aLeavePageHdl = rLink; } + void connect_enter_page(const Link<const OString&, void>& rLink) { m_aEnterPageHdl = rLink; } +}; + +class VCL_DLLPUBLIC ScreenShotEntry +{ +public: + ScreenShotEntry(const OString& rHelpId, const basegfx::B2IRange& rB2IRange) + : msHelpId(rHelpId) + , maB2IRange(rB2IRange) + { + } + + const basegfx::B2IRange& getB2IRange() const { return maB2IRange; } + + const OString& GetHelpId() const { return msHelpId; } + +private: + OString msHelpId; + basegfx::B2IRange maB2IRange; +}; + +typedef std::vector<ScreenShotEntry> ScreenShotCollection; + +class VCL_DLLPUBLIC Window : virtual public Container +{ +protected: + Link<Widget&, bool> m_aHelpRequestHdl; + +public: + virtual void set_title(const OUString& rTitle) = 0; + virtual OUString get_title() const = 0; + virtual void window_move(int x, int y) = 0; + virtual void set_modal(bool bModal) = 0; + virtual bool get_modal() const = 0; + virtual bool get_resizable() const = 0; + virtual Size get_size() const = 0; + virtual Point get_position() const = 0; + virtual tools::Rectangle get_monitor_workarea() const = 0; + // center window on is parent + // + // bTrackGeometryRequests set to true tries to ensure the window will end + // up still centered on its parent windows final size, taking into account + // that there may currently be pending geometry requests for the parent not + // yet processed by the underlying toolkit + // + // for e.g gtk this will means the window is always centered even when + // resized, calling set_centered_on_parent with false will turn this + // off again. + virtual void set_centered_on_parent(bool bTrackGeometryRequests) = 0; + // returns whether the widget that has focus is within this Window + // (its very possible to move this to weld::Container if that becomes + // desirable) + virtual bool has_toplevel_focus() const = 0; + virtual void present() = 0; + + // with pOld of null, automatically find the old default widget and unset + // it, otherwise use as hint to the old default + virtual void change_default_widget(weld::Widget* pOld, weld::Widget* pNew) = 0; + virtual bool is_default_widget(const weld::Widget* pCandidate) const = 0; + + virtual void set_window_state(const OString& rStr) = 0; + virtual OString get_window_state(WindowStateMask nMask) const = 0; + + virtual css::uno::Reference<css::awt::XWindow> GetXWindow() = 0; + + void connect_help(const Link<Widget&, bool>& rLink) { m_aHelpRequestHdl = rLink; } + + virtual SystemEnvData get_system_data() const = 0; + + virtual void resize_to_request() = 0; + + // collect positions of widgets and their help ids for screenshot purposes + virtual ScreenShotCollection collect_screenshot_data() = 0; + + // render the widget to an output device + virtual VclPtr<VirtualDevice> screenshot() = 0; +}; + +class VCL_DLLPUBLIC WaitObject +{ +private: + weld::Widget* m_pWindow; + +public: + WaitObject(weld::Widget* pWindow) + : m_pWindow(pWindow) + { + if (m_pWindow) + m_pWindow->set_busy_cursor(true); + } + ~WaitObject() + { + if (m_pWindow) + m_pWindow->set_busy_cursor(false); + } +}; + +class Button; + +class VCL_DLLPUBLIC Dialog : virtual public Window +{ +private: + friend DialogController; + virtual bool runAsync(std::shared_ptr<DialogController>, + const std::function<void(sal_Int32)>& func) + = 0; + +public: + virtual int run() = 0; + // Run async without a controller + // @param self - must point to this, to enforce that the dialog was created/held by a shared_ptr + virtual bool runAsync(std::shared_ptr<Dialog> const& rxSelf, + const std::function<void(sal_Int32)>& func) + = 0; + virtual void response(int response) = 0; + virtual void add_button(const OUString& rText, int response, const OString& rHelpId = OString()) + = 0; + virtual void set_default_response(int response) = 0; + virtual Button* weld_widget_for_response(int response) = 0; + virtual Container* weld_content_area() = 0; + + // shrink the dialog down to shown just these widgets + virtual void collapse(weld::Widget* pEdit, weld::Widget* pButton) = 0; + // undo previous dialog collapse + virtual void undo_collapse() = 0; + + virtual void SetInstallLOKNotifierHdl(const Link<void*, vcl::ILibreOfficeKitNotifier*>& rLink) + = 0; +}; + +class VCL_DLLPUBLIC MessageDialog : virtual public Dialog +{ +public: + virtual void set_primary_text(const OUString& rText) = 0; + virtual OUString get_primary_text() const = 0; + virtual void set_secondary_text(const OUString& rText) = 0; + virtual OUString get_secondary_text() const = 0; + virtual Container* weld_message_area() = 0; +}; + +class VCL_DLLPUBLIC Assistant : virtual public Dialog +{ +protected: + Link<const OString&, bool> m_aJumpPageHdl; + + bool signal_jump_page(const OString& rIdent) { return m_aJumpPageHdl.Call(rIdent); } + +public: + virtual int get_current_page() const = 0; + virtual int get_n_pages() const = 0; + virtual OString get_page_ident(int nPage) const = 0; + virtual OString get_current_page_ident() const = 0; + virtual void set_current_page(int nPage) = 0; + virtual void set_current_page(const OString& rIdent) = 0; + // move the page rIdent to position nIndex + virtual void set_page_index(const OString& rIdent, int nIndex) = 0; + virtual void set_page_title(const OString& rIdent, const OUString& rTitle) = 0; + virtual OUString get_page_title(const OString& rIdent) const = 0; + virtual void set_page_sensitive(const OString& rIdent, bool bSensitive) = 0; + virtual weld::Container* append_page(const OString& rIdent) = 0; + + virtual void set_page_side_help_id(const OString& rHelpId) = 0; + + void connect_jump_page(const Link<const OString&, bool>& rLink) { m_aJumpPageHdl = rLink; } +}; + +inline OUString toId(const void* pValue) +{ + return OUString::number(reinterpret_cast<sal_uInt64>(pValue)); +} + +template <typename T> T fromId(const OUString& rValue) +{ + return reinterpret_cast<T>(rValue.toUInt64()); +} + +struct VCL_DLLPUBLIC ComboBoxEntry +{ + OUString sString; + OUString sId; + OUString sImage; + ComboBoxEntry(const OUString& rString) + : sString(rString) + { + } + ComboBoxEntry(const OUString& rString, const OUString& rId) + : sString(rString) + , sId(rId) + { + } + ComboBoxEntry(const OUString& rString, const OUString& rId, const OUString& rImage) + : sString(rString) + , sId(rId) + , sImage(rImage) + { + } +}; + +enum class EntryMessageType +{ + Normal, + Warning, + Error, +}; + +class Menu; + +/// A widget used to choose from a list of items. +class VCL_DLLPUBLIC ComboBox : virtual public Widget +{ +private: + OUString m_sSavedValue; + std::vector<OUString> m_aSavedValues; + +public: + // OUString is the id of the row, it may be null to measure the height of a generic line + typedef std::tuple<vcl::RenderContext&, const tools::Rectangle&, bool, const OUString&> + render_args; + +protected: + Link<ComboBox&, void> m_aChangeHdl; + Link<ComboBox&, void> m_aPopupToggledHdl; + Link<ComboBox&, bool> m_aEntryActivateHdl; + Link<OUString&, bool> m_aEntryInsertTextHdl; + + friend class ::LOKTrigger; + + void signal_changed() { m_aChangeHdl.Call(*this); } + + virtual void signal_popup_toggled() { m_aPopupToggledHdl.Call(*this); } + + Link<render_args, void> m_aRenderHdl; + void signal_custom_render(vcl::RenderContext& rDevice, const tools::Rectangle& rRect, + bool bSelected, const OUString& rId) + { + m_aRenderHdl.Call(render_args(rDevice, rRect, bSelected, rId)); + } + + Link<vcl::RenderContext&, Size> m_aGetSizeHdl; + Size signal_custom_get_size(vcl::RenderContext& rDevice) { return m_aGetSizeHdl.Call(rDevice); } + +public: + virtual void insert(int pos, const OUString& rStr, const OUString* pId, + const OUString* pIconName, VirtualDevice* pImageSurface) + = 0; + virtual void insert_vector(const std::vector<weld::ComboBoxEntry>& rItems, bool bKeepExisting) + = 0; + void insert_text(int pos, const OUString& rStr) + { + insert(pos, rStr, nullptr, nullptr, nullptr); + } + void append_text(const OUString& rStr) { insert(-1, rStr, nullptr, nullptr, nullptr); } + void append(const OUString& rId, const OUString& rStr) + { + insert(-1, rStr, &rId, nullptr, nullptr); + } + void append(const OUString& rId, const OUString& rStr, const OUString& rImage) + { + insert(-1, rStr, &rId, &rImage, nullptr); + } + void append(const OUString& rId, const OUString& rStr, VirtualDevice& rImage) + { + insert(-1, rStr, &rId, nullptr, &rImage); + } + void append(int pos, const OUString& rId, const OUString& rStr) + { + insert(pos, rStr, &rId, nullptr, nullptr); + } + virtual void insert_separator(int pos, const OUString& rId) = 0; + void append_separator(const OUString& rId) { insert_separator(-1, rId); } + + virtual int get_count() const = 0; + virtual void make_sorted() = 0; + virtual void clear() = 0; + + //by index + virtual int get_active() const = 0; + virtual void set_active(int pos) = 0; + virtual void remove(int pos) = 0; + + //by text + virtual OUString get_active_text() const = 0; + void set_active_text(const OUString& rStr) { set_active(find_text(rStr)); } + virtual OUString get_text(int pos) const = 0; + virtual int find_text(const OUString& rStr) const = 0; + void remove_text(const OUString& rText) { remove(find_text(rText)); } + + //by id + virtual OUString get_active_id() const = 0; + virtual void set_active_id(const OUString& rStr) = 0; + virtual OUString get_id(int pos) const = 0; + virtual void set_id(int row, const OUString& rId) = 0; + virtual int find_id(const OUString& rId) const = 0; + void remove_id(const OUString& rId) { remove(find_id(rId)); } + + /* m_aChangeHdl is called when the active item is changed. The can be due + to the user selecting a different item from the list or while typing + into the entry of a combo box with an entry. + + Use changed_by_direct_pick() to discover whether an item was actually explicitly + selected, e.g. from the menu. + */ + void connect_changed(const Link<ComboBox&, void>& rLink) { m_aChangeHdl = rLink; } + + virtual bool changed_by_direct_pick() const = 0; + + virtual void connect_popup_toggled(const Link<ComboBox&, void>& rLink) + { + m_aPopupToggledHdl = rLink; + } + + //entry related + virtual bool has_entry() const = 0; + virtual void set_entry_message_type(EntryMessageType eType) = 0; + virtual void set_entry_text(const OUString& rStr) = 0; + virtual void set_entry_width_chars(int nChars) = 0; + virtual void set_entry_max_length(int nChars) = 0; + virtual void select_entry_region(int nStartPos, int nEndPos) = 0; + virtual bool get_entry_selection_bounds(int& rStartPos, int& rEndPos) = 0; + virtual void set_entry_completion(bool bEnable, bool bCaseSensitive = false) = 0; + virtual void set_entry_placeholder_text(const OUString& rText) = 0; + virtual void set_entry_editable(bool bEditable) = 0; + virtual void cut_entry_clipboard() = 0; + virtual void copy_entry_clipboard() = 0; + virtual void paste_entry_clipboard() = 0; + + // font size is in points, not pixels, e.g. see Window::[G]etPointFont + virtual void set_font(const vcl::Font& rFont) = 0; + + // font size is in points, not pixels, e.g. see Window::[G]etPointFont + virtual void set_entry_font(const vcl::Font& rFont) = 0; + virtual vcl::Font get_entry_font() = 0; + + virtual bool get_popup_shown() const = 0; + + void connect_entry_insert_text(const Link<OUString&, bool>& rLink) + { + m_aEntryInsertTextHdl = rLink; + } + + // callback returns true to indicated no further processing of activate wanted + void connect_entry_activate(const Link<ComboBox&, bool>& rLink) { m_aEntryActivateHdl = rLink; } + + void save_value() { m_sSavedValue = get_active_text(); } + + void save_values_by_id(const OUString& rId) + { + m_aSavedValues.push_back(get_text(find_id(rId))); + } + + OUString const& get_saved_value() const { return m_sSavedValue; } + OUString const& get_saved_values(int pos) const { return m_aSavedValues[pos]; } + bool get_value_changed_from_saved() const { return m_sSavedValue != get_active_text(); } + bool get_values_changed_from_saved() const + { + return !m_aSavedValues.empty() + && std::find(m_aSavedValues.begin(), m_aSavedValues.end(), get_active_text()) + == m_aSavedValues.end(); + } + + void removeSavedValues() { m_aSavedValues.clear(); } + + // for custom rendering a row + void connect_custom_get_size(const Link<vcl::RenderContext&, Size>& rLink) + { + m_aGetSizeHdl = rLink; + } + void connect_custom_render(const Link<render_args, void>& rLink) { m_aRenderHdl = rLink; } + // call set_custom_renderer after setting custom callbacks + virtual void set_custom_renderer(bool bOn) = 0; + // create a virtual device compatible with the device passed in render_args wrt alpha + virtual VclPtr<VirtualDevice> create_render_virtual_device() const = 0; + // set a sub menu for a entry, only works with custom rendering + virtual void set_item_menu(const OString& rIdent, weld::Menu* pMenu) = 0; + // get the width needed to show the menu launcher in a custom row + virtual int get_menu_button_width() const = 0; + + // for mru support + virtual int get_max_mru_count() const = 0; + virtual void set_max_mru_count(int nCount) = 0; + virtual OUString get_mru_entries() const = 0; + virtual void set_mru_entries(const OUString& rEntries) = 0; +}; + +enum class ColumnToggleType +{ + Check, + Radio +}; + +class VCL_DLLPUBLIC TreeIter +{ +private: + TreeIter(const TreeIter&) = delete; + TreeIter& operator=(const TreeIter&) = delete; + +public: + TreeIter() {} + virtual bool equal(const TreeIter& rOther) const = 0; + virtual ~TreeIter() {} +}; + +/* Model column indexes are considered to begin at 0, but with special columns + before index 0. A expander image column (and an additional optional toggle + button column when enable_toggle_buttons is used). Column index -1 is + reserved to access those columns. +*/ +class VCL_DLLPUBLIC TreeView : virtual public Widget +{ + friend class ::LOKTrigger; + +public: + typedef std::pair<const TreeIter&, int> iter_col; + typedef std::pair<const TreeIter&, OUString> iter_string; + // OUString is the id of the row, it may be null to measure the height of a generic line + typedef std::pair<vcl::RenderContext&, const OUString&> get_size_args; + typedef std::tuple<vcl::RenderContext&, const tools::Rectangle&, bool, const OUString&> + render_args; + +private: + OUString m_sSavedValue; + +protected: + Link<TreeView&, void> m_aChangeHdl; + Link<TreeView&, bool> m_aRowActivatedHdl; + Link<int, void> m_aColumnClickedHdl; + Link<const iter_col&, void> m_aRadioToggleHdl; + Link<const TreeIter&, bool> m_aEditingStartedHdl; + Link<const iter_string&, bool> m_aEditingDoneHdl; + // if handler returns false, the expansion of the row is refused + Link<const TreeIter&, bool> m_aExpandingHdl; + // if handler returns false, the collapse of the row is refused + Link<const TreeIter&, bool> m_aCollapsingHdl; + Link<TreeView&, void> m_aVisibleRangeChangedHdl; + Link<TreeView&, void> m_aModelChangedHdl; + // if handler returns true, then menu has been show and event is consumed + Link<const CommandEvent&, bool> m_aPopupMenuHdl; + // if handler returns true, drag is disallowed, consumer can change bool + // arg to false to disable the treeview default dnd icon + Link<bool&, bool> m_aDragBeginHdl; + std::function<int(const weld::TreeIter&, const weld::TreeIter&)> m_aCustomSort; + +protected: + void signal_changed() { m_aChangeHdl.Call(*this); } + bool signal_row_activated() { return m_aRowActivatedHdl.Call(*this); } + void signal_column_clicked(int nColumn) { m_aColumnClickedHdl.Call(nColumn); } + bool signal_expanding(const TreeIter& rIter) + { + return !m_aExpandingHdl.IsSet() || m_aExpandingHdl.Call(rIter); + } + bool signal_collapsing(const TreeIter& rIter) + { + return !m_aCollapsingHdl.IsSet() || m_aCollapsingHdl.Call(rIter); + } + void signal_visible_range_changed() { m_aVisibleRangeChangedHdl.Call(*this); } + void signal_model_changed() { m_aModelChangedHdl.Call(*this); } + + void signal_toggled(const iter_col& rIterCol) { m_aRadioToggleHdl.Call(rIterCol); } + + bool signal_editing_started(const TreeIter& rIter) { return m_aEditingStartedHdl.Call(rIter); } + + bool signal_editing_done(const iter_string& rIterText) + { + return m_aEditingDoneHdl.Call(rIterText); + } + + Link<const TreeIter&, OUString> m_aQueryTooltipHdl; + OUString signal_query_tooltip(const TreeIter& rIter) { return m_aQueryTooltipHdl.Call(rIter); } + + Link<render_args, void> m_aRenderHdl; + void signal_custom_render(vcl::RenderContext& rDevice, const tools::Rectangle& rRect, + bool bSelected, const OUString& rId) + { + m_aRenderHdl.Call(render_args(rDevice, rRect, bSelected, rId)); + } + + Link<get_size_args, Size> m_aGetSizeHdl; + Size signal_custom_get_size(vcl::RenderContext& rDevice, const OUString& rId) + { + return m_aGetSizeHdl.Call(get_size_args(rDevice, rId)); + } + +public: + virtual void connect_query_tooltip(const Link<const TreeIter&, OUString>& rLink) + { + assert(!m_aQueryTooltipHdl.IsSet() || !rLink.IsSet()); + m_aQueryTooltipHdl = rLink; + } + + // see 'expanding on-demand node details' for bChildrenOnDemand of true + virtual void insert(const TreeIter* pParent, int pos, const OUString* pStr, const OUString* pId, + const OUString* pIconName, VirtualDevice* pImageSurface, + bool bChildrenOnDemand, TreeIter* pRet) + = 0; + + void insert(int nRow, TreeIter* pRet = nullptr) + { + insert(nullptr, nRow, nullptr, nullptr, nullptr, nullptr, false, pRet); + } + + void append(TreeIter* pRet = nullptr) { insert(-1, pRet); } + + void insert(int pos, const OUString& rStr, const OUString* pId, const OUString* pIconName, + VirtualDevice* pImageSurface) + { + insert(nullptr, pos, &rStr, pId, pIconName, pImageSurface, false, nullptr); + } + void insert_text(int pos, const OUString& rStr) + { + insert(nullptr, pos, &rStr, nullptr, nullptr, nullptr, false, nullptr); + } + void append_text(const OUString& rStr) + { + insert(nullptr, -1, &rStr, nullptr, nullptr, nullptr, false, nullptr); + } + void append(const OUString& rId, const OUString& rStr) + { + insert(nullptr, -1, &rStr, &rId, nullptr, nullptr, false, nullptr); + } + void append(const OUString& rId, const OUString& rStr, const OUString& rImage) + { + insert(nullptr, -1, &rStr, &rId, &rImage, nullptr, false, nullptr); + } + void append(const TreeIter* pParent, const OUString& rStr) + { + insert(pParent, -1, &rStr, nullptr, nullptr, nullptr, false, nullptr); + } + + virtual void insert_separator(int pos, const OUString& rId) = 0; + void append_separator(const OUString& rId) { insert_separator(-1, rId); } + + void connect_changed(const Link<TreeView&, void>& rLink) { m_aChangeHdl = rLink; } + + /* A row is "activated" when the user double clicks a treeview row. It may + also be emitted when a row is selected and Space or Enter is pressed. + + a return of "true" means the activation has been handled, a "false" propagates + the activation to the default handler which expands/collapses the row, if possible. + */ + void connect_row_activated(const Link<TreeView&, bool>& rLink) { m_aRowActivatedHdl = rLink; } + + // Argument is a pair of iter, col describing the toggled node + void connect_toggled(const Link<const iter_col&, void>& rLink) { m_aRadioToggleHdl = rLink; } + + void connect_column_clicked(const Link<int, void>& rLink) { m_aColumnClickedHdl = rLink; } + void connect_model_changed(const Link<TreeView&, void>& rLink) { m_aModelChangedHdl = rLink; } + + virtual OUString get_selected_text() const = 0; + virtual OUString get_selected_id() const = 0; + + // call before inserting any content and connecting to toggle signals, + // an pre-inserted checkbutton column will exist at the start of every row + // inserted after this call which can be accessed with col index -1 + virtual void enable_toggle_buttons(ColumnToggleType eType) = 0; + + virtual void set_clicks_to_toggle(int nToggleBehavior) = 0; + + //by index + virtual int get_selected_index() const = 0; + //Don't select when frozen, select after thaw. Note selection doesn't survive a freeze. + virtual void select(int pos) = 0; + virtual void unselect(int pos) = 0; + virtual void remove(int pos) = 0; + // col index -1 gets the first text column + virtual OUString get_text(int row, int col = -1) const = 0; + // col index -1 sets the first text column + virtual void set_text(int row, const OUString& rText, int col = -1) = 0; + // col index -1 sets the first text column + virtual void set_sensitive(int row, bool bSensitive, int col = -1) = 0; + virtual void set_id(int row, const OUString& rId) = 0; + // col index -1 sets the expander toggle, enable_toggle_buttons must have been called to create that column + virtual void set_toggle(int row, TriState eState, int col = -1) = 0; + // col index -1 gets the expander toggle, enable_toggle_buttons must have been called to create that column + virtual TriState get_toggle(int row, int col = -1) const = 0; + // col index -1 sets the expander image + virtual void set_image(int row, const OUString& rImage, int col = -1) = 0; + // col index -1 sets the expander image + virtual void set_image(int row, VirtualDevice& rImage, int col = -1) = 0; + // col index -1 sets the expander image + virtual void set_image(int row, const css::uno::Reference<css::graphic::XGraphic>& rImage, + int col = -1) + = 0; + virtual void set_text_emphasis(int row, bool bOn, int col) = 0; + virtual bool get_text_emphasis(int row, int col) const = 0; + virtual void set_text_align(int row, double fAlign, int col) = 0; + virtual void swap(int pos1, int pos2) = 0; + virtual std::vector<int> get_selected_rows() const = 0; + virtual void set_font_color(int pos, const Color& rColor) = 0; + // scroll to make 'row' visible, this will also expand all parent rows of 'row' as necessary to + // make 'row' visible + virtual void scroll_to_row(int row) = 0; + virtual bool is_selected(int pos) const = 0; + virtual int get_cursor_index() const = 0; + virtual void set_cursor(int pos) = 0; + + //by text + virtual int find_text(const OUString& rText) const = 0; + //Don't select when frozen, select after thaw. Note selection doesn't survive a freeze. + void select_text(const OUString& rText) { select(find_text(rText)); } + void remove_text(const OUString& rText) { remove(find_text(rText)); } + std::vector<OUString> get_selected_rows_text() const + { + std::vector<int> aRows(get_selected_rows()); + std::vector<OUString> aRet; + aRet.reserve(aRows.size()); + for (auto a : aRows) + aRet.push_back(get_text(a)); + return aRet; + } + + //by id + virtual OUString get_id(int pos) const = 0; + virtual int find_id(const OUString& rId) const = 0; + //Don't select when frozen, select after thaw. Note selection doesn't survive a freeze. + void select_id(const OUString& rId) { select(find_id(rId)); } + void remove_id(const OUString& rText) { remove(find_id(rText)); } + + //via iter + virtual std::unique_ptr<TreeIter> make_iterator(const TreeIter* pOrig = nullptr) const = 0; + virtual void copy_iterator(const TreeIter& rSource, TreeIter& rDest) const = 0; + virtual bool get_selected(TreeIter* pIter) const = 0; + virtual bool get_cursor(TreeIter* pIter) const = 0; + virtual void set_cursor(const TreeIter& rIter) = 0; + virtual bool get_iter_first(TreeIter& rIter) const = 0; + // set iter to point to next node at the current level + virtual bool iter_next_sibling(TreeIter& rIter) const = 0; + // set iter to point to previous node at the current level + virtual bool iter_previous_sibling(TreeIter& rIter) const = 0; + // set iter to point to next node, depth first, then sibling + virtual bool iter_next(TreeIter& rIter) const = 0; + // set iter to point to previous node, sibling first then depth + virtual bool iter_previous(TreeIter& rIter) const = 0; + // set iter to point to first child node + virtual bool iter_children(TreeIter& rIter) const = 0; + bool iter_nth_sibling(TreeIter& rIter, int nChild) const + { + bool bRet = true; + for (int i = 0; i < nChild && bRet; ++i) + bRet = iter_next_sibling(rIter); + return bRet; + } + bool iter_nth_child(TreeIter& rIter, int nChild) const + { + if (!iter_children(rIter)) + return false; + return iter_nth_sibling(rIter, nChild); + } + virtual bool iter_parent(TreeIter& rIter) const = 0; + virtual int get_iter_depth(const TreeIter& rIter) const = 0; + virtual int get_iter_index_in_parent(const TreeIter& rIter) const = 0; + /* Compares two paths. If a appears before b in a tree, then -1 is returned. + If b appears before a , then 1 is returned. If the two nodes are equal, + then 0 is returned. + */ + virtual int iter_compare(const TreeIter& a, const TreeIter& b) const = 0; + virtual bool iter_has_child(const TreeIter& rIter) const = 0; + // returns the number of direct children rIter has + virtual int iter_n_children(const TreeIter& rIter) const = 0; + virtual void remove(const TreeIter& rIter) = 0; + //Don't select when frozen, select after thaw. Note selection doesn't survive a freeze. + virtual void select(const TreeIter& rIter) = 0; + virtual void unselect(const TreeIter& rIter) = 0; + //visually indent this row as if it was at get_iter_depth() + nIndentLevel + virtual void set_extra_row_indent(const TreeIter& rIter, int nIndentLevel) = 0; + // col index -1 sets the first text column + virtual void set_text(const TreeIter& rIter, const OUString& rStr, int col = -1) = 0; + // col index -1 sets the first text column + virtual void set_sensitive(const TreeIter& rIter, bool bSensitive, int col = -1) = 0; + virtual void set_text_emphasis(const TreeIter& rIter, bool bOn, int col) = 0; + virtual bool get_text_emphasis(const TreeIter& rIter, int col) const = 0; + virtual void set_text_align(const TreeIter& rIter, double fAlign, int col) = 0; + // col index -1 sets the expander toggle, enable_toggle_buttons must have been called to create that column + virtual void set_toggle(const TreeIter& rIter, TriState bOn, int col = -1) = 0; + // col index -1 gets the expander toggle, enable_toggle_buttons must have been called to create that column + virtual TriState get_toggle(const TreeIter& rIter, int col = -1) const = 0; + // col index -1 gets the first text column + virtual OUString get_text(const TreeIter& rIter, int col = -1) const = 0; + virtual void set_id(const TreeIter& rIter, const OUString& rId) = 0; + virtual OUString get_id(const TreeIter& rIter) const = 0; + // col index -1 sets the expander image + virtual void set_image(const TreeIter& rIter, const OUString& rImage, int col = -1) = 0; + // col index -1 sets the expander image + virtual void set_image(const TreeIter& rIter, VirtualDevice& rImage, int col = -1) = 0; + // col index -1 sets the expander image + virtual void set_image(const TreeIter& rIter, + const css::uno::Reference<css::graphic::XGraphic>& rImage, int col = -1) + = 0; + virtual void set_font_color(const TreeIter& rIter, const Color& rColor) = 0; + // scroll to make rIter visible, this will also expand all parent rows of rIter as necessary to + // make rIter visible + virtual void scroll_to_row(const TreeIter& rIter) = 0; + virtual bool is_selected(const TreeIter& rIter) const = 0; + + virtual void move_subtree(TreeIter& rNode, const TreeIter* pNewParent, int nIndexInNewParent) + = 0; + + // call func on each element until func returns true or we run out of elements + virtual void all_foreach(const std::function<bool(TreeIter&)>& func) = 0; + // call func on each selected element until func returns true or we run out of elements + virtual void selected_foreach(const std::function<bool(TreeIter&)>& func) = 0; + // call func on each visible element until func returns true or we run out of elements + virtual void visible_foreach(const std::function<bool(TreeIter&)>& func) = 0; + // clear the children of pParent (whole tree if nullptr), + // then add nSourceCount rows under pParent, call func on each row + // inserted with an arg of the index that this row will be when bulk insert + // ends. + // + // this enables inserting the entries backwards in models where that is faster, + // + // pFixedWidths is optional, when present each matching entry col text + // width will not be measured, and the fixed width used instead. Use + // sparingly because wider text than the fixed width is clipped and cannot + // be scrolled into view horizontally. + virtual void bulk_insert_for_each(int nSourceCount, + const std::function<void(TreeIter&, int nSourceIndex)>& func, + const weld::TreeIter* pParent = nullptr, + const std::vector<int>* pFixedWidths = nullptr) + = 0; + + /* expanding on-demand node details + + When a node is added with children-on-demand (typically via 'insert' with + bChildrenOnDemand of true), then initially in reality the + children-on-demand node is given a 'placeholder' child entry to indicate + the load-on-demand state. + + The 'placeholder' needs to be there for the expander indicator to be + drawn/shown even when there are no "real" entries yet. This child doesn't + exist for the purposes of any of the iterator methods, e.g. iter_has_child + on an on-demand node which hasn't been expanded yet is false. Likewise the + rest of the iterator methods skip over or otherwise ignore that node. + + Normal usage is the user clicks on the expander, the expansion mechanism + removes the 'placeholder' entry (set_children_on_demand(false)) and calls + any installed expanding-callback (installable via connect_expanding) which + has the opportunity to populate the node with children. + + If you decide to directly populate the children of an on-demand node + outside of the expanding-callback then you also need to explicitly remove + the 'placeholder' with set_children_on_demand(false) otherwise the treeview + is in an inconsistent state. */ + + virtual bool get_row_expanded(const TreeIter& rIter) const = 0; + // expand row will first trigger the callback set via connect_expanding before expanding + virtual void expand_row(const TreeIter& rIter) = 0; + // collapse row will first trigger the callback set via connect_collapsing before collapsing + virtual void collapse_row(const TreeIter& rIter) = 0; + // set the empty node to appear as if it has children, true is equivalent + // to 'insert' with a bChildrenOnDemand of true. See notes above. + virtual void set_children_on_demand(const TreeIter& rIter, bool bChildrenOnDemand) = 0; + // return if the node is configured to be populated on-demand + virtual bool get_children_on_demand(const TreeIter& rIter) const = 0; + // set if the expanders are shown or not + virtual void set_show_expanders(bool bShow) = 0; + + void connect_expanding(const Link<const TreeIter&, bool>& rLink) { m_aExpandingHdl = rLink; } + void connect_collapsing(const Link<const TreeIter&, bool>& rLink) { m_aCollapsingHdl = rLink; } + + // rStartLink returns true to allow editing, false to disallow + // rEndLink returns true to accept the edit, false to reject + virtual void connect_editing(const Link<const TreeIter&, bool>& rStartLink, + const Link<const iter_string&, bool>& rEndLink) + { + assert(rStartLink.IsSet() == rEndLink.IsSet() && "should be both on or both off"); + m_aEditingStartedHdl = rStartLink; + m_aEditingDoneHdl = rEndLink; + } + + virtual void start_editing(const weld::TreeIter& rEntry) = 0; + virtual void end_editing() = 0; + + virtual void connect_visible_range_changed(const Link<TreeView&, void>& rLink) + { + assert(!m_aVisibleRangeChangedHdl.IsSet() || !rLink.IsSet()); + m_aVisibleRangeChangedHdl = rLink; + } + + virtual void connect_popup_menu(const Link<const CommandEvent&, bool>& rLink) + { + m_aPopupMenuHdl = rLink; + } + + virtual void enable_drag_source(rtl::Reference<TransferDataContainer>& rTransferrable, + sal_uInt8 eDNDConstants) + = 0; + + void connect_drag_begin(const Link<bool&, bool>& rLink) { m_aDragBeginHdl = rLink; } + + //all of them. Don't select when frozen, select after thaw. Note selection doesn't survive a freeze. + void select_all() { unselect(-1); } + void unselect_all() { select(-1); } + + // return the number of toplevel nodes + virtual int n_children() const = 0; + + // afterwards, entries will be in default ascending sort order + virtual void make_sorted() = 0; + virtual void make_unsorted() = 0; + virtual bool get_sort_order() const = 0; + virtual void set_sort_order(bool bAscending) = 0; + + // TRUE ascending, FALSE, descending, INDET, neither (off) + virtual void set_sort_indicator(TriState eState, int nColumn) = 0; + virtual TriState get_sort_indicator(int nColumn) const = 0; + + virtual int get_sort_column() const = 0; + virtual void set_sort_column(int nColumn) = 0; + + virtual void + set_sort_func(const std::function<int(const weld::TreeIter&, const weld::TreeIter&)>& func) + { + m_aCustomSort = func; + } + + virtual void clear() = 0; + virtual int get_height_rows(int nRows) const = 0; + + virtual void columns_autosize() = 0; + virtual void set_column_fixed_widths(const std::vector<int>& rWidths) = 0; + virtual void set_column_editables(const std::vector<bool>& rEditables) = 0; + virtual int get_column_width(int nCol) const = 0; + virtual void set_centered_column(int nCol) = 0; + virtual OUString get_column_title(int nColumn) const = 0; + virtual void set_column_title(int nColumn, const OUString& rTitle) = 0; + + int get_checkbox_column_width() const { return get_approximate_digit_width() * 3 + 6; } + + virtual void set_selection_mode(SelectionMode eMode) = 0; + virtual int count_selected_rows() const = 0; + // remove the selected nodes + virtual void remove_selection() = 0; + + // only meaningful is call this from a "changed" callback, true if the change + // was due to mouse hovering over the entry + virtual bool changed_by_hover() const = 0; + + virtual void vadjustment_set_value(int value) = 0; + virtual int vadjustment_get_value() const = 0; + + void save_value() { m_sSavedValue = get_selected_text(); } + OUString const& get_saved_value() const { return m_sSavedValue; } + bool get_value_changed_from_saved() const { return m_sSavedValue != get_selected_text(); } + + // for custom rendering a cell + void connect_custom_get_size(const Link<get_size_args, Size>& rLink) { m_aGetSizeHdl = rLink; } + void connect_custom_render(const Link<render_args, void>& rLink) { m_aRenderHdl = rLink; } + // call set_column_custom_renderer after setting custom callbacks + virtual void set_column_custom_renderer(int nColumn, bool bEnable) = 0; + // redraw all rows, typically only useful with custom rendering to redraw due to external + // state change + virtual void queue_draw() = 0; + + /* with bDnDMode false simply return the row under the point + * + * with bDnDMode true: + * a) return the row which should be dropped on, which may + * be different from the row the mouse is over in some backends where + * positioning the mouse on the bottom half of a row indicates to drop + * after the row + * b) dnd highlight the dest row + */ + virtual bool get_dest_row_at_pos(const Point& rPos, weld::TreeIter* pResult, bool bDnDMode) = 0; + virtual void unset_drag_dest_row() = 0; + virtual tools::Rectangle get_row_area(const weld::TreeIter& rIter) const = 0; + // for dragging and dropping between TreeViews, return the active source + virtual TreeView* get_drag_source() const = 0; + + using Widget::set_sensitive; +}; + +class VCL_DLLPUBLIC IconView : virtual public Widget +{ + friend class ::LOKTrigger; + +private: + OUString m_sSavedValue; + +protected: + Link<IconView&, void> m_aSelectionChangeHdl; + Link<IconView&, bool> m_aItemActivatedHdl; + Link<const CommandEvent&, bool> m_aCommandHdl; + Link<const TreeIter&, OUString> m_aQueryTooltipHdl; + + void signal_selection_changed() { m_aSelectionChangeHdl.Call(*this); } + bool signal_item_activated() { return m_aItemActivatedHdl.Call(*this); } + OUString signal_query_tooltip(const TreeIter& rIter) const + { + return m_aQueryTooltipHdl.Call(rIter); + } + +public: + virtual int get_item_width() const = 0; + virtual void set_item_width(int width) = 0; + + virtual void insert(int pos, const OUString* pStr, const OUString* pId, + const OUString* pIconName, TreeIter* pRet) + = 0; + + virtual void insert(int pos, const OUString* pStr, const OUString* pId, + const VirtualDevice* pIcon, TreeIter* pRet) + = 0; + + virtual void insert_separator(int pos, const OUString* pId) = 0; + + void append(const OUString& rId, const OUString& rStr, const OUString& rImage) + { + insert(-1, &rStr, &rId, &rImage, nullptr); + } + + void append(const OUString& rId, const OUString& rStr, const VirtualDevice* pImage) + { + insert(-1, &rStr, &rId, pImage, nullptr); + } + + void append_separator(const OUString& rId) { insert_separator(-1, &rId); } + + void connect_selection_changed(const Link<IconView&, void>& rLink) + { + m_aSelectionChangeHdl = rLink; + } + + /* A row is "activated" when the user double clicks a treeview row. It may + also be emitted when a row is selected and Space or Enter is pressed. + + a return of "true" means the activation has been handled, a "false" propagates + the activation to the default handler which expands/collapses the row, if possible. + */ + void connect_item_activated(const Link<IconView&, bool>& rLink) { m_aItemActivatedHdl = rLink; } + + void connect_command(const Link<const CommandEvent&, bool>& rLink) { m_aCommandHdl = rLink; } + + virtual void connect_query_tooltip(const Link<const TreeIter&, OUString>& rLink) + { + m_aQueryTooltipHdl = rLink; + } + + virtual OUString get_selected_id() const = 0; + + virtual void clear() = 0; + + virtual int count_selected_items() const = 0; + + virtual OUString get_selected_text() const = 0; + + //by index. Don't select when frozen, select after thaw. Note selection doesn't survive a freeze. + virtual void select(int pos) = 0; + virtual void unselect(int pos) = 0; + + //via iter + virtual std::unique_ptr<TreeIter> make_iterator(const TreeIter* pOrig = nullptr) const = 0; + virtual bool get_selected(TreeIter* pIter) const = 0; + virtual bool get_cursor(TreeIter* pIter) const = 0; + virtual void set_cursor(const TreeIter& rIter) = 0; + virtual bool get_iter_first(TreeIter& rIter) const = 0; + virtual OUString get_id(const TreeIter& rIter) const = 0; + virtual void scroll_to_item(const TreeIter& rIter) = 0; + + // call func on each selected element until func returns true or we run out of elements + virtual void selected_foreach(const std::function<bool(TreeIter&)>& func) = 0; + + //all of them. Don't select when frozen, select after thaw. Note selection doesn't survive a freeze. + void select_all() { unselect(-1); } + void unselect_all() { select(-1); } + + // return the number of toplevel nodes + virtual int n_children() const = 0; + + void save_value() { m_sSavedValue = get_selected_text(); } + OUString const& get_saved_value() const { return m_sSavedValue; } + bool get_value_changed_from_saved() const { return m_sSavedValue != get_selected_text(); } +}; + +class VCL_DLLPUBLIC Button : virtual public Widget +{ + friend class ::LOKTrigger; + +protected: + Link<Button&, void> m_aClickHdl; + + void signal_clicked() { m_aClickHdl.Call(*this); } + +public: + virtual void set_label(const OUString& rText) = 0; + // pDevice, the image for the button, or nullptr to unset + virtual void set_image(VirtualDevice* pDevice) = 0; + virtual void set_image(const css::uno::Reference<css::graphic::XGraphic>& rImage) = 0; + virtual void set_from_icon_name(const OUString& rIconName) = 0; + virtual OUString get_label() const = 0; + void clicked() { signal_clicked(); } + + // font size is in points, not pixels, e.g. see Window::[G]etPointFont + virtual void set_font(const vcl::Font& rFont) = 0; + + /* Sometimes, a widget should behave like a button (activate on click, + accept keyboard focus, etc), but look entirely different. + + pDevice, the custom look to use, or nullptr to unset. + + Typically doing this is ill advised. Consider using + set_accessible_name if you do. */ + virtual void set_custom_button(VirtualDevice* pDevice) = 0; + + void connect_clicked(const Link<Button&, void>& rLink) { m_aClickHdl = rLink; } +}; + +class VCL_DLLPUBLIC Toggleable : virtual public Widget +{ + friend class ::LOKTrigger; + +protected: + Link<Toggleable&, void> m_aToggleHdl; + TriState m_eSavedValue = TRISTATE_FALSE; + + void signal_toggled() { m_aToggleHdl.Call(*this); } + +public: + virtual void set_active(bool active) = 0; + virtual bool get_active() const = 0; + + virtual void set_inconsistent(bool inconsistent) = 0; + virtual bool get_inconsistent() const = 0; + + TriState get_state() const + { + if (get_inconsistent()) + return TRISTATE_INDET; + else if (get_active()) + return TRISTATE_TRUE; + return TRISTATE_FALSE; + } + + void set_state(TriState eState) + { + switch (eState) + { + case TRISTATE_INDET: + set_inconsistent(true); + break; + case TRISTATE_TRUE: + set_inconsistent(false); + set_active(true); + break; + case TRISTATE_FALSE: + set_inconsistent(false); + set_active(false); + break; + } + } + + void save_state() { m_eSavedValue = get_state(); } + TriState get_saved_state() const { return m_eSavedValue; } + bool get_state_changed_from_saved() const { return m_eSavedValue != get_state(); } + + virtual void connect_toggled(const Link<Toggleable&, void>& rLink) { m_aToggleHdl = rLink; } +}; + +class VCL_DLLPUBLIC ToggleButton : virtual public Button, virtual public Toggleable +{ + friend class ::LOKTrigger; +}; + +struct VCL_DLLPUBLIC TriStateEnabled +{ + TriState eState; + bool bTriStateEnabled; + TriStateEnabled() + : eState(TRISTATE_INDET) + , bTriStateEnabled(true) + { + } + void ButtonToggled(Toggleable& rToggle); +}; + +class VCL_DLLPUBLIC MenuButton : virtual public ToggleButton +{ +protected: + Link<const OString&, void> m_aSelectHdl; + + void signal_selected(const OString& rIdent) { m_aSelectHdl.Call(rIdent); } + +public: + void connect_selected(const Link<const OString&, void>& rLink) { m_aSelectHdl = rLink; } + + virtual void insert_item(int pos, const OUString& rId, const OUString& rStr, + const OUString* pIconName, VirtualDevice* pImageSurface, + TriState eCheckRadioFalse) + = 0; + void append_item(const OUString& rId, const OUString& rStr) + { + insert_item(-1, rId, rStr, nullptr, nullptr, TRISTATE_INDET); + } + void append_item_check(const OUString& rId, const OUString& rStr) + { + insert_item(-1, rId, rStr, nullptr, nullptr, TRISTATE_TRUE); + } + void append_item_radio(const OUString& rId, const OUString& rStr) + { + insert_item(-1, rId, rStr, nullptr, nullptr, TRISTATE_FALSE); + } + void append_item(const OUString& rId, const OUString& rStr, const OUString& rImage) + { + insert_item(-1, rId, rStr, &rImage, nullptr, TRISTATE_INDET); + } + void append_item(const OUString& rId, const OUString& rStr, VirtualDevice& rImage) + { + insert_item(-1, rId, rStr, nullptr, &rImage, TRISTATE_INDET); + } + virtual void insert_separator(int pos, const OUString& rId) = 0; + void append_separator(const OUString& rId) { insert_separator(-1, rId); } + virtual void remove_item(const OString& rId) = 0; + virtual void clear() = 0; + virtual void set_item_sensitive(const OString& rIdent, bool bSensitive) = 0; + virtual void set_item_active(const OString& rIdent, bool bActive) = 0; + virtual void set_item_label(const OString& rIdent, const OUString& rLabel) = 0; + virtual OUString get_item_label(const OString& rIdent) const = 0; + virtual void set_item_visible(const OString& rIdent, bool bVisible) = 0; + + virtual void set_popover(weld::Widget* pPopover) = 0; +}; + +// Similar to a MenuButton except it is split into two parts, a toggle +// button at the start and a menubutton at the end +class VCL_DLLPUBLIC MenuToggleButton : virtual public MenuButton +{ +}; + +class VCL_DLLPUBLIC CheckButton : virtual public Toggleable +{ +public: + virtual void set_label(const OUString& rText) = 0; + virtual OUString get_label() const = 0; + virtual void set_label_wrap(bool wrap) = 0; +}; + +class VCL_DLLPUBLIC RadioButton : virtual public CheckButton +{ +}; + +class VCL_DLLPUBLIC LinkButton : virtual public Widget +{ +protected: + Link<LinkButton&, bool> m_aActivateLinkHdl; + + bool signal_activate_link() { return m_aActivateLinkHdl.Call(*this); } + +public: + virtual void set_label(const OUString& rText) = 0; + virtual OUString get_label() const = 0; + virtual void set_uri(const OUString& rUri) = 0; + virtual OUString get_uri() const = 0; + + void connect_activate_link(const Link<LinkButton&, bool>& rLink) { m_aActivateLinkHdl = rLink; } +}; + +class VCL_DLLPUBLIC Scale : virtual public Widget +{ +protected: + Link<Scale&, void> m_aValueChangedHdl; + + void signal_value_changed() { m_aValueChangedHdl.Call(*this); } + +public: + virtual void set_value(int value) = 0; + virtual int get_value() const = 0; + virtual void set_range(int min, int max) = 0; + + virtual void set_increments(int step, int page) = 0; + virtual void get_increments(int& step, int& page) const = 0; + + void connect_value_changed(const Link<Scale&, void>& rLink) { m_aValueChangedHdl = rLink; } +}; + +class VCL_DLLPUBLIC Spinner : virtual public Widget +{ +public: + virtual void start() = 0; + virtual void stop() = 0; +}; + +class VCL_DLLPUBLIC ProgressBar : virtual public Widget +{ +public: + //0-100 + virtual void set_percentage(int value) = 0; + virtual OUString get_text() const = 0; + virtual void set_text(const OUString& rText) = 0; +}; + +class VCL_DLLPUBLIC Entry : virtual public Widget +{ +private: + OUString m_sSavedValue; + +protected: + Link<Entry&, void> m_aChangeHdl; + Link<OUString&, bool> m_aInsertTextHdl; + Link<Entry&, void> m_aCursorPositionHdl; + Link<Entry&, bool> m_aActivateHdl; + + friend class ::LOKTrigger; + + void signal_changed() { m_aChangeHdl.Call(*this); } + void signal_cursor_position() { m_aCursorPositionHdl.Call(*this); } + +public: + virtual void set_text(const OUString& rText) = 0; + virtual OUString get_text() const = 0; + virtual void set_width_chars(int nChars) = 0; + virtual int get_width_chars() const = 0; + // The maximum length of the entry. Use 0 for no maximum + virtual void set_max_length(int nChars) = 0; + // nEndPos can be -1 in order to select all text + virtual void select_region(int nStartPos, int nEndPos) = 0; + // returns true if the selection has nonzero length + virtual bool get_selection_bounds(int& rStartPos, int& rEndPos) = 0; + virtual void replace_selection(const OUString& rText) = 0; + // nCursorPos can be -1 to set to the end + virtual void set_position(int nCursorPos) = 0; + virtual int get_position() const = 0; + virtual void set_editable(bool bEditable) = 0; + virtual bool get_editable() const = 0; + virtual void set_message_type(EntryMessageType eType) = 0; + virtual void set_placeholder_text(const OUString& rText) = 0; + + virtual void set_overwrite_mode(bool bOn) = 0; + virtual bool get_overwrite_mode() const = 0; + + // font size is in points, not pixels, e.g. see Window::[G]etPointFont + virtual void set_font(const vcl::Font& rFont) = 0; + + /* + If you want to set a warning or error state, see set_message_type + instead where, if the toolkit supports it, a specific warning/error + indicator is shown. + + This explicit text color method exists to support rendering the + SvNumberformat color feature. + */ + virtual void set_font_color(const Color& rColor) = 0; + + virtual void connect_changed(const Link<Entry&, void>& rLink) { m_aChangeHdl = rLink; } + void connect_insert_text(const Link<OUString&, bool>& rLink) { m_aInsertTextHdl = rLink; } + // callback returns true to indicated no further processing of activate wanted + void connect_activate(const Link<Entry&, bool>& rLink) { m_aActivateHdl = rLink; } + virtual void connect_cursor_position(const Link<Entry&, void>& rLink) + { + m_aCursorPositionHdl = rLink; + } + + virtual void cut_clipboard() = 0; + virtual void copy_clipboard() = 0; + virtual void paste_clipboard() = 0; + + virtual void set_alignment(TxtAlign eXAlign) = 0; + + void save_value() { m_sSavedValue = get_text(); } + OUString const& get_saved_value() const { return m_sSavedValue; } + bool get_value_changed_from_saved() const { return m_sSavedValue != get_text(); } +}; + +class VCL_DLLPUBLIC SpinButton : virtual public Entry +{ + friend class ::LOKTrigger; + +protected: + Link<SpinButton&, void> m_aValueChangedHdl; + Link<SpinButton&, void> m_aOutputHdl; + Link<int*, bool> m_aInputHdl; + + void signal_value_changed() { m_aValueChangedHdl.Call(*this); } + + bool signal_output() + { + if (!m_aOutputHdl.IsSet()) + return false; + m_aOutputHdl.Call(*this); + return true; + } + + TriState signal_input(int* result) + { + if (!m_aInputHdl.IsSet()) + return TRISTATE_INDET; + return m_aInputHdl.Call(result) ? TRISTATE_TRUE : TRISTATE_FALSE; + } + +public: + virtual void set_value(sal_Int64 value) = 0; + virtual sal_Int64 get_value() const = 0; + virtual void set_range(sal_Int64 min, sal_Int64 max) = 0; + virtual void get_range(sal_Int64& min, sal_Int64& max) const = 0; + void set_min(sal_Int64 min) + { + sal_Int64 dummy, max; + get_range(dummy, max); + set_range(min, max); + } + void set_max(sal_Int64 max) + { + sal_Int64 min, dummy; + get_range(min, dummy); + set_range(min, max); + } + sal_Int64 get_min() const + { + sal_Int64 min, dummy; + get_range(min, dummy); + return min; + } + sal_Int64 get_max() const + { + sal_Int64 dummy, max; + get_range(dummy, max); + return max; + } + virtual void set_increments(int step, int page) = 0; + virtual void get_increments(int& step, int& page) const = 0; + virtual void set_digits(unsigned int digits) = 0; + virtual unsigned int get_digits() const = 0; + + void connect_value_changed(const Link<SpinButton&, void>& rLink) { m_aValueChangedHdl = rLink; } + + void connect_output(const Link<SpinButton&, void>& rLink) { m_aOutputHdl = rLink; } + void connect_input(const Link<int*, bool>& rLink) { m_aInputHdl = rLink; } + + sal_Int64 normalize(sal_Int64 nValue) const { return (nValue * Power10(get_digits())); } + + sal_Int64 denormalize(sal_Int64 nValue) const; + + static unsigned int Power10(unsigned int n); +}; + +class EntryFormatter; + +// Similar to a SpinButton, but input and output formatting and range/value +// are managed by a more complex Formatter which can support doubles. +class VCL_DLLPUBLIC FormattedSpinButton : virtual public Entry +{ +protected: + Link<FormattedSpinButton&, void> m_aValueChangedHdl; + + void signal_value_changed() { m_aValueChangedHdl.Call(*this); } + +public: + virtual Formatter& GetFormatter() = 0; + // does not take ownership, and so must be deregistered if pFormatter + // is destroyed + virtual void SetFormatter(weld::EntryFormatter* pFormatter) = 0; + + void connect_value_changed(const Link<FormattedSpinButton&, void>& rLink) + { + m_aValueChangedHdl = rLink; + } + +private: + friend class EntryFormatter; + virtual void sync_range_from_formatter() = 0; + virtual void sync_value_from_formatter() = 0; + virtual void sync_increments_from_formatter() = 0; +}; + +class VCL_DLLPUBLIC Image : virtual public Widget +{ +public: + virtual void set_from_icon_name(const OUString& rIconName) = 0; + virtual void set_image(VirtualDevice* pDevice) = 0; + virtual void set_image(const css::uno::Reference<css::graphic::XGraphic>& rImage) = 0; +}; + +class VCL_DLLPUBLIC Calendar : virtual public Widget +{ +protected: + Link<Calendar&, void> m_aSelectedHdl; + Link<Calendar&, void> m_aActivatedHdl; + + void signal_selected() { m_aSelectedHdl.Call(*this); } + void signal_activated() { m_aActivatedHdl.Call(*this); } + +public: + void connect_selected(const Link<Calendar&, void>& rLink) { m_aSelectedHdl = rLink; } + void connect_activated(const Link<Calendar&, void>& rLink) { m_aActivatedHdl = rLink; } + + virtual void set_date(const Date& rDate) = 0; + virtual Date get_date() const = 0; +}; + +// an entry + treeview pair, where the entry autocompletes from the +// treeview list, and selecting something in the list sets the +// entry to that text, i.e. a visually exploded ComboBox +class VCL_DLLPUBLIC EntryTreeView : virtual public ComboBox +{ +private: + DECL_DLLPRIVATE_LINK(ClickHdl, weld::TreeView&, void); + DECL_DLLPRIVATE_LINK(ModifyHdl, weld::Entry&, void); + void EntryModifyHdl(const weld::Entry& rEntry); + +protected: + std::unique_ptr<Entry> m_xEntry; + std::unique_ptr<TreeView> m_xTreeView; + +public: + EntryTreeView(std::unique_ptr<Entry> xEntry, std::unique_ptr<TreeView> xTreeView); + + virtual void insert_vector(const std::vector<weld::ComboBoxEntry>& rItems, + bool bKeepExisting) override + { + m_xTreeView->freeze(); + if (!bKeepExisting) + m_xTreeView->clear(); + for (const auto& rItem : rItems) + { + m_xTreeView->insert(-1, rItem.sString, rItem.sId.isEmpty() ? nullptr : &rItem.sId, + rItem.sImage.isEmpty() ? nullptr : &rItem.sImage, nullptr); + } + m_xTreeView->thaw(); + } + + virtual void insert(int pos, const OUString& rStr, const OUString* pId, + const OUString* pIconName, VirtualDevice* pImageSurface) override + { + m_xTreeView->insert(pos, rStr, pId, pIconName, pImageSurface); + } + + virtual int get_count() const override { return m_xTreeView->n_children(); } + virtual void clear() override { m_xTreeView->clear(); } + + //by index + virtual int get_active() const override { return m_xTreeView->get_selected_index(); } + virtual void set_active(int pos) override + { + m_xTreeView->set_cursor(pos); + m_xTreeView->select(pos); + m_xEntry->set_text(m_xTreeView->get_selected_text()); + } + virtual void remove(int pos) override { m_xTreeView->remove(pos); } + + //by text + virtual OUString get_active_text() const override { return m_xEntry->get_text(); } + virtual OUString get_text(int pos) const override { return m_xTreeView->get_text(pos); } + virtual int find_text(const OUString& rStr) const override + { + return m_xTreeView->find_text(rStr); + } + + //by id + virtual OUString get_active_id() const override { return m_xTreeView->get_selected_id(); } + virtual void set_active_id(const OUString& rStr) override + { + m_xTreeView->select_id(rStr); + m_xEntry->set_text(m_xTreeView->get_selected_text()); + } + virtual OUString get_id(int pos) const override { return m_xTreeView->get_id(pos); } + virtual void set_id(int pos, const OUString& rId) override { m_xTreeView->set_id(pos, rId); } + virtual int find_id(const OUString& rId) const override { return m_xTreeView->find_id(rId); } + + //entry related + virtual bool has_entry() const override { return true; } + virtual void set_entry_message_type(EntryMessageType eType) override + { + m_xEntry->set_message_type(eType); + } + virtual void set_entry_text(const OUString& rStr) override { m_xEntry->set_text(rStr); } + virtual void set_entry_width_chars(int nChars) override { m_xEntry->set_width_chars(nChars); } + virtual void set_entry_max_length(int nChars) override { m_xEntry->set_max_length(nChars); } + virtual void select_entry_region(int nStartPos, int nEndPos) override + { + m_xEntry->select_region(nStartPos, nEndPos); + } + //if no text was selected, both rStartPos and rEndPos will be identical + //and false will be returned + virtual bool get_entry_selection_bounds(int& rStartPos, int& rEndPos) override + { + return m_xEntry->get_selection_bounds(rStartPos, rEndPos); + } + void connect_row_activated(const Link<TreeView&, bool>& rLink) + { + m_xTreeView->connect_row_activated(rLink); + } + + virtual bool get_popup_shown() const override { return false; } + + void set_height_request_by_rows(int nRows); +}; + +class VCL_DLLPUBLIC MetricSpinButton final +{ + FieldUnit m_eSrcUnit; + std::unique_ptr<weld::SpinButton> m_xSpinButton; + Link<MetricSpinButton&, void> m_aValueChangedHdl; + + DECL_LINK(spin_button_value_changed, weld::SpinButton&, void); + DECL_LINK(spin_button_output, weld::SpinButton&, void); + DECL_LINK(spin_button_input, int* result, bool); + + void signal_value_changed() { m_aValueChangedHdl.Call(*this); } + + sal_Int64 ConvertValue(sal_Int64 nValue, FieldUnit eInUnit, FieldUnit eOutUnit) const; + OUString format_number(sal_Int64 nValue) const; + void update_width_chars(); + +public: + MetricSpinButton(std::unique_ptr<SpinButton> pSpinButton, FieldUnit eSrcUnit) + : m_eSrcUnit(eSrcUnit) + , m_xSpinButton(std::move(pSpinButton)) + { + update_width_chars(); + m_xSpinButton->connect_output(LINK(this, MetricSpinButton, spin_button_output)); + m_xSpinButton->connect_input(LINK(this, MetricSpinButton, spin_button_input)); + m_xSpinButton->connect_value_changed( + LINK(this, MetricSpinButton, spin_button_value_changed)); + spin_button_output(*m_xSpinButton); + } + + static OUString MetricToString(FieldUnit rUnit); + + FieldUnit get_unit() const { return m_eSrcUnit; } + + void set_unit(FieldUnit eUnit); + + sal_Int64 convert_value_to(sal_Int64 nValue, FieldUnit eValueUnit) const + { + return ConvertValue(nValue, m_eSrcUnit, eValueUnit); + } + + sal_Int64 convert_value_from(sal_Int64 nValue, FieldUnit eValueUnit) const + { + return ConvertValue(nValue, eValueUnit, m_eSrcUnit); + } + + void set_value(sal_Int64 nValue, FieldUnit eValueUnit) + { + m_xSpinButton->set_value(convert_value_from(nValue, eValueUnit)); + } + + sal_Int64 get_value(FieldUnit eDestUnit) const + { + return convert_value_to(m_xSpinButton->get_value(), eDestUnit); + } + + // typically you only need to call this if set_text (e.g. with "") was + // previously called to display some arbitrary text instead of the + // formatted value and now you want to show it as formatted again + void reformat() { spin_button_output(*m_xSpinButton); } + + void set_range(sal_Int64 min, sal_Int64 max, FieldUnit eValueUnit) + { + min = convert_value_from(min, eValueUnit); + max = convert_value_from(max, eValueUnit); + m_xSpinButton->set_range(min, max); + update_width_chars(); + } + + void get_range(sal_Int64& min, sal_Int64& max, FieldUnit eDestUnit) const + { + m_xSpinButton->get_range(min, max); + min = convert_value_to(min, eDestUnit); + max = convert_value_to(max, eDestUnit); + } + + void set_min(sal_Int64 min, FieldUnit eValueUnit) + { + sal_Int64 dummy, max; + get_range(dummy, max, eValueUnit); + set_range(min, max, eValueUnit); + } + + void set_max(sal_Int64 max, FieldUnit eValueUnit) + { + sal_Int64 min, dummy; + get_range(min, dummy, eValueUnit); + set_range(min, max, eValueUnit); + } + + sal_Int64 get_min(FieldUnit eValueUnit) const + { + sal_Int64 min, dummy; + get_range(min, dummy, eValueUnit); + return min; + } + + sal_Int64 get_max(FieldUnit eValueUnit) const + { + sal_Int64 dummy, max; + get_range(dummy, max, eValueUnit); + return max; + } + + void set_increments(int step, int page, FieldUnit eValueUnit) + { + step = convert_value_from(step, eValueUnit); + page = convert_value_from(page, eValueUnit); + m_xSpinButton->set_increments(step, page); + } + + void get_increments(int& step, int& page, FieldUnit eDestUnit) const + { + m_xSpinButton->get_increments(step, page); + step = convert_value_to(step, eDestUnit); + page = convert_value_to(page, eDestUnit); + } + + void connect_value_changed(const Link<MetricSpinButton&, void>& rLink) + { + m_aValueChangedHdl = rLink; + } + + sal_Int64 normalize(sal_Int64 nValue) const { return m_xSpinButton->normalize(nValue); } + sal_Int64 denormalize(sal_Int64 nValue) const { return m_xSpinButton->denormalize(nValue); } + void set_sensitive(bool sensitive) { m_xSpinButton->set_sensitive(sensitive); } + bool get_sensitive() const { return m_xSpinButton->get_sensitive(); } + bool get_visible() const { return m_xSpinButton->get_visible(); } + void grab_focus() { m_xSpinButton->grab_focus(); } + bool has_focus() const { return m_xSpinButton->has_focus(); } + void show() { m_xSpinButton->show(); } + void set_visible(bool bShow) { m_xSpinButton->set_visible(bShow); } + void hide() { m_xSpinButton->hide(); } + void set_digits(unsigned int digits); + void set_accessible_name(const OUString& rName) { m_xSpinButton->set_accessible_name(rName); } + unsigned int get_digits() const { return m_xSpinButton->get_digits(); } + void save_value() { m_xSpinButton->save_value(); } + bool get_value_changed_from_saved() const + { + return m_xSpinButton->get_value_changed_from_saved(); + } + void set_text(const OUString& rText) { m_xSpinButton->set_text(rText); } + OUString get_text() const { return m_xSpinButton->get_text(); } + void set_size_request(int nWidth, int nHeight) + { + m_xSpinButton->set_size_request(nWidth, nHeight); + } + Size get_size_request() const { return m_xSpinButton->get_size_request(); } + Size get_preferred_size() const { return m_xSpinButton->get_preferred_size(); } + void connect_focus_in(const Link<Widget&, void>& rLink) + { + m_xSpinButton->connect_focus_in(rLink); + } + void connect_focus_out(const Link<Widget&, void>& rLink) + { + m_xSpinButton->connect_focus_out(rLink); + } + OString get_buildable_name() const { return m_xSpinButton->get_buildable_name(); } + void set_help_id(const OString& rName) { m_xSpinButton->set_help_id(rName); } + void set_position(int nCursorPos) { m_xSpinButton->set_position(nCursorPos); } + // set the width of the underlying widget in characters, this setting is + // invalidated when changing the units, range or digits, so to have effect + // must come after changing those values + void set_width_chars(int nChars) { m_xSpinButton->set_width_chars(nChars); } + int get_width_chars() const { return m_xSpinButton->get_width_chars(); } + weld::SpinButton& get_widget() { return *m_xSpinButton; } +}; + +enum class LabelType +{ + Normal, + Warning, + Error, + Title, // this is intended to be used against the background set by set_title_background +}; + +class VCL_DLLPUBLIC Label : virtual public Widget +{ +public: + virtual void set_label(const OUString& rText) = 0; + virtual OUString get_label() const = 0; + virtual void set_mnemonic_widget(Widget* pTarget) = 0; + // font size is in points, not pixels, e.g. see Window::[G]etPointFont + virtual void set_font(const vcl::Font& rFont) = 0; + virtual void set_label_type(LabelType eType) = 0; + /* + If you want to set a warning or error state, see set_label_type + instead. + */ + virtual void set_font_color(const Color& rColor) = 0; +}; + +class VCL_DLLPUBLIC TextView : virtual public Widget +{ + friend class ::LOKTrigger; + +private: + OUString m_sSavedValue; + +protected: + Link<TextView&, void> m_aChangeHdl; + Link<TextView&, void> m_aVChangeHdl; + Link<TextView&, void> m_aCursorPositionHdl; + + void signal_changed() { m_aChangeHdl.Call(*this); } + void signal_cursor_position() { m_aCursorPositionHdl.Call(*this); } + void signal_vadjustment_changed() { m_aVChangeHdl.Call(*this); } + +public: + virtual void set_text(const OUString& rText) = 0; + virtual OUString get_text() const = 0; + // if nStartPos or nEndPos is -1 the max available text pos will be used + virtual void select_region(int nStartPos, int nEndPos) = 0; + // returns true if the selection has nonzero length + virtual bool get_selection_bounds(int& rStartPos, int& rEndPos) = 0; + virtual void replace_selection(const OUString& rText) = 0; + virtual void set_editable(bool bEditable) = 0; + virtual bool get_editable() const = 0; + virtual void set_monospace(bool bMonospace) = 0; + // The maximum length of the entry. Use 0 for no maximum + virtual void set_max_length(int nChars) = 0; + int get_height_rows(int nRows) const + { + //can improve this if needed + return get_text_height() * nRows; + } + + // font size is in points, not pixels, e.g. see Window::[G]etPointFont + virtual void set_font(const vcl::Font& rFont) = 0; + + /* + Typically you want to avoid the temptation of customizing + font colors + */ + virtual void set_font_color(const Color& rColor) = 0; + + void save_value() { m_sSavedValue = get_text(); } + bool get_value_changed_from_saved() const { return m_sSavedValue != get_text(); } + + void connect_changed(const Link<TextView&, void>& rLink) { m_aChangeHdl = rLink; } + virtual void connect_cursor_position(const Link<TextView&, void>& rLink) + { + m_aCursorPositionHdl = rLink; + } + + // returns true if pressing up would move the cursor + // doesn't matter if that move is to a previous line or to the start of the + // current line just so long as the cursor would move + virtual bool can_move_cursor_with_up() const = 0; + + // returns true if pressing down would move the cursor + // doesn't matter if that move is to a next line or to the end of the + // current line just so long as the cursor would move + virtual bool can_move_cursor_with_down() const = 0; + + virtual void cut_clipboard() = 0; + virtual void copy_clipboard() = 0; + virtual void paste_clipboard() = 0; + + virtual void set_alignment(TxtAlign eXAlign) = 0; + + virtual int vadjustment_get_value() const = 0; + virtual int vadjustment_get_upper() const = 0; + virtual int vadjustment_get_lower() const = 0; + virtual int vadjustment_get_page_size() const = 0; + virtual void vadjustment_set_value(int value) = 0; + void connect_vadjustment_changed(const Link<TextView&, void>& rLink) { m_aVChangeHdl = rLink; } +}; + +class VCL_DLLPUBLIC Expander : virtual public Widget +{ +protected: + Link<Expander&, void> m_aExpandedHdl; + + void signal_expanded() { m_aExpandedHdl.Call(*this); } + +public: + virtual void set_label(const OUString& rText) = 0; + virtual OUString get_label() const = 0; + virtual bool get_expanded() const = 0; + virtual void set_expanded(bool bExpand) = 0; + + void connect_expanded(const Link<Expander&, void>& rLink) { m_aExpandedHdl = rLink; } +}; + +class VCL_DLLPUBLIC DrawingArea : virtual public Widget +{ +public: + typedef std::pair<vcl::RenderContext&, const tools::Rectangle&> draw_args; + +protected: + Link<draw_args, void> m_aDrawHdl; + Link<Widget&, void> m_aStyleUpdatedHdl; + Link<const CommandEvent&, bool> m_aCommandHdl; + Link<Widget&, tools::Rectangle> m_aGetFocusRectHdl; + Link<tools::Rectangle&, OUString> m_aQueryTooltipHdl; + // if handler returns true, drag is disallowed + Link<DrawingArea&, bool> m_aDragBeginHdl; + // return position of cursor, fill OUString& with surrounding text + Link<OUString&, int> m_aGetSurroundingHdl; + // attempt to delete the range, return true if successful + Link<const Selection&, bool> m_aDeleteSurroundingHdl; + + OUString signal_query_tooltip(tools::Rectangle& rHelpArea) + { + return m_aQueryTooltipHdl.Call(rHelpArea); + } + + int signal_im_context_get_surrounding(OUString& rSurroundingText) + { + if (!m_aGetSurroundingHdl.IsSet()) + return -1; + return m_aGetSurroundingHdl.Call(rSurroundingText); + } + + bool signal_im_context_delete_surrounding(const Selection& rRange) + { + return m_aDeleteSurroundingHdl.Call(rRange); + } + +public: + void connect_draw(const Link<draw_args, void>& rLink) { m_aDrawHdl = rLink; } + void connect_style_updated(const Link<Widget&, void>& rLink) { m_aStyleUpdatedHdl = rLink; } + void connect_command(const Link<const CommandEvent&, bool>& rLink) { m_aCommandHdl = rLink; } + void connect_focus_rect(const Link<Widget&, tools::Rectangle>& rLink) + { + m_aGetFocusRectHdl = rLink; + } + void connect_query_tooltip(const Link<tools::Rectangle&, OUString>& rLink) + { + m_aQueryTooltipHdl = rLink; + } + void connect_drag_begin(const Link<DrawingArea&, bool>& rLink) { m_aDragBeginHdl = rLink; } + void connect_im_context_get_surrounding(const Link<OUString&, int>& rLink) + { + m_aGetSurroundingHdl = rLink; + } + void connect_im_context_delete_surrounding(const Link<const Selection&, bool>& rLink) + { + m_aDeleteSurroundingHdl = rLink; + } + virtual void queue_draw() = 0; + virtual void queue_draw_area(int x, int y, int width, int height) = 0; + + virtual void enable_drag_source(rtl::Reference<TransferDataContainer>& rTransferrable, + sal_uInt8 eDNDConstants) + = 0; + + virtual void set_cursor(PointerStyle ePointerStyle) = 0; + + virtual Point get_pointer_position() const = 0; + + virtual void set_input_context(const InputContext& rInputContext) = 0; + virtual void im_context_set_cursor_location(const tools::Rectangle& rCursorRect, + int nExtTextInputWidth) + = 0; + + // use return here just to generate matching VirtualDevices + virtual OutputDevice& get_ref_device() = 0; + + virtual a11yref get_accessible_parent() = 0; + virtual a11yrelationset get_accessible_relation_set() = 0; + virtual Point get_accessible_location_on_screen() = 0; + +private: + friend class ::LOKTrigger; + + virtual void click(const Point& rPos) = 0; +}; + +enum class Placement +{ + Under, + End +}; + +class VCL_DLLPUBLIC Menu +{ +protected: + Link<const OString&, void> m_aActivateHdl; + + void signal_activate(const OString& rIdent) { m_aActivateHdl.Call(rIdent); } + +public: + virtual OString popup_at_rect(weld::Widget* pParent, const tools::Rectangle& rRect, + Placement ePlace = Placement::Under) + = 0; + + void connect_activate(const Link<const OString&, void>& rLink) { m_aActivateHdl = rLink; } + + virtual void set_sensitive(const OString& rIdent, bool bSensitive) = 0; + virtual bool get_sensitive(const OString& rIdent) const = 0; + virtual void set_label(const OString& rIdent, const OUString& rLabel) = 0; + virtual OUString get_label(const OString& rIdent) const = 0; + virtual void set_active(const OString& rIdent, bool bActive) = 0; + virtual bool get_active(const OString& rIdent) const = 0; + virtual void set_visible(const OString& rIdent, bool bVisible) = 0; + + virtual void insert(int pos, const OUString& rId, const OUString& rStr, + const OUString* pIconName, VirtualDevice* pImageSurface, + const css::uno::Reference<css::graphic::XGraphic>& rImage, + TriState eCheckRadioFalse) + = 0; + + virtual void remove(const OString& rId) = 0; + + virtual void clear() = 0; + + virtual void insert_separator(int pos, const OUString& rId) = 0; + void append_separator(const OUString& rId) { insert_separator(-1, rId); } + + void append(const OUString& rId, const OUString& rStr) + { + insert(-1, rId, rStr, nullptr, nullptr, nullptr, TRISTATE_INDET); + } + void append_check(const OUString& rId, const OUString& rStr) + { + insert(-1, rId, rStr, nullptr, nullptr, nullptr, TRISTATE_TRUE); + } + void append_radio(const OUString& rId, const OUString& rStr) + { + insert(-1, rId, rStr, nullptr, nullptr, nullptr, TRISTATE_FALSE); + } + void append(const OUString& rId, const OUString& rStr, const OUString& rImage) + { + insert(-1, rId, rStr, &rImage, nullptr, nullptr, TRISTATE_INDET); + } + void append(const OUString& rId, const OUString& rStr, VirtualDevice& rImage) + { + insert(-1, rId, rStr, nullptr, &rImage, nullptr, TRISTATE_INDET); + } + + // return the number of toplevel nodes + virtual int n_children() const = 0; + + virtual OString get_id(int pos) const = 0; + + virtual ~Menu() {} +}; + +class VCL_DLLPUBLIC Popover : virtual public Container +{ + friend class ::LOKTrigger; + +private: + Link<weld::Popover&, void> m_aCloseHdl; + +protected: + void signal_closed() { m_aCloseHdl.Call(*this); } + +public: + virtual void popup_at_rect(weld::Widget* pParent, const tools::Rectangle& rRect, + Placement ePlace = Placement::Under) + = 0; + virtual void popdown() = 0; + + virtual void resize_to_request() = 0; + + void connect_closed(const Link<weld::Popover&, void>& rLink) { m_aCloseHdl = rLink; } +}; + +class VCL_DLLPUBLIC Toolbar : virtual public Widget +{ +protected: + Link<const OString&, void> m_aClickHdl; + Link<const OString&, void> m_aToggleMenuHdl; + + friend class ::LOKTrigger; + + void signal_clicked(const OString& rIdent) { m_aClickHdl.Call(rIdent); } + void signal_toggle_menu(const OString& rIdent) { m_aToggleMenuHdl.Call(rIdent); } + +public: + virtual void set_item_sensitive(const OString& rIdent, bool bSensitive) = 0; + virtual bool get_item_sensitive(const OString& rIdent) const = 0; + virtual void set_item_active(const OString& rIdent, bool bActive) = 0; + virtual bool get_item_active(const OString& rIdent) const = 0; + virtual void set_menu_item_active(const OString& rIdent, bool bActive) = 0; + virtual bool get_menu_item_active(const OString& rIdent) const = 0; + virtual void set_item_menu(const OString& rIdent, weld::Menu* pMenu) = 0; + virtual void set_item_popover(const OString& rIdent, weld::Widget* pPopover) = 0; + virtual void set_item_visible(const OString& rIdent, bool bVisible) = 0; + virtual void set_item_help_id(const OString& rIdent, const OString& rHelpId) = 0; + virtual bool get_item_visible(const OString& rIdent) const = 0; + virtual void set_item_label(const OString& rIdent, const OUString& rLabel) = 0; + virtual OUString get_item_label(const OString& rIdent) const = 0; + virtual void set_item_tooltip_text(const OString& rIdent, const OUString& rTip) = 0; + virtual OUString get_item_tooltip_text(const OString& rIdent) const = 0; + virtual void set_item_icon_name(const OString& rIdent, const OUString& rIconName) = 0; + virtual void set_item_image(const OString& rIdent, + const css::uno::Reference<css::graphic::XGraphic>& rIcon) + = 0; + virtual void set_item_image(const OString& rIdent, VirtualDevice* pDevice) = 0; + + virtual void insert_item(int pos, const OUString& rId) = 0; + virtual void insert_separator(int pos, const OUString& rId) = 0; + void append_separator(const OUString& rId) { insert_separator(-1, rId); } + + virtual int get_n_items() const = 0; + virtual OString get_item_ident(int nIndex) const = 0; + virtual void set_item_ident(int nIndex, const OString& rIdent) = 0; + virtual void set_item_label(int nIndex, const OUString& rLabel) = 0; + virtual void set_item_image(int nIndex, + const css::uno::Reference<css::graphic::XGraphic>& rIcon) + = 0; + virtual void set_item_tooltip_text(int nIndex, const OUString& rTip) = 0; + + virtual vcl::ImageType get_icon_size() const = 0; + virtual void set_icon_size(vcl::ImageType eType) = 0; + + // return what modifiers are held + virtual sal_uInt16 get_modifier_state() const = 0; + + // This function returns the position a new item should be inserted if dnd + // is dropped at rPoint + virtual int get_drop_index(const Point& rPoint) const = 0; + + void connect_clicked(const Link<const OString&, void>& rLink) { m_aClickHdl = rLink; } + void connect_menu_toggled(const Link<const OString&, void>& rLink) { m_aToggleMenuHdl = rLink; } +}; + +class VCL_DLLPUBLIC SizeGroup +{ +public: + virtual void add_widget(weld::Widget* pWidget) = 0; + // the default mode is VclSizeGroupMode::Horizontal + virtual void set_mode(VclSizeGroupMode eMode) = 0; + virtual ~SizeGroup() {} +}; + +class VCL_DLLPUBLIC Builder +{ +public: + virtual std::unique_ptr<MessageDialog> weld_message_dialog(const OString& id) = 0; + virtual std::unique_ptr<Dialog> weld_dialog(const OString& id) = 0; + virtual std::unique_ptr<Assistant> weld_assistant(const OString& id) = 0; + virtual std::unique_ptr<Widget> weld_widget(const OString& id) = 0; + virtual std::unique_ptr<Container> weld_container(const OString& id) = 0; + virtual std::unique_ptr<Box> weld_box(const OString& id) = 0; + virtual std::unique_ptr<Paned> weld_paned(const OString& id) = 0; + virtual std::unique_ptr<Button> weld_button(const OString& id) = 0; + virtual std::unique_ptr<MenuButton> weld_menu_button(const OString& id) = 0; + virtual std::unique_ptr<MenuToggleButton> weld_menu_toggle_button(const OString& id) = 0; + virtual std::unique_ptr<Frame> weld_frame(const OString& id) = 0; + /* bUserManagedScrolling of true means that the automatic scrolling of the window is disabled + and the owner must specifically listen to adjustment changes and react appropriately to them. + */ + virtual std::unique_ptr<ScrolledWindow> weld_scrolled_window(const OString& id, + bool bUserManagedScrolling = false) + = 0; + virtual std::unique_ptr<Notebook> weld_notebook(const OString& id) = 0; + virtual std::unique_ptr<ToggleButton> weld_toggle_button(const OString& id) = 0; + virtual std::unique_ptr<RadioButton> weld_radio_button(const OString& id) = 0; + virtual std::unique_ptr<CheckButton> weld_check_button(const OString& id) = 0; + virtual std::unique_ptr<LinkButton> weld_link_button(const OString& id) = 0; + virtual std::unique_ptr<SpinButton> weld_spin_button(const OString& id) = 0; + virtual std::unique_ptr<MetricSpinButton> weld_metric_spin_button(const OString& id, + FieldUnit eUnit) + = 0; + virtual std::unique_ptr<FormattedSpinButton> weld_formatted_spin_button(const OString& id) = 0; + virtual std::unique_ptr<ComboBox> weld_combo_box(const OString& id) = 0; + virtual std::unique_ptr<TreeView> weld_tree_view(const OString& id) = 0; + virtual std::unique_ptr<IconView> weld_icon_view(const OString& id) = 0; + virtual std::unique_ptr<Label> weld_label(const OString& id) = 0; + virtual std::unique_ptr<TextView> weld_text_view(const OString& id) = 0; + virtual std::unique_ptr<Expander> weld_expander(const OString& id) = 0; + virtual std::unique_ptr<Entry> weld_entry(const OString& id) = 0; + virtual std::unique_ptr<Scale> weld_scale(const OString& id) = 0; + virtual std::unique_ptr<ProgressBar> weld_progress_bar(const OString& id) = 0; + virtual std::unique_ptr<Spinner> weld_spinner(const OString& id) = 0; + virtual std::unique_ptr<Image> weld_image(const OString& id) = 0; + virtual std::unique_ptr<Calendar> weld_calendar(const OString& id) = 0; + virtual std::unique_ptr<DrawingArea> + weld_drawing_area(const OString& id, const a11yref& rA11yImpl = nullptr, + FactoryFunction pUITestFactoryFunction = nullptr, void* pUserData = nullptr) + = 0; + virtual std::unique_ptr<EntryTreeView> weld_entry_tree_view(const OString& containerid, + const OString& entryid, + const OString& treeviewid) + = 0; + virtual std::unique_ptr<Menu> weld_menu(const OString& id) = 0; + virtual std::unique_ptr<Popover> weld_popover(const OString& id) = 0; + virtual std::unique_ptr<Toolbar> weld_toolbar(const OString& id) = 0; + virtual std::unique_ptr<SizeGroup> create_size_group() = 0; + /* return a Dialog suitable to take a screenshot of containing the contents of the .ui file. + + If the toplevel element is a dialog, that will be returned + If the toplevel is not a dialog, a dialog will be created and the contents of the .ui + inserted into it + */ + virtual std::unique_ptr<Window> create_screenshot_window() = 0; + virtual ~Builder() {} +}; + +class VCL_DLLPUBLIC DialogController : public std::enable_shared_from_this<DialogController> +{ +public: + virtual Dialog* getDialog() = 0; + const Dialog* getConstDialog() const + { + return const_cast<DialogController*>(this)->getDialog(); + } + virtual short run() { return getDialog()->run(); } + static bool runAsync(const std::shared_ptr<DialogController>& rController, + const std::function<void(sal_Int32)>&); + void set_title(const OUString& rTitle) { getDialog()->set_title(rTitle); } + OUString get_title() const { return getConstDialog()->get_title(); } + void set_help_id(const OString& rHelpId) { getDialog()->set_help_id(rHelpId); } + OString get_help_id() const { return getConstDialog()->get_help_id(); } + void response(int nResponse) { getDialog()->response(nResponse); } + virtual ~DialogController() COVERITY_NOEXCEPT_FALSE; +}; + +class VCL_DLLPUBLIC GenericDialogController : public DialogController +{ +protected: + std::unique_ptr<weld::Builder> m_xBuilder; + std::shared_ptr<weld::Dialog> m_xDialog; + +public: + GenericDialogController(weld::Widget* pParent, const OUString& rUIFile, + const OString& rDialogId, bool bMobile = false); + virtual Dialog* getDialog() override; + virtual ~GenericDialogController() COVERITY_NOEXCEPT_FALSE override; +}; + +class VCL_DLLPUBLIC MessageDialogController : public DialogController +{ +protected: + std::unique_ptr<weld::Builder> m_xBuilder; + std::unique_ptr<weld::MessageDialog> m_xDialog; + std::unique_ptr<weld::Container> m_xContentArea; + std::unique_ptr<weld::Widget> m_xRelocate; + std::unique_ptr<weld::Container> m_xOrigParent; + +public: + /* @param rRelocateId - optional argument of the name of a widget in the .ui file + which should be relocated into the content area of the dialog. + + e.g. a checkbox for a "Never show this again" option. + + This results in the named widget relocating to the same container + as the messages. This enables aligning the extra widget with the + message labels in the content area container which doesn't + explicitly exist in the ui description, but is only implied. + */ + MessageDialogController(weld::Widget* pParent, const OUString& rUIFile, + const OString& rDialogId, const OString& rRelocateId = OString()); + virtual Dialog* getDialog() override; + virtual ~MessageDialogController() override; + void set_primary_text(const OUString& rText) { m_xDialog->set_primary_text(rText); } + OUString get_primary_text() const { return m_xDialog->get_primary_text(); } + void set_default_response(int nResponse) { m_xDialog->set_default_response(nResponse); } +}; + +class VCL_DLLPUBLIC AssistantController : public DialogController +{ +protected: + std::unique_ptr<weld::Builder> m_xBuilder; + std::unique_ptr<weld::Assistant> m_xAssistant; + +public: + AssistantController(weld::Widget* pParent, const OUString& rUIFile, const OString& rDialogId); + virtual Dialog* getDialog() override; + virtual ~AssistantController() override; +}; +} +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/weldutils.hxx b/include/vcl/weldutils.hxx new file mode 100644 index 000000000..07fc5eb2d --- /dev/null +++ b/include/vcl/weldutils.hxx @@ -0,0 +1,471 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_VCL_WELDUTILS_HXX +#define INCLUDED_VCL_WELDUTILS_HXX + +#include <com/sun/star/awt/XWindow.hpp> +#include <com/sun/star/frame/XDispatch.hpp> +#include <com/sun/star/frame/XFrame.hpp> +#include <com/sun/star/frame/XStatusListener.hpp> +#include <com/sun/star/uno/Reference.hxx> +#include <comphelper/interfacecontainer4.hxx> +#include <comphelper/compbase.hxx> +#include <tools/time.hxx> +#include <vcl/dllapi.h> +#include <vcl/formatter.hxx> +#include <vcl/timer.hxx> +#include <vcl/transfer.hxx> +#include <vcl/weld.hxx> + +class CalendarWrapper; + +namespace vcl +{ +class Window; +} + +namespace weld +{ +typedef comphelper::WeakComponentImplHelper<css::awt::XWindow> TransportAsXWindow_Base; + +class VCL_DLLPUBLIC TransportAsXWindow : public TransportAsXWindow_Base +{ +private: + weld::Widget* m_pWeldWidget; + weld::Builder* m_pWeldWidgetBuilder; + + comphelper::OInterfaceContainerHelper4<css::awt::XWindowListener> m_aWindowListeners; + comphelper::OInterfaceContainerHelper4<css::awt::XKeyListener> m_aKeyListeners; + comphelper::OInterfaceContainerHelper4<css::awt::XFocusListener> m_aFocusListeners; + comphelper::OInterfaceContainerHelper4<css::awt::XMouseListener> m_aMouseListeners; + comphelper::OInterfaceContainerHelper4<css::awt::XMouseMotionListener> m_aMotionListeners; + comphelper::OInterfaceContainerHelper4<css::awt::XPaintListener> m_aPaintListeners; + +public: + TransportAsXWindow(weld::Widget* pWeldWidget, weld::Builder* pWeldWidgetBuilder = nullptr) + : m_pWeldWidget(pWeldWidget) + , m_pWeldWidgetBuilder(pWeldWidgetBuilder) + { + } + + weld::Widget* getWidget() const { return m_pWeldWidget; } + + weld::Builder* getBuilder() const { return m_pWeldWidgetBuilder; } + + virtual void clear() + { + m_pWeldWidget = nullptr; + m_pWeldWidgetBuilder = nullptr; + } + + // css::awt::XWindow + void SAL_CALL setPosSize(sal_Int32, sal_Int32, sal_Int32, sal_Int32, sal_Int16) override + { + throw css::uno::RuntimeException("not implemented"); + } + + css::awt::Rectangle SAL_CALL getPosSize() override + { + throw css::uno::RuntimeException("not implemented"); + } + + void SAL_CALL setVisible(sal_Bool bVisible) override { m_pWeldWidget->set_visible(bVisible); } + + void SAL_CALL setEnable(sal_Bool bSensitive) override + { + m_pWeldWidget->set_sensitive(bSensitive); + } + + void SAL_CALL setFocus() override { m_pWeldWidget->grab_focus(); } + + void SAL_CALL + addWindowListener(const css::uno::Reference<css::awt::XWindowListener>& rListener) override + { + std::unique_lock g(m_aMutex); + m_aWindowListeners.addInterface(g, rListener); + } + + void SAL_CALL + removeWindowListener(const css::uno::Reference<css::awt::XWindowListener>& rListener) override + { + std::unique_lock g(m_aMutex); + m_aWindowListeners.removeInterface(g, rListener); + } + + void SAL_CALL + addFocusListener(const css::uno::Reference<css::awt::XFocusListener>& rListener) override + { + std::unique_lock g(m_aMutex); + m_aFocusListeners.addInterface(g, rListener); + } + + void SAL_CALL + removeFocusListener(const css::uno::Reference<css::awt::XFocusListener>& rListener) override + { + std::unique_lock g(m_aMutex); + m_aFocusListeners.removeInterface(g, rListener); + } + + void SAL_CALL + addKeyListener(const css::uno::Reference<css::awt::XKeyListener>& rListener) override + { + std::unique_lock g(m_aMutex); + m_aKeyListeners.addInterface(g, rListener); + } + + void SAL_CALL + removeKeyListener(const css::uno::Reference<css::awt::XKeyListener>& rListener) override + { + std::unique_lock g(m_aMutex); + m_aKeyListeners.removeInterface(g, rListener); + } + + void SAL_CALL + addMouseListener(const css::uno::Reference<css::awt::XMouseListener>& rListener) override + { + std::unique_lock g(m_aMutex); + m_aMouseListeners.addInterface(g, rListener); + } + + void SAL_CALL + removeMouseListener(const css::uno::Reference<css::awt::XMouseListener>& rListener) override + { + std::unique_lock g(m_aMutex); + m_aMouseListeners.removeInterface(g, rListener); + } + + void SAL_CALL addMouseMotionListener( + const css::uno::Reference<css::awt::XMouseMotionListener>& rListener) override + { + std::unique_lock g(m_aMutex); + m_aMotionListeners.addInterface(g, rListener); + } + + void SAL_CALL removeMouseMotionListener( + const css::uno::Reference<css::awt::XMouseMotionListener>& rListener) override + { + std::unique_lock g(m_aMutex); + m_aMotionListeners.removeInterface(g, rListener); + } + + void SAL_CALL + addPaintListener(const css::uno::Reference<css::awt::XPaintListener>& rListener) override + { + std::unique_lock g(m_aMutex); + m_aPaintListeners.addInterface(g, rListener); + } + + void SAL_CALL + removePaintListener(const css::uno::Reference<css::awt::XPaintListener>& rListener) override + { + std::unique_lock g(m_aMutex); + m_aPaintListeners.removeInterface(g, rListener); + } +}; + +// don't export to avoid duplicate WeakImplHelper definitions with MSVC +class SAL_DLLPUBLIC_TEMPLATE WidgetStatusListener_Base + : public cppu::WeakImplHelper<css::frame::XStatusListener> +{ +}; + +class VCL_DLLPUBLIC WidgetStatusListener final : public WidgetStatusListener_Base +{ +public: + WidgetStatusListener(weld::Widget* widget, const OUString& rCommand); + +private: + weld::Widget* mWidget; /** The widget on which actions are performed */ + + /** Dispatcher. Need to keep a reference to it as long as this StatusListener exists. */ + css::uno::Reference<css::frame::XDispatch> mxDispatch; + css::util::URL maCommandURL; + css::uno::Reference<css::frame::XFrame> mxFrame; + +public: + SAL_DLLPRIVATE void SAL_CALL + statusChanged(const css::frame::FeatureStateEvent& rEvent) override; + + SAL_DLLPRIVATE void SAL_CALL disposing(const css::lang::EventObject& /*Source*/) override; + + const css::uno::Reference<css::frame::XFrame>& getFrame() const { return mxFrame; } + + void startListening(); + + void dispose(); +}; + +class VCL_DLLPUBLIC EntryFormatter : public Formatter +{ +public: + EntryFormatter(weld::Entry& rEntry); + EntryFormatter(weld::FormattedSpinButton& rSpinButton); + + weld::Entry& get_widget() { return m_rEntry; } + + // public Formatter overrides, drives interactions with the Entry + SAL_DLLPRIVATE virtual Selection GetEntrySelection() const override; + SAL_DLLPRIVATE virtual OUString GetEntryText() const override; + SAL_DLLPRIVATE virtual void SetEntryText(const OUString& rText, const Selection& rSel) override; + SAL_DLLPRIVATE virtual void SetEntryTextColor(const Color* pColor) override; + SAL_DLLPRIVATE virtual SelectionOptions GetEntrySelectionOptions() const override; + SAL_DLLPRIVATE virtual void FieldModified() override; + + // public Formatter overrides, drives optional SpinButton settings + SAL_DLLPRIVATE virtual void ClearMinValue() override; + SAL_DLLPRIVATE virtual void SetMinValue(double dMin) override; + SAL_DLLPRIVATE virtual void ClearMaxValue() override; + SAL_DLLPRIVATE virtual void SetMaxValue(double dMin) override; + + SAL_DLLPRIVATE virtual void SetSpinSize(double dStep) override; + + void SetEntrySelectionOptions(SelectionOptions eOptions) { m_eOptions = eOptions; } + + /* EntryFormatter will set listeners to "changed" and "focus-out" of the + Entry so users that want to add their own listeners to those must set + them through this formatter and not directly on that entry. + + If EntryFormatter is used with a weld::FormattedSpinButton this is + handled transparently by the FormattedSpinButton for the user and the + handlers can be set on the FormattedSpinButton + */ + void connect_changed(const Link<weld::Entry&, void>& rLink) { m_aModifyHdl = rLink; } + void connect_focus_out(const Link<weld::Widget&, void>& rLink) { m_aFocusOutHdl = rLink; } + + SAL_DLLPRIVATE virtual ~EntryFormatter() override; + +private: + weld::Entry& m_rEntry; + weld::FormattedSpinButton* m_pSpinButton; + Link<weld::Entry&, void> m_aModifyHdl; + Link<weld::Widget&, void> m_aFocusOutHdl; + SelectionOptions m_eOptions; + DECL_DLLPRIVATE_LINK(ModifyHdl, weld::Entry&, void); + DECL_DLLPRIVATE_LINK(FocusOutHdl, weld::Widget&, void); + SAL_DLLPRIVATE void Init(); + + // private Formatter overrides + SAL_DLLPRIVATE virtual void UpdateCurrentValue(double dCurrentValue) override; +}; + +class VCL_DLLPUBLIC DoubleNumericFormatter final : public EntryFormatter +{ +public: + DoubleNumericFormatter(weld::Entry& rEntry); + DoubleNumericFormatter(weld::FormattedSpinButton& rSpinButton); + + SAL_DLLPRIVATE virtual ~DoubleNumericFormatter() override; + +private: + SAL_DLLPRIVATE virtual bool CheckText(const OUString& sText) const override; + + SAL_DLLPRIVATE virtual void FormatChanged(FORMAT_CHANGE_TYPE nWhat) override; + SAL_DLLPRIVATE void ResetConformanceTester(); + + std::unique_ptr<validation::NumberValidator> m_pNumberValidator; +}; + +class VCL_DLLPUBLIC LongCurrencyFormatter final : public EntryFormatter +{ +public: + LongCurrencyFormatter(weld::Entry& rEntry); + LongCurrencyFormatter(weld::FormattedSpinButton& rSpinButton); + + void SetUseThousandSep(bool b); + void SetCurrencySymbol(const OUString& rStr); + + SAL_DLLPRIVATE virtual ~LongCurrencyFormatter() override; + +private: + DECL_DLLPRIVATE_LINK(FormatOutputHdl, LinkParamNone*, bool); + DECL_DLLPRIVATE_LINK(ParseInputHdl, sal_Int64*, TriState); + + SAL_DLLPRIVATE void Init(); + + OUString m_aCurrencySymbol; + bool m_bThousandSep; +}; + +class VCL_DLLPUBLIC TimeFormatter final : public EntryFormatter +{ +public: + TimeFormatter(weld::Entry& rEntry); + TimeFormatter(weld::FormattedSpinButton& rSpinButton); + + void SetExtFormat(ExtTimeFieldFormat eFormat); + void SetDuration(bool bDuration); + void SetTimeFormat(TimeFieldFormat eTimeFormat); + + void SetMin(const tools::Time& rNewMin); + void SetMax(const tools::Time& rNewMax); + + void SetTime(const tools::Time& rNewTime); + tools::Time GetTime(); + + virtual ~TimeFormatter() override; + +private: + DECL_DLLPRIVATE_LINK(FormatOutputHdl, LinkParamNone*, bool); + DECL_DLLPRIVATE_LINK(ParseInputHdl, sal_Int64*, TriState); + DECL_DLLPRIVATE_LINK(CursorChangedHdl, weld::Entry&, void); + + SAL_DLLPRIVATE void Init(); + + SAL_DLLPRIVATE static tools::Time ConvertValue(int nValue); + SAL_DLLPRIVATE static int ConvertValue(const tools::Time& rTime); + + SAL_DLLPRIVATE OUString FormatNumber(int nValue) const; + + TimeFieldFormat m_eFormat; + TimeFormat m_eTimeFormat; + bool m_bDuration; +}; + +class VCL_DLLPUBLIC DateFormatter final : public EntryFormatter +{ +public: + DateFormatter(weld::Entry& rEntry); + + void SetMin(const Date& rNewMin); + void SetMax(const Date& rNewMax); + + void SetDate(const Date& rNewDate); + Date GetDate(); + + void SetExtDateFormat(ExtDateFieldFormat eFormat); + void SetShowDateCentury(bool bShowCentury); + + virtual ~DateFormatter() override; + +private: + DECL_DLLPRIVATE_LINK(FormatOutputHdl, LinkParamNone*, bool); + DECL_DLLPRIVATE_LINK(ParseInputHdl, sal_Int64*, TriState); + DECL_DLLPRIVATE_LINK(CursorChangedHdl, weld::Entry&, void); + + SAL_DLLPRIVATE void Init(); + SAL_DLLPRIVATE CalendarWrapper& GetCalendarWrapper() const; + + SAL_DLLPRIVATE OUString FormatNumber(int nValue) const; + + ExtDateFieldFormat m_eFormat; + mutable std::unique_ptr<CalendarWrapper> m_xCalendarWrapper; +}; + +class VCL_DLLPUBLIC PatternFormatter final +{ +public: + PatternFormatter(weld::Entry& rEntry); + ~PatternFormatter(); + + weld::Entry& get_widget() { return m_rEntry; } + + void SetMask(const OString& rEditMask, const OUString& rLiteralMask); + void SetStrictFormat(bool bStrict); + void ReformatAll(); + + /* PatternFormatter will set listeners to "changed", "focus-out", "focus-in" + and "key-press" of the Entry so users that want to add their own listeners + to those must set them through this formatter and not directly on that entry. + */ + void connect_changed(const Link<weld::Entry&, void>& rLink) { m_aModifyHdl = rLink; } + void connect_focus_out(const Link<weld::Widget&, void>& rLink) { m_aFocusOutHdl = rLink; } + void connect_focus_in(const Link<weld::Widget&, void>& rLink) { m_aFocusInHdl = rLink; } + void connect_key_press(const Link<const KeyEvent&, bool>& rLink) { m_aKeyPressHdl = rLink; } + + SAL_DLLPRIVATE void Modify(); + +private: + weld::Entry& m_rEntry; + Link<weld::Entry&, void> m_aModifyHdl; + Link<weld::Widget&, void> m_aFocusInHdl; + Link<weld::Widget&, void> m_aFocusOutHdl; + Link<const KeyEvent&, bool> m_aKeyPressHdl; + bool m_bStrictFormat; + bool m_bSameMask; + bool m_bReformat; + bool m_bInPattKeyInput; + OString m_aEditMask; + OUString m_aLiteralMask; + + SAL_DLLPRIVATE void EntryGainFocus(); + SAL_DLLPRIVATE void EntryLostFocus(); + DECL_DLLPRIVATE_LINK(ModifyHdl, weld::Entry&, void); + DECL_DLLPRIVATE_LINK(FocusInHdl, weld::Widget&, void); + DECL_DLLPRIVATE_LINK(FocusOutHdl, weld::Widget&, void); + DECL_DLLPRIVATE_LINK(KeyInputHdl, const KeyEvent&, bool); +}; + +class VCL_DLLPUBLIC ButtonPressRepeater final + : public std::enable_shared_from_this<ButtonPressRepeater> +{ +private: + weld::Button& m_rButton; + AutoTimer m_aRepeat; + const Link<Button&, void> m_aLink; + const Link<const CommandEvent&, void> m_aContextLink; + bool m_bModKey; + + DECL_DLLPRIVATE_LINK(MousePressHdl, const MouseEvent&, bool); + DECL_DLLPRIVATE_LINK(MouseReleaseHdl, const MouseEvent&, bool); + DECL_DLLPRIVATE_LINK(RepeatTimerHdl, Timer*, void); + +public: + ButtonPressRepeater(weld::Button& rButton, const Link<Button&, void>& rLink, + const Link<const CommandEvent&, void>& rContextLink + = Link<const CommandEvent&, void>()); + void Stop() { m_aRepeat.Stop(); } + bool IsModKeyPressed() const { return m_bModKey; } +}; + +/* + If a TreeView is used as a list, rather than a tree, and DnD should just + reorder rows, then this can be used to implement that. + + Because the TreeView doesn't want or need subnodes, the drop target can be + simply visually indicated as being between rows (the issue of a final drop + location of a child of the drop target doesn't arise), and the meaning of + what a drop before or after the last row should do is unambiguous. +*/ +class VCL_DLLPUBLIC ReorderingDropTarget : public DropTargetHelper +{ +protected: + weld::TreeView& m_rTreeView; + virtual sal_Int8 AcceptDrop(const AcceptDropEvent& rEvt) override; + virtual sal_Int8 ExecuteDrop(const ExecuteDropEvent& rEvt) override; + +public: + ReorderingDropTarget(weld::TreeView& rTreeView); +}; + +// get the row the iterator is on +VCL_DLLPUBLIC size_t GetAbsPos(const weld::TreeView& rTreeView, const weld::TreeIter& rIter); + +// an entry is visible if all parents are expanded +VCL_DLLPUBLIC bool IsEntryVisible(const weld::TreeView& rTreeView, const weld::TreeIter& rIter); + +// A Parent's Children are turned into Children of the Parent which comes next in hierarchy +VCL_DLLPUBLIC void RemoveParentKeepChildren(weld::TreeView& rTreeView, + const weld::TreeIter& rParent); + +// return the min height of a weld::Entry +VCL_DLLPUBLIC int GetMinimumEditHeight(); + +// return the weld::Window of the SalFrame rOutWin is in, and convert rRect +// from relative to rOutWin to relative to that weld::Window suitable for use +// with popup_at_rect +VCL_DLLPUBLIC weld::Window* GetPopupParent(vcl::Window& rOutWin, tools::Rectangle& rRect); + +// Use Application::GetDefaultDevice to set the PointFont rFont to the OutputDevice +VCL_DLLPUBLIC void SetPointFont(OutputDevice& rDevice, const vcl::Font& rFont); +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/window.hxx b/include/vcl/window.hxx new file mode 100644 index 000000000..5ad39489f --- /dev/null +++ b/include/vcl/window.hxx @@ -0,0 +1,1586 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_WINDOW_HXX +#define INCLUDED_VCL_WINDOW_HXX + +#include <vcl/dllapi.h> +#include <vcl/outdev.hxx> +#include <tools/link.hxx> +#include <tools/wintypes.hxx> +#include <vcl/vclenum.hxx> +#include <vcl/keycodes.hxx> +#include <vcl/region.hxx> +#include <vcl/uitest/factory.hxx> +#include <vcl/IDialogRenderable.hxx> +#include <rtl/ustring.hxx> +#include <com/sun/star/uno/Reference.hxx> +#include <memory> + +class VirtualDevice; +struct ImplSVEvent; +struct ImplWinData; +struct ImplFrameData; +struct ImplCalcToTopData; +struct SystemEnvData; +struct SystemParentData; +class ImplBorderWindow; +class Timer; +class DockingManager; +class ScrollBar; +class FixedText; +class MouseEvent; +class KeyEvent; +class CommandEvent; +class TrackingEvent; +class HelpEvent; +class DataChangedEvent; +class VclSimpleEvent; +class NotifyEvent; +class SystemWindow; +class SalFrame; +class MenuFloatingWindow; +class VCLXWindow; +class VclWindowEvent; +class AllSettings; +class InputContext; +class VclEventListeners; +enum class ImplPaintFlags; +enum class VclEventId; +enum class PointerStyle; + +namespace com::sun::star { + namespace accessibility { + struct AccessibleRelation; + class XAccessible; + } + namespace rendering { + class XCanvas; + class XSpriteCanvas; + } + namespace awt { + class XWindowPeer; + } + namespace uno { + class Any; + } + namespace datatransfer::clipboard { + class XClipboard; + } + namespace datatransfer::dnd { + class XDragGestureRecognizer; + class XDragSource; + class XDropTarget; + } +} + +namespace vcl { + struct ControlLayoutData; +} + +namespace svt { class PopupWindowControllerImpl; } + +namespace weld { class Window; } + +template<class T> class VclPtr; +namespace tools { class JsonWriter; } + +// Type for GetWindow() +enum class GetWindowType +{ + Parent = 0, + FirstChild = 1, + LastChild = 2, + Prev = 3, + Next = 4, + FirstOverlap = 5, + Overlap = 7, + ParentOverlap = 8, + Client = 9, + RealParent = 10, + Frame = 11, + Border = 12, + FirstTopWindowChild = 13, + NextTopWindowSibling = 16, +}; + +// Flags for setPosSizePixel() +// These must match the definitions in css::awt::PosSize +enum class PosSizeFlags +{ + NONE = 0x0000, + X = 0x0001, + Y = 0x0002, + Width = 0x0004, + Height = 0x0008, + Pos = X | Y, + Size = Width | Height, + PosSize = Pos | Size, + All = PosSize, +}; + +namespace o3tl +{ + template<> struct typed_flags<PosSizeFlags> : is_typed_flags<PosSizeFlags, 0x000f> {}; +} + +// Flags for SetZOrder() +enum class ZOrderFlags +{ + NONE = 0x0000, + Before = 0x0001, + Behind = 0x0002, + First = 0x0004, + Last = 0x0008, +}; +namespace o3tl +{ + template<> struct typed_flags<ZOrderFlags> : is_typed_flags<ZOrderFlags, 0x000f> {}; +} + +// Activate-Flags +enum class ActivateModeFlags +{ + NONE = 0, + GrabFocus = 0x0001, +}; +namespace o3tl +{ + template<> struct typed_flags<ActivateModeFlags> : is_typed_flags<ActivateModeFlags, 0x0001> {}; +} + +// ToTop-Flags +enum class ToTopFlags +{ + NONE = 0x0000, + RestoreWhenMin = 0x0001, + ForegroundTask = 0x0002, + NoGrabFocus = 0x0004, + GrabFocusOnly = 0x0008, +}; +namespace o3tl +{ + template<> struct typed_flags<ToTopFlags> : is_typed_flags<ToTopFlags, 0x000f> {}; +} + +// Flags for Invalidate +// must match css::awt::InvalidateStyle +enum class InvalidateFlags +{ + NONE = 0x0000, + /** The child windows are invalidated, too. */ + Children = 0x0001, + /** The child windows are not invalidated. */ + NoChildren = 0x0002, + /** The invalidated area is painted with the background color/pattern. */ + NoErase = 0x0004, + /** The invalidated area is updated immediately. */ + Update = 0x0008, + /** The parent window is invalidated, too. */ + Transparent = 0x0010, + /** The parent window is not invalidated. */ + NoTransparent = 0x0020, + /** The area is invalidated regardless of overlapping child windows. */ + NoClipChildren = 0x4000, +}; +namespace o3tl +{ + template<> struct typed_flags<InvalidateFlags> : is_typed_flags<InvalidateFlags, 0x403f> {}; +} + +// Flags for Validate +enum class ValidateFlags +{ + NONE = 0x0000, + Children = 0x0001, + NoChildren = 0x0002 +}; +namespace o3tl +{ + template<> struct typed_flags<ValidateFlags> : is_typed_flags<ValidateFlags, 0x0003> {}; +} + +// Flags for Scroll +enum class ScrollFlags +{ + NONE = 0x0000, + Clip = 0x0001, + Children = 0x0002, + NoChildren = 0x0004, + UseClipRegion = 0x0008, + Update = 0x0010, +}; +namespace o3tl +{ + template<> struct typed_flags<ScrollFlags> : is_typed_flags<ScrollFlags, 0x001f> {}; +} + +// Flags for ParentClipMode +enum class ParentClipMode +{ + NONE = 0x0000, + Clip = 0x0001, + NoClip = 0x0002, +}; +namespace o3tl +{ + template<> struct typed_flags<ParentClipMode> : is_typed_flags<ParentClipMode, 0x0003> {}; +} + +// Flags for ShowTracking() +enum class ShowTrackFlags { + NONE = 0x0000, + Small = 0x0001, + Big = 0x0002, + Split = 0x0003, + Object = 0x0004, + StyleMask = 0x000F, + TrackWindow = 0x1000, + Clip = 0x2000, +}; +namespace o3tl +{ + template<> struct typed_flags<ShowTrackFlags> : is_typed_flags<ShowTrackFlags, 0x300f> {}; +} + +// Flags for StartTracking() +enum class StartTrackingFlags +{ + NONE = 0x0001, + KeyMod = 0x0002, + ScrollRepeat = 0x0004, + ButtonRepeat = 0x0008, +}; + +namespace o3tl +{ + template<> struct typed_flags<StartTrackingFlags> : is_typed_flags<StartTrackingFlags, 0x000f> {}; +} + +// Flags for StartAutoScroll() +enum class StartAutoScrollFlags +{ + NONE = 0x0000, + Vert = 0x0001, + Horz = 0x0002, +}; +namespace o3tl +{ + template<> struct typed_flags<StartAutoScrollFlags> : is_typed_flags<StartAutoScrollFlags, 0x0003> {}; +} + +// Flags for StateChanged() +enum class StateChangedType : sal_uInt16 +{ + InitShow = 1, + Visible = 2, + UpdateMode = 3, + Enable = 4, + Text = 5, + Data = 7, + State = 8, + Style = 9, + Zoom = 10, + ControlFont = 13, + ControlForeground = 14, + ControlBackground = 15, + ReadOnly = 16, + Mirroring = 18, + Layout = 19, + ControlFocus = 20 +}; + +// GetFocusFlags +// must match constants in css:awt::FocusChangeReason +enum class GetFocusFlags +{ + NONE = 0x0000, + Tab = 0x0001, + CURSOR = 0x0002, // avoid name-clash with X11 #define + Mnemonic = 0x0004, + F6 = 0x0008, + Forward = 0x0010, + Backward = 0x0020, + Around = 0x0040, + UniqueMnemonic = 0x0100, + Init = 0x0200, + FloatWinPopupModeEndCancel = 0x0400, +}; +namespace o3tl +{ + template<> struct typed_flags<GetFocusFlags> : is_typed_flags<GetFocusFlags, 0x077f> {}; +} + +// DialogControl-Flags +enum class DialogControlFlags +{ + NONE = 0x0000, + Return = 0x0001, + WantFocus = 0x0002, + FloatWinPopupModeEndCancel = 0x0004, +}; +namespace o3tl +{ + template<> struct typed_flags<DialogControlFlags> : is_typed_flags<DialogControlFlags, 0x0007> {}; +} + +// EndExtTextInput() Flags +enum class EndExtTextInputFlags +{ + NONE = 0x0000, + Complete = 0x0001 +}; +namespace o3tl +{ + template<> struct typed_flags<EndExtTextInputFlags> : is_typed_flags<EndExtTextInputFlags, 0x0001> {}; +} + +#define IMPL_MINSIZE_BUTTON_WIDTH 70 +#define IMPL_MINSIZE_BUTTON_HEIGHT 22 +#define IMPL_EXTRA_BUTTON_WIDTH 18 +#define IMPL_EXTRA_BUTTON_HEIGHT 10 +#define IMPL_SEP_BUTTON_X 5 +#define IMPL_SEP_BUTTON_Y 5 +#define IMPL_MINSIZE_MSGBOX_WIDTH 150 +#define IMPL_DIALOG_OFFSET 5 +#define IMPL_DIALOG_BAR_OFFSET 3 +#define IMPL_MSGBOX_OFFSET_EXTRA_X 0 +#define IMPL_MSGBOX_OFFSET_EXTRA_Y 2 +#define IMPL_SEP_MSGBOX_IMAGE 8 + +// ImplGetDlgWindow() +enum class GetDlgWindowType +{ + Prev, Next, First +}; + + +#ifdef DBG_UTIL +const char* ImplDbgCheckWindow( const void* pObj ); +#endif + +namespace vcl { class Window; } +namespace vcl { class Cursor; } +namespace vcl { class WindowOutputDevice; } +class Dialog; +class Edit; +class WindowImpl; +class PaintHelper; +class VclSizeGroup; +class Application; +class WorkWindow; +class MessBox; +class MessageDialog; +class DockingWindow; +class FloatingWindow; +class GroupBox; +class PushButton; +class RadioButton; +class SalInstanceWidget; +class SystemChildWindow; +class ImplDockingWindowWrapper; +class ImplPopupFloatWin; +class LifecycleTest; + + +enum class WindowHitTest { + NONE = 0x0000, + Inside = 0x0001, + Transparent = 0x0002 +}; +namespace o3tl { + template<> struct typed_flags<WindowHitTest> : is_typed_flags<WindowHitTest, 0x0003> {}; +}; + + +enum class WindowExtendedStyle { + NONE = 0x0000, + Document = 0x0001, + DocModified = 0x0002, + /** + * This is a frame window that is requested to be hidden (not just "not yet + * shown"). + */ + DocHidden = 0x0004, +}; +namespace o3tl { + template<> struct typed_flags<WindowExtendedStyle> : is_typed_flags<WindowExtendedStyle, 0x0007> {}; +}; + +namespace vcl { + +class RenderTools +{ +public: + // transparent background for selected or checked items in toolboxes etc. + // + selection Color with a text color complementing the selection background + // + rounded edge + static void DrawSelectionBackground(vcl::RenderContext& rRenderContext, vcl::Window const & rWindow, + const tools::Rectangle& rRect, sal_uInt16 nHighlight, + bool bChecked, bool bDrawBorder, bool bDrawExtBorderOnly, + Color* pSelectionTextColor = nullptr, tools::Long nCornerRadius = 0, + Color const * pPaintColor = nullptr); +}; + +class VCL_DLLPUBLIC Window : public virtual VclReferenceBase +{ + friend class ::vcl::Cursor; + friend class ::vcl::WindowOutputDevice; + friend class ::OutputDevice; + friend class ::Application; + friend class ::SystemWindow; + friend class ::WorkWindow; + friend class ::Dialog; + friend class ::Edit; + friend class ::MessBox; + friend class ::MessageDialog; + friend class ::DockingWindow; + friend class ::FloatingWindow; + friend class ::GroupBox; + friend class ::PushButton; + friend class ::RadioButton; + friend class ::SalInstanceWidget; + friend class ::SystemChildWindow; + friend class ::ImplBorderWindow; + friend class ::PaintHelper; + friend class ::LifecycleTest; + friend class ::VclEventListeners; + + // TODO: improve missing functionality + // only required because of SetFloatingMode() + friend class ::ImplDockingWindowWrapper; + friend class ::ImplPopupFloatWin; + friend class ::MenuFloatingWindow; + + friend class ::svt::PopupWindowControllerImpl; + +private: + // NOTE: to remove many dependencies of other modules + // to this central file, all members are now hidden + // in the WindowImpl class and all inline functions + // were removed. + // (WindowImpl is a pImpl pattern) + + // Please do *not* add new members or inline functions to class Window, + // but use class WindowImpl instead + + std::unique_ptr<WindowImpl> mpWindowImpl; + +#ifdef DBG_UTIL + friend const char* ::ImplDbgCheckWindow( const void* pObj ); +#endif + +public: + + DECL_DLLPRIVATE_LINK( ImplHandlePaintHdl, Timer*, void ); + DECL_DLLPRIVATE_LINK( ImplGenerateMouseMoveHdl, void*, void ); + DECL_DLLPRIVATE_LINK( ImplTrackTimerHdl, Timer*, void ); + DECL_DLLPRIVATE_LINK( ImplAsyncFocusHdl, void*, void ); + DECL_DLLPRIVATE_LINK( ImplHandleResizeTimerHdl, Timer*, void ); + + + SAL_DLLPRIVATE static void ImplInitAppFontData( vcl::Window const * pWindow ); + + SAL_DLLPRIVATE vcl::Window* ImplGetFrameWindow() const; + weld::Window* GetFrameWeld() const; + vcl::Window* GetFrameWindow() const; + SalFrame* ImplGetFrame() const; + SAL_DLLPRIVATE ImplFrameData* ImplGetFrameData(); + + vcl::Window* ImplGetWindow() const; ///< if this is a proxy return the client, otherwise itself + SAL_DLLPRIVATE ImplWinData* ImplGetWinData() const; + SAL_DLLPRIVATE vcl::Window* ImplGetClientWindow() const; + SAL_DLLPRIVATE vcl::Window* ImplGetDlgWindow( sal_uInt16 n, GetDlgWindowType nType, sal_uInt16 nStart = 0, sal_uInt16 nEnd = 0xFFFF, sal_uInt16* pIndex = nullptr ); + SAL_DLLPRIVATE vcl::Window* ImplGetParent() const; + SAL_DLLPRIVATE vcl::Window* ImplFindWindow( const Point& rFramePos ); + + SAL_DLLPRIVATE void ImplInvalidateFrameRegion( const vcl::Region* pRegion, InvalidateFlags nFlags ); + SAL_DLLPRIVATE void ImplInvalidateOverlapFrameRegion( const vcl::Region& rRegion ); + + SAL_DLLPRIVATE bool ImplSetClipFlag( bool bSysObjOnlySmaller = false ); + + SAL_DLLPRIVATE bool ImplIsWindowOrChild( const vcl::Window* pWindow, bool bSystemWindow = false ) const; + SAL_DLLPRIVATE bool ImplIsChild( const vcl::Window* pWindow, bool bSystemWindow = false ) const; + SAL_DLLPRIVATE bool ImplIsFloatingWindow() const; + SAL_DLLPRIVATE bool ImplIsPushButton() const; + SAL_DLLPRIVATE bool ImplIsSplitter() const; + SAL_DLLPRIVATE bool ImplIsOverlapWindow() const; + + SAL_DLLPRIVATE void ImplIsInTaskPaneList( bool mbIsInTaskList ); + + SAL_DLLPRIVATE WindowImpl* ImplGetWindowImpl() const { return mpWindowImpl.get(); } + + SAL_DLLPRIVATE Point ImplFrameToOutput( const Point& rPos ); + + SAL_DLLPRIVATE void ImplGrabFocus( GetFocusFlags nFlags ); + SAL_DLLPRIVATE void ImplGrabFocusToDocument( GetFocusFlags nFlags ); + SAL_DLLPRIVATE void ImplInvertFocus( const tools::Rectangle& rRect ); + + SAL_DLLPRIVATE PointerStyle ImplGetMousePointer() const; + SAL_DLLPRIVATE void ImplCallMouseMove( sal_uInt16 nMouseCode, bool bModChanged = false ); + SAL_DLLPRIVATE void ImplGenerateMouseMove(); + + SAL_DLLPRIVATE void ImplNotifyKeyMouseCommandEventListeners( NotifyEvent& rNEvt ); + SAL_DLLPRIVATE void ImplNotifyIconifiedState( bool bIconified ); + + SAL_DLLPRIVATE void ImplUpdateAll(); + + SAL_DLLPRIVATE void ImplControlFocus( GetFocusFlags nFlags = GetFocusFlags::NONE ); + + SAL_DLLPRIVATE void ImplMirrorFramePos( Point &pt ) const; + + SAL_DLLPRIVATE void ImplPosSizeWindow( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, PosSizeFlags nFlags ); + + SAL_DLLPRIVATE void ImplCallResize(); + SAL_DLLPRIVATE void ImplCallMove(); + + // These methods call the relevant virtual method when not in/post dispose + SAL_DLLPRIVATE void CompatGetFocus(); + SAL_DLLPRIVATE void CompatLoseFocus(); + SAL_DLLPRIVATE void CompatStateChanged( StateChangedType nStateChange ); + SAL_DLLPRIVATE void CompatDataChanged( const DataChangedEvent& rDCEvt ); + SAL_DLLPRIVATE bool CompatPreNotify( NotifyEvent& rNEvt ); + SAL_DLLPRIVATE bool CompatNotify( NotifyEvent& rNEvt ); + + void IncModalCount(); + void DecModalCount(); + + SAL_DLLPRIVATE static void ImplCalcSymbolRect( tools::Rectangle& rRect ); + +protected: + + /** This is intended to be used to clear any locally held references to other Window-subclass objects */ + virtual void dispose() override; + + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle, SystemParentData* pSystemParentData ); + + SAL_DLLPRIVATE Point ImplOutputToFrame( const Point& rPos ); + + SAL_DLLPRIVATE void ImplInvalidateParentFrameRegion( const vcl::Region& rRegion ); + SAL_DLLPRIVATE void ImplValidateFrameRegion( const vcl::Region* rRegion, ValidateFlags nFlags ); + SAL_DLLPRIVATE void ImplValidate(); + SAL_DLLPRIVATE void ImplMoveInvalidateRegion( const tools::Rectangle& rRect, tools::Long nHorzScroll, tools::Long nVertScroll, bool bChildren ); + SAL_DLLPRIVATE void ImplMoveAllInvalidateRegions( const tools::Rectangle& rRect, tools::Long nHorzScroll, tools::Long nVertScroll, bool bChildren ); + + SAL_DLLPRIVATE vcl::Window* ImplGetBorderWindow() const; + + SAL_DLLPRIVATE void ImplInvalidate( const vcl::Region* rRegion, InvalidateFlags nFlags ); + + virtual WindowHitTest ImplHitTest( const Point& rFramePos ); + + SAL_DLLPRIVATE void ImplSetMouseTransparent( bool bTransparent ); + + SAL_DLLPRIVATE void ImplScroll( const tools::Rectangle& rRect, tools::Long nHorzScroll, tools::Long nVertScroll, ScrollFlags nFlags ); + + SAL_DLLPRIVATE bool ImplSetClipFlagChildren( bool bSysObjOnlySmaller ); + SAL_DLLPRIVATE bool ImplSetClipFlagOverlapWindows( bool bSysObjOnlySmaller = false ); + + SAL_DLLPRIVATE void PushPaintHelper(PaintHelper* pHelper, vcl::RenderContext& rRenderContext); + SAL_DLLPRIVATE void PopPaintHelper(PaintHelper const * pHelper); + +private: + + SAL_DLLPRIVATE void ImplSetFrameParent( const vcl::Window* pParent ); + + SAL_DLLPRIVATE void ImplInsertWindow( vcl::Window* pParent ); + SAL_DLLPRIVATE void ImplRemoveWindow( bool bRemoveFrameData ); + + SAL_DLLPRIVATE SalGraphics* ImplGetFrameGraphics() const; + + SAL_DLLPRIVATE static void ImplCallFocusChangeActivate( vcl::Window* pNewOverlapWindow, vcl::Window* pOldOverlapWindow ); + SAL_DLLPRIVATE vcl::Window* ImplGetFirstOverlapWindow(); + SAL_DLLPRIVATE const vcl::Window* ImplGetFirstOverlapWindow() const; + + SAL_DLLPRIVATE bool ImplIsRealParentPath( const vcl::Window* pWindow ) const; + + SAL_DLLPRIVATE bool ImplTestMousePointerSet(); + + SAL_DLLPRIVATE void ImplResetReallyVisible(); + SAL_DLLPRIVATE void ImplSetReallyVisible(); + + SAL_DLLPRIVATE void ImplCallInitShow(); + + SAL_DLLPRIVATE void ImplInitResolutionSettings(); + + SAL_DLLPRIVATE void ImplPointToLogic(vcl::RenderContext const & rRenderContext, vcl::Font& rFont) const; + SAL_DLLPRIVATE void ImplLogicToPoint(vcl::RenderContext const & rRenderContext, vcl::Font& rFont) const; + + SAL_DLLPRIVATE bool ImplSysObjClip( const vcl::Region* pOldRegion ); + SAL_DLLPRIVATE void ImplUpdateSysObjChildrenClip(); + SAL_DLLPRIVATE void ImplUpdateSysObjOverlapsClip(); + SAL_DLLPRIVATE void ImplUpdateSysObjClip(); + + SAL_DLLPRIVATE void ImplIntersectWindowClipRegion( vcl::Region& rRegion ); + SAL_DLLPRIVATE void ImplIntersectWindowRegion( vcl::Region& rRegion ); + SAL_DLLPRIVATE void ImplExcludeWindowRegion( vcl::Region& rRegion ); + SAL_DLLPRIVATE void ImplExcludeOverlapWindows( vcl::Region& rRegion ) const; + SAL_DLLPRIVATE void ImplExcludeOverlapWindows2( vcl::Region& rRegion ); + + SAL_DLLPRIVATE void ImplClipBoundaries( vcl::Region& rRegion, bool bThis, bool bOverlaps ); + SAL_DLLPRIVATE bool ImplClipChildren( vcl::Region& rRegion ) const; + SAL_DLLPRIVATE void ImplClipAllChildren( vcl::Region& rRegion ) const; + SAL_DLLPRIVATE void ImplClipSiblings( vcl::Region& rRegion ) const; + + SAL_DLLPRIVATE void ImplInitWinClipRegion(); + SAL_DLLPRIVATE void ImplInitWinChildClipRegion(); + SAL_DLLPRIVATE vcl::Region& ImplGetWinChildClipRegion(); + + SAL_DLLPRIVATE void ImplIntersectAndUnionOverlapWindows( const vcl::Region& rInterRegion, vcl::Region& rRegion ) const; + SAL_DLLPRIVATE void ImplIntersectAndUnionOverlapWindows2( const vcl::Region& rInterRegion, vcl::Region& rRegion ); + SAL_DLLPRIVATE void ImplCalcOverlapRegionOverlaps( const vcl::Region& rInterRegion, vcl::Region& rRegion ) const; + SAL_DLLPRIVATE void ImplCalcOverlapRegion( const tools::Rectangle& rSourceRect, vcl::Region& rRegion, + bool bChildren, bool bSiblings ); + + /** Invoke the actual painting. + + This function is kind of recursive - it may be called from the + PaintHelper destructor; and on the other hand it creates PaintHelper + that (when destructed) calls other ImplCallPaint()'s. + */ + SAL_DLLPRIVATE void ImplCallPaint(const vcl::Region* pRegion, ImplPaintFlags nPaintFlags); + + SAL_DLLPRIVATE void ImplCallOverlapPaint(); + + SAL_DLLPRIVATE void ImplUpdateWindowPtr( vcl::Window* pWindow ); + SAL_DLLPRIVATE void ImplUpdateWindowPtr(); + SAL_DLLPRIVATE void ImplUpdateOverlapWindowPtr( bool bNewFrame ); + + SAL_DLLPRIVATE bool ImplUpdatePos(); + SAL_DLLPRIVATE void ImplUpdateSysObjPos(); + + SAL_DLLPRIVATE void ImplUpdateGlobalSettings( AllSettings& rSettings, bool bCallHdl = true ) const; + + SAL_DLLPRIVATE void ImplToBottomChild(); + + SAL_DLLPRIVATE void ImplCalcToTop( ImplCalcToTopData* pPrevData ); + SAL_DLLPRIVATE void ImplToTop( ToTopFlags nFlags ); + SAL_DLLPRIVATE void ImplStartToTop( ToTopFlags nFlags ); + SAL_DLLPRIVATE void ImplFocusToTop( ToTopFlags nFlags, bool bReallyVisible ); + + SAL_DLLPRIVATE void ImplShowAllOverlaps(); + SAL_DLLPRIVATE void ImplHideAllOverlaps(); + + SAL_DLLPRIVATE bool ImplDlgCtrl( const KeyEvent& rKEvt, bool bKeyInput ); + SAL_DLLPRIVATE bool ImplHasDlgCtrl() const; + SAL_DLLPRIVATE void ImplDlgCtrlNextWindow(); + SAL_DLLPRIVATE void ImplDlgCtrlFocusChanged( vcl::Window* pWindow, bool bGetFocus ); + SAL_DLLPRIVATE vcl::Window* ImplFindDlgCtrlWindow( vcl::Window* pWindow ); + + SAL_DLLPRIVATE static void ImplNewInputContext(); + + SAL_DLLPRIVATE void ImplCallActivateListeners(vcl::Window*); + SAL_DLLPRIVATE void ImplCallDeactivateListeners(vcl::Window*); + + SAL_DLLPRIVATE static void ImplHandleScroll(ScrollBar* pHScrl, double nX, ScrollBar* pVScrl, double nY); + + SAL_DLLPRIVATE tools::Rectangle ImplOutputToUnmirroredAbsoluteScreenPixel( const tools::Rectangle& rRect ) const; + SAL_DLLPRIVATE tools::Rectangle ImplUnmirroredAbsoluteScreenToOutputPixel( const tools::Rectangle& rRect ) const; + SAL_DLLPRIVATE tools::Long ImplGetUnmirroredOutOffX(); + + // retrieves the list of owner draw decorated windows for this window hierarchy + SAL_DLLPRIVATE ::std::vector<VclPtr<vcl::Window> >& ImplGetOwnerDrawList(); + + SAL_DLLPRIVATE vcl::Window* ImplGetTopmostFrameWindow(); + + SAL_DLLPRIVATE tools::Rectangle ImplGetWindowExtentsRelative(const vcl::Window *pRelativeWindow) const; + + SAL_DLLPRIVATE bool ImplStopDnd(); + SAL_DLLPRIVATE void ImplStartDnd(); + + virtual void ImplPaintToDevice( ::OutputDevice* pTargetOutDev, const Point& rPos ); + +protected: + // Single argument ctors shall be explicit. + explicit Window( WindowType nType ); + + void SetCompoundControl( bool bCompound ); + + void CallEventListeners( VclEventId nEvent, void* pData = nullptr ); + + // FIXME: this is a hack to workaround missing layout functionality + virtual void ImplAdjustNWFSizes(); + + virtual void ApplySettings(vcl::RenderContext& rRenderContext); + +public: + // Single argument ctors shall be explicit. + explicit Window( vcl::Window* pParent, WinBits nStyle = 0 ); + + virtual ~Window() override; + + ::OutputDevice const* GetOutDev() const; + ::OutputDevice* GetOutDev(); + + Color GetBackgroundColor() const; + const Wallpaper & GetBackground() const; + bool IsBackground() const; + const MapMode& GetMapMode() const; + void SetBackground(); + void SetBackground( const Wallpaper& rBackground ); + + virtual void MouseMove( const MouseEvent& rMEvt ); + virtual void MouseButtonDown( const MouseEvent& rMEvt ); + virtual void MouseButtonUp( const MouseEvent& rMEvt ); + virtual void KeyInput( const KeyEvent& rKEvt ); + virtual void KeyUp( const KeyEvent& rKEvt ); + virtual void PrePaint(vcl::RenderContext& rRenderContext); + virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect); + virtual void PostPaint(vcl::RenderContext& rRenderContext); + + void Erase(vcl::RenderContext& rRenderContext); + + virtual void Draw( ::OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags ); + virtual void Move(); + virtual void Resize(); + virtual void Activate(); + virtual void Deactivate(); + virtual void GetFocus(); + virtual void LoseFocus(); + virtual void RequestHelp( const HelpEvent& rHEvt ); + virtual void Command( const CommandEvent& rCEvt ); + virtual void Tracking( const TrackingEvent& rTEvt ); + virtual void StateChanged( StateChangedType nStateChange ); + virtual void DataChanged( const DataChangedEvent& rDCEvt ); + virtual bool PreNotify( NotifyEvent& rNEvt ); + virtual bool EventNotify( NotifyEvent& rNEvt ); + + void AddEventListener( const Link<VclWindowEvent&,void>& rEventListener ); + void RemoveEventListener( const Link<VclWindowEvent&,void>& rEventListener ); + void AddChildEventListener( const Link<VclWindowEvent&,void>& rEventListener ); + void RemoveChildEventListener( const Link<VclWindowEvent&,void>& rEventListener ); + + ImplSVEvent * PostUserEvent( const Link<void*,void>& rLink, void* pCaller = nullptr, bool bReferenceLink = false ); + void RemoveUserEvent( ImplSVEvent * nUserEvent ); + + // returns the input language used for the last key stroke + // may be LANGUAGE_DONTKNOW if not supported by the OS + LanguageType GetInputLanguage() const; + + void SetStyle( WinBits nStyle ); + WinBits GetStyle() const; + WinBits GetPrevStyle() const; + void SetExtendedStyle( WindowExtendedStyle nExtendedStyle ); + WindowExtendedStyle GetExtendedStyle() const; + void SetType( WindowType nType ); + WindowType GetType() const; + bool IsSystemWindow() const; + bool IsDockingWindow() const; + bool IsDialog() const; + bool IsMenuFloatingWindow() const; + bool IsToolbarFloatingWindow() const; + bool IsTopWindow() const; + SystemWindow* GetSystemWindow() const; + + /// Can the widget derived from this Window do the double-buffering via RenderContext properly? + bool SupportsDoubleBuffering() const; + /// Enable/disable double-buffering of the frame window and all its children. + void RequestDoubleBuffering(bool bRequest); + + void EnableAllResize(); + + void SetBorderStyle( WindowBorderStyle nBorderStyle ); + WindowBorderStyle GetBorderStyle() const; + void GetBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder, + sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const; + Size CalcWindowSize( const Size& rOutSz ) const; + Size CalcOutputSize( const Size& rWinSz ) const; + tools::Long CalcTitleWidth() const; + + void EnableClipSiblings( bool bClipSiblings = true ); + + void EnableChildTransparentMode( bool bEnable = true ); + bool IsChildTransparentModeEnabled() const; + + void SetMouseTransparent( bool bTransparent ); + bool IsMouseTransparent() const; + void SetPaintTransparent( bool bTransparent ); + bool IsPaintTransparent() const; + void SetDialogControlStart( bool bStart ); + bool IsDialogControlStart() const; + void SetDialogControlFlags( DialogControlFlags nFlags ); + DialogControlFlags GetDialogControlFlags() const; + + struct PointerState + { + sal_Int32 mnState; // the button state + Point maPos; // mouse position in output coordinates + }; + PointerState GetPointerState(); + bool IsMouseOver() const; + + void SetInputContext( const InputContext& rInputContext ); + const InputContext& GetInputContext() const; + void PostExtTextInputEvent(VclEventId nType, const OUString& rText); + void EndExtTextInput(); + void SetCursorRect( const tools::Rectangle* pRect = nullptr, tools::Long nExtTextInputWidth = 0 ); + const tools::Rectangle* GetCursorRect() const; + tools::Long GetCursorExtTextInputWidth() const; + + void SetCompositionCharRect( const tools::Rectangle* pRect, tools::Long nCompositionLength, bool bVertical = false ); + + void UpdateSettings( const AllSettings& rSettings, bool bChild = false ); + void NotifyAllChildren( DataChangedEvent& rDCEvt ); + + void SetPointFont(vcl::RenderContext& rRenderContext, const vcl::Font& rFont); + vcl::Font GetPointFont(vcl::RenderContext const & rRenderContext) const; + void SetZoomedPointFont(vcl::RenderContext& rRenderContext, const vcl::Font& rFont); + tools::Long GetDrawPixel( ::OutputDevice const * pDev, tools::Long nPixels ) const; + vcl::Font GetDrawPixelFont( ::OutputDevice const * pDev ) const; + + void SetControlFont(); + void SetControlFont( const vcl::Font& rFont ); + vcl::Font GetControlFont() const; + bool IsControlFont() const; + void ApplyControlFont(vcl::RenderContext& rRenderContext, const vcl::Font& rDefaultFont); + + void SetControlForeground(); + void SetControlForeground(const Color& rColor); + const Color& GetControlForeground() const; + bool IsControlForeground() const; + void ApplyControlForeground(vcl::RenderContext& rRenderContext, const Color& rDefaultColor); + + void SetControlBackground(); + void SetControlBackground( const Color& rColor ); + const Color& GetControlBackground() const; + bool IsControlBackground() const; + void ApplyControlBackground(vcl::RenderContext& rRenderContext, const Color& rDefaultColor); + + void SetParentClipMode( ParentClipMode nMode = ParentClipMode::NONE ); + ParentClipMode GetParentClipMode() const; + + void SetWindowRegionPixel(); + void SetWindowRegionPixel( const vcl::Region& rRegion ); + vcl::Region GetWindowClipRegionPixel() const; + vcl::Region GetPaintRegion() const; + bool IsInPaint() const; + // while IsInPaint returns true ExpandPaintClipRegion adds the + // submitted region to the paint clip region so you can + // paint additional parts of your window if necessary + void ExpandPaintClipRegion( const vcl::Region& rRegion ); + + void SetParent( vcl::Window* pNewParent ); + vcl::Window* GetParent() const; + // return the dialog we are contained in or NULL if un-contained + Dialog* GetParentDialog() const; + bool IsAncestorOf( const vcl::Window& rWindow ) const; + + void Show( bool bVisible = true, ShowFlags nFlags = ShowFlags::NONE ); + void Hide() { Show( false ); } + bool IsVisible() const; + bool IsReallyVisible() const; + bool IsReallyShown() const; + bool IsInInitShow() const; + + void Enable( bool bEnable = true, bool bChild = true ); + void Disable( bool bChild = true ) { Enable( false, bChild ); } + bool IsEnabled() const; + + void EnableInput( bool bEnable = true, bool bChild = true ); + void EnableInput( bool bEnable, const vcl::Window* pExcludeWindow ); + bool IsInputEnabled() const; + + /** Override <code>EnableInput</code>. This can be necessary due to other people + using EnableInput for whole window hierarchies. + + @param bAlways + sets always enabled flag + + @param bChild + if true children are recursively set to AlwaysEnableInput + */ + void AlwaysEnableInput( bool bAlways, bool bChild = true ); + + /** returns the current AlwaysEnableInput state + @return + true if window is in AlwaysEnableInput state + */ + bool IsAlwaysEnableInput() const; + + /** A window is in modal mode if one of its children or subchildren + is a running modal window (a modal dialog) + + @returns sal_True if a child or subchild is a running modal window + */ + bool IsInModalMode() const; + + void SetActivateMode( ActivateModeFlags nMode ); + ActivateModeFlags GetActivateMode() const; + + void ToTop( ToTopFlags nFlags = ToTopFlags::NONE ); + void SetZOrder( vcl::Window* pRefWindow, ZOrderFlags nFlags ); + void EnableAlwaysOnTop( bool bEnable = true ); + bool IsAlwaysOnTopEnabled() const; + + virtual void setPosSizePixel( tools::Long nX, tools::Long nY, + tools::Long nWidth, tools::Long nHeight, + PosSizeFlags nFlags = PosSizeFlags::All ); + virtual void SetPosPixel( const Point& rNewPos ); + virtual Point GetPosPixel() const; + virtual void SetSizePixel( const Size& rNewSize ); + virtual Size GetSizePixel() const; + virtual void SetPosSizePixel( const Point& rNewPos, + const Size& rNewSize ); + virtual void SetOutputSizePixel( const Size& rNewSize ); + bool IsDefaultPos() const; + bool IsDefaultSize() const; + Point GetOffsetPixelFrom(const vcl::Window& rWindow) const; + + // those conversion routines might deliver different results during UI mirroring + Point OutputToScreenPixel( const Point& rPos ) const; + Point ScreenToOutputPixel( const Point& rPos ) const; + // the normalized screen methods work independent from UI mirroring + Point OutputToNormalizedScreenPixel( const Point& rPos ) const; + Point NormalizedScreenToOutputPixel( const Point& rPos ) const; + Point OutputToAbsoluteScreenPixel( const Point& rPos ) const; + Point AbsoluteScreenToOutputPixel( const Point& rPos ) const; + tools::Rectangle GetDesktopRectPixel() const; + // window extents including border and decoration + tools::Rectangle GetWindowExtentsRelative(const vcl::Window *pRelativeWindow) const; + + bool IsScrollable() const; + virtual void Scroll( tools::Long nHorzScroll, tools::Long nVertScroll, + ScrollFlags nFlags = ScrollFlags::NONE ); + void Scroll( tools::Long nHorzScroll, tools::Long nVertScroll, + const tools::Rectangle& rRect, ScrollFlags nFlags = ScrollFlags::NONE ); + virtual void Invalidate( InvalidateFlags nFlags = InvalidateFlags::NONE ); + virtual void Invalidate( const tools::Rectangle& rRect, InvalidateFlags nFlags = InvalidateFlags::NONE ); + virtual void Invalidate( const vcl::Region& rRegion, InvalidateFlags nFlags = InvalidateFlags::NONE ); + /** + * Notification about some rectangle of the output device got invalidated.Used for the main + * document window. + * + * @param pRectangle If 0, that means the whole area, otherwise the area in logic coordinates. + */ + virtual void LogicInvalidate(const tools::Rectangle* pRectangle); + + /** + * Notification about some rectangle of the output device got invalidated. Used for the + * dialogs and floating windows (e.g. context menu, popup). + * + * @param pRectangle If 0, that means the whole area, otherwise the area in pixel coordinates. + */ + virtual void PixelInvalidate(const tools::Rectangle* pRectangle); + void Validate(); + bool HasPaintEvent() const; + void PaintImmediately(); + + // toggles new docking support, enabled via toolkit + void EnableDocking( bool bEnable = true ); + // retrieves the single dockingmanager instance + static DockingManager* GetDockingManager(); + + void EnablePaint( bool bEnable ); + bool IsPaintEnabled() const; + void SetUpdateMode( bool bUpdate ); + bool IsUpdateMode() const; + void SetParentUpdateMode( bool bUpdate ); + + void GrabFocus(); + bool HasFocus() const; + bool HasChildPathFocus( bool bSystemWindow = false ) const; + bool IsActive() const; + bool HasActiveChildFrame() const; + GetFocusFlags GetGetFocusFlags() const; + void GrabFocusToDocument(); + VclPtr<vcl::Window> GetFocusedWindow() const; + + /** + * Set this when you need to act as if the window has focus even if it + * doesn't. This is necessary for implementing tab stops inside floating + * windows, but floating windows don't get focus from the system. + */ + void SetFakeFocus( bool bFocus ); + + bool IsCompoundControl() const; + + static VclPtr<vcl::Window> SaveFocus(); + static void EndSaveFocus(const VclPtr<vcl::Window>& xFocusWin); + + void LocalStartDrag(); + void CaptureMouse(); + void ReleaseMouse(); + bool IsMouseCaptured() const; + + void SetPointer( PointerStyle ); + PointerStyle GetPointer() const; + void EnableChildPointerOverwrite( bool bOverwrite ); + void SetPointerPosPixel( const Point& rPos ); + Point GetPointerPosPixel(); + Point GetLastPointerPosPixel(); + /// Similar to SetPointerPosPixel(), but sets the frame data's last mouse position instead. + void SetLastMousePos(const Point& rPos); + void ShowPointer( bool bVisible ); + void EnterWait(); + void LeaveWait(); + bool IsWait() const; + + void SetCursor( vcl::Cursor* pCursor ); + vcl::Cursor* GetCursor() const; + + void SetZoom( const Fraction& rZoom ); + const Fraction& GetZoom() const; + bool IsZoom() const; + tools::Long CalcZoom( tools::Long n ) const; + + virtual void SetText( const OUString& rStr ); + virtual OUString GetText() const; + // return the actual text displayed + // this may have e.g. accelerators removed or portions + // replaced by ellipses + virtual OUString GetDisplayText() const; + // gets the visible background color. for transparent windows + // this may be the parent's background color; for controls + // this may be a child's background color (e.g. ListBox) + virtual const Wallpaper& GetDisplayBackground() const; + + void SetHelpText( const OUString& rHelpText ); + const OUString& GetHelpText() const; + + void SetQuickHelpText( const OUString& rHelpText ); + const OUString& GetQuickHelpText() const; + + void SetHelpId( const OString& ); + const OString& GetHelpId() const; + + sal_uInt16 GetChildCount() const; + vcl::Window* GetChild( sal_uInt16 nChild ) const; + vcl::Window* GetWindow( GetWindowType nType ) const; + bool IsChild( const vcl::Window* pWindow ) const; + bool IsWindowOrChild( const vcl::Window* pWindow, bool bSystemWindow = false ) const; + + /// Add all children to rAllChildren recursively. + SAL_DLLPRIVATE void CollectChildren(::std::vector<vcl::Window *>& rAllChildren ); + + virtual void ShowFocus(const tools::Rectangle& rRect); + void HideFocus(); + + // transparent background for selected or checked items in toolboxes etc. + void DrawSelectionBackground( const tools::Rectangle& rRect, sal_uInt16 highlight, bool bChecked, bool bDrawBorder ); + + void ShowTracking( const tools::Rectangle& rRect, + ShowTrackFlags nFlags = ShowTrackFlags::Small ); + void HideTracking(); + void InvertTracking( const tools::Rectangle& rRect, ShowTrackFlags nFlags ); + + void StartTracking( StartTrackingFlags nFlags = StartTrackingFlags::NONE ); + void EndTracking( TrackingEventFlags nFlags = TrackingEventFlags::NONE ); + bool IsTracking() const; + + void StartAutoScroll( StartAutoScrollFlags nFlags ); + void EndAutoScroll(); + + bool HandleScrollCommand( const CommandEvent& rCmd, + ScrollBar* pHScrl, + ScrollBar* pVScrl ); + + virtual const SystemEnvData* GetSystemData() const; + + // API to set/query the component interfaces + virtual css::uno::Reference< css::awt::XWindowPeer > + GetComponentInterface( bool bCreate = true ); + + void SetComponentInterface( css::uno::Reference< css::awt::XWindowPeer > const & xIFace ); + + void SetUseFrameData(bool bUseFrameData); + + /// Interface to register for dialog / window tunneling. + void SetLOKNotifier(const vcl::ILibreOfficeKitNotifier* pNotifier, bool bParent = false); + const vcl::ILibreOfficeKitNotifier* GetLOKNotifier() const; + vcl::LOKWindowId GetLOKWindowId() const; + + /// Find the nearest parent with LOK Notifier; can be itself if this Window has LOK notifier set. + VclPtr<vcl::Window> GetParentWithLOKNotifier(); + + /// Indicate that LOK is not going to use this dialog any more. + void ReleaseLOKNotifier(); + + /// Find an existing Window based on the LOKWindowId. + static VclPtr<vcl::Window> FindLOKWindow(vcl::LOKWindowId nWindowId); + + /// check if LOK Window container is empty + static bool IsLOKWindowsEmpty(); + + /// Dumps itself and potentially its children to a property tree, to be written easily to JSON. + virtual void DumpAsPropertyTree(tools::JsonWriter&); + + /// Same as MouseButtonDown(), but coordinates are in logic unit. used for LOK + virtual void LogicMouseButtonDown(const MouseEvent&) {}; + /// Same as MouseButtonUp(), but coordinates are in logic unit. used for LOK + virtual void LogicMouseButtonUp(const MouseEvent&) {}; + /// Same as MouseMove(), but coordinates are in logic unit. used for LOK + virtual void LogicMouseMove(const MouseEvent&) {}; + + /** @name Accessibility + */ + ///@{ +public: + + css::uno::Reference< css::accessibility::XAccessible > + GetAccessible( bool bCreate = true ); + + virtual css::uno::Reference< css::accessibility::XAccessible > + CreateAccessible(); + + void SetAccessible( const css::uno::Reference< css::accessibility::XAccessible >& ); + + vcl::Window* GetAccessibleParentWindow() const; + sal_uInt16 GetAccessibleChildWindowCount(); + vcl::Window* GetAccessibleChildWindow( sal_uInt16 n ); + + void SetAccessibleRole( sal_uInt16 nRole ); + sal_uInt16 GetAccessibleRole() const; + + void SetAccessibleName( const OUString& rName ); + OUString GetAccessibleName() const; + + void SetAccessibleDescription( const OUString& rDescr ); + OUString GetAccessibleDescription() const; + + void SetAccessibleRelationLabeledBy( vcl::Window* pLabeledBy ); + vcl::Window* GetAccessibleRelationLabeledBy() const; + + void SetAccessibleRelationLabelFor( vcl::Window* pLabelFor ); + vcl::Window* GetAccessibleRelationLabelFor() const; + + vcl::Window* GetAccessibleRelationMemberOf() const; + + // to avoid sending accessibility events in cases like closing dialogs + // by default checks complete parent path + bool IsAccessibilityEventsSuppressed( bool bTraverseParentPath = true ); + void SetAccessibilityEventsSuppressed(bool bSuppressed); + + KeyEvent GetActivationKey() const; + +protected: + + // These eventually are supposed to go when everything is converted to .ui + SAL_DLLPRIVATE vcl::Window* getLegacyNonLayoutAccessibleRelationMemberOf() const; + SAL_DLLPRIVATE vcl::Window* getLegacyNonLayoutAccessibleRelationLabeledBy() const; + SAL_DLLPRIVATE vcl::Window* getLegacyNonLayoutAccessibleRelationLabelFor() const; + + // Let Label override the code part of GetAccessibleRelationLabelFor + virtual vcl::Window* getAccessibleRelationLabelFor() const; + virtual sal_uInt16 getDefaultAccessibleRole() const; + virtual OUString getDefaultAccessibleName() const; + + /* + * Advisory Sizing - what is a good size for this widget + * + * Retrieves the preferred size of a widget ignoring + * "width-request" and "height-request" properties. + * + * Implement this in sub-classes to tell layout + * the preferred widget size. + * + * Use get_preferred_size to retrieve this value + * cached and mediated via height and width requests + */ + virtual Size GetOptimalSize() const; + /// clear OptimalSize cache + void InvalidateSizeCache(); +private: + + SAL_DLLPRIVATE bool ImplIsAccessibleCandidate() const; + SAL_DLLPRIVATE bool ImplIsAccessibleNativeFrame() const; + ///@} + + /* + * Retrieves the preferred size of a widget taking + * into account the "width-request" and "height-request" properties. + * + * Overrides the result of GetOptimalSize to honor the + * width-request and height-request properties. + * + * So the same as get_ungrouped_preferred_size except + * it ignores groups. A building block of get_preferred_size + * that access the size cache + * + * @see get_preferred_size + */ + Size get_ungrouped_preferred_size() const; +public: + /* records all DrawText operations within the passed rectangle; + * a synchronous paint is sent to achieve this + */ + void RecordLayoutData( vcl::ControlLayoutData* pLayout, const tools::Rectangle& rRect ); + + // set and retrieve for Toolkit + VCLXWindow* GetWindowPeer() const; + void SetWindowPeer( css::uno::Reference< css::awt::XWindowPeer > const & xPeer, VCLXWindow* pVCLXWindow ); + + // remember if it was generated by Toolkit + bool IsCreatedWithToolkit() const; + void SetCreatedWithToolkit( bool b ); + + // Drag and Drop interfaces + css::uno::Reference< css::datatransfer::dnd::XDropTarget > GetDropTarget(); + css::uno::Reference< css::datatransfer::dnd::XDragSource > GetDragSource(); + css::uno::Reference< css::datatransfer::dnd::XDragGestureRecognizer > GetDragGestureRecognizer(); + + // Clipboard/Selection interfaces + css::uno::Reference< css::datatransfer::clipboard::XClipboard > GetClipboard(); + /// Sets a custom clipboard for the window's frame, instead of creating it on-demand using css::datatransfer::clipboard::SystemClipboard. + void SetClipboard(css::uno::Reference<css::datatransfer::clipboard::XClipboard> const & xClipboard); + + /* + * Widgets call this to inform their owner container that the widget wants + * to renegotiate its size. Should be called when a widget has a new size + * request. e.g. a FixedText Control gets a new label. + * + * akin to gtk_widget_queue_resize + */ + virtual void queue_resize(StateChangedType eReason = StateChangedType::Layout); + + /* + * Sets the "height-request" property + * + * Override for height request of the widget, or -1 if natural request + * should be used. + * + * @see get_preferred_size, set_width_request + */ + void set_height_request(sal_Int32 nHeightRequest); + sal_Int32 get_height_request() const; + + /* + * Sets the "width-request" property + * + * Override for width request of the widget, or -1 if natural request + * should be used. + * + * @see get_preferred_size, set_height_request + */ + void set_width_request(sal_Int32 nWidthRequest); + sal_Int32 get_width_request() const; + + /* + * Retrieves the preferred size of a widget taking + * into account the "width-request" and "height-request" properties. + * + * Overrides the result of GetOptimalSize to honor the + * width-request and height-request properties. + * + * @see GetOptimalSize + * + * akin to gtk_widget_get_preferred_size + */ + Size get_preferred_size() const; + + /* + * How to horizontally align this widget + */ + VclAlign get_halign() const; + void set_halign(VclAlign eAlign); + + /* + * How to vertically align this widget + */ + VclAlign get_valign() const; + void set_valign(VclAlign eAlign); + + /* + * Whether the widget would like to use any available extra horizontal + * space. + */ + bool get_hexpand() const; + void set_hexpand(bool bExpand); + + /* + * Whether the widget would like to use any available extra vertical + * space. + */ + bool get_vexpand() const; + void set_vexpand(bool bExpand); + + /* + * Whether the widget would like to use any available extra space. + */ + bool get_expand() const; + void set_expand(bool bExpand); + + /* + * Whether the widget should receive extra space when the parent grows + */ + bool get_fill() const; + void set_fill(bool bFill); + + void set_border_width(sal_Int32 nBorderWidth); + sal_Int32 get_border_width() const; + + void set_margin_start(sal_Int32 nWidth); + sal_Int32 get_margin_start() const; + + void set_margin_end(sal_Int32 nWidth); + sal_Int32 get_margin_end() const; + + void set_margin_top(sal_Int32 nWidth); + sal_Int32 get_margin_top() const; + + void set_margin_bottom(sal_Int32 nWidth); + sal_Int32 get_margin_bottom() const; + + /* + * How the widget is packed with reference to the start or end of the parent + */ + VclPackType get_pack_type() const; + void set_pack_type(VclPackType ePackType); + + /* + * The extra space to put between the widget and its neighbors + */ + sal_Int32 get_padding() const; + void set_padding(sal_Int32 nPadding); + + /* + * The number of columns that the widget spans + */ + sal_Int32 get_grid_width() const; + void set_grid_width(sal_Int32 nCols); + + /* + * The column number to attach the left side of the widget to + */ + sal_Int32 get_grid_left_attach() const; + void set_grid_left_attach(sal_Int32 nAttach); + + /* + * The number of row that the widget spans + */ + sal_Int32 get_grid_height() const; + void set_grid_height(sal_Int32 nRows); + + /* + * The row number to attach the top side of the widget to + */ + sal_Int32 get_grid_top_attach() const; + void set_grid_top_attach(sal_Int32 nAttach); + + /* + * If true this child appears in a secondary layout group of children + * e.g. help buttons in a buttonbox + */ + bool get_secondary() const; + void set_secondary(bool bSecondary); + + /* + * If true this child is exempted from homogeneous sizing + * e.g. special button in a buttonbox + */ + bool get_non_homogeneous() const; + void set_non_homogeneous(bool bNonHomogeneous); + + /* + * Sets a widget property + * + * @return false if property is unknown + */ + virtual bool set_property(const OString &rKey, const OUString &rValue); + + /* + * Sets a font attribute + * + * @return false if attribute is unknown + */ + bool set_font_attribute(const OString &rKey, std::u16string_view rValue); + + /* + * Adds this widget to the xGroup VclSizeGroup + * + */ + void add_to_size_group(const std::shared_ptr<VclSizeGroup>& xGroup); + void remove_from_all_size_groups(); + + /* + * add/remove mnemonic label + */ + void add_mnemonic_label(FixedText *pLabel); + void remove_mnemonic_label(FixedText *pLabel); + const std::vector<VclPtr<FixedText> >& list_mnemonic_labels() const; + + /* + * Move this widget to be the nNewPosition'd child of its parent + */ + void reorderWithinParent(sal_uInt16 nNewPosition); + + /** + * Sets an ID. + */ + void set_id(const OUString& rID); + + /** + * Get the ID of the window. + */ + const OUString& get_id() const; + + + // Native Widget Rendering functions + + + // form controls must never use native widgets, this can be toggled here + void EnableNativeWidget( bool bEnable = true ); + bool IsNativeWidgetEnabled() const; + + // a helper method for a Control's Draw method + void PaintToDevice( ::OutputDevice* pDevice, const Point& rPos ); + + // Keyboard access functions + + /** Query the states of keyboard indicators - Caps Lock, Num Lock and + Scroll Lock. Use the following mask to retrieve the state of each + indicator: + + KeyIndicatorState::CAPS_LOCK + KeyIndicatorState::NUM_LOCK + KeyIndicatorState::SCROLL_LOCK + */ + KeyIndicatorState GetIndicatorState() const; + + void SimulateKeyPress( sal_uInt16 nKeyCode ) const; + + virtual OUString GetSurroundingText() const; + virtual Selection GetSurroundingTextSelection() const; + virtual bool DeleteSurroundingText(const Selection& rSelection); + + virtual FactoryFunction GetUITestFactory() const; + + virtual bool IsChart() const { return false; } + virtual bool IsStarMath() const { return false; } + + void SetHelpHdl(const Link<vcl::Window&, bool>& rLink); + void SetMnemonicActivateHdl(const Link<vcl::Window&, bool>& rLink); + void SetModalHierarchyHdl(const Link<bool, void>& rLink); + void SetDumpAsPropertyTreeHdl(const Link<tools::JsonWriter&, void>& rLink); + + Size GetOutputSizePixel() const; + tools::Rectangle GetOutputRectPixel() const; + + Point LogicToPixel( const Point& rLogicPt ) const; + Size LogicToPixel( const Size& rLogicSize ) const; + tools::Rectangle LogicToPixel( const tools::Rectangle& rLogicRect ) const; + vcl::Region LogicToPixel( const vcl::Region& rLogicRegion )const; + Point LogicToPixel( const Point& rLogicPt, + const MapMode& rMapMode ) const; + Size LogicToPixel( const Size& rLogicSize, + const MapMode& rMapMode ) const; + tools::Rectangle LogicToPixel( const tools::Rectangle& rLogicRect, + const MapMode& rMapMode ) const; + + Point PixelToLogic( const Point& rDevicePt ) const; + Size PixelToLogic( const Size& rDeviceSize ) const; + tools::Rectangle PixelToLogic( const tools::Rectangle& rDeviceRect ) const; + tools::PolyPolygon PixelToLogic( const tools::PolyPolygon& rDevicePolyPoly ) const; + vcl::Region PixelToLogic( const vcl::Region& rDeviceRegion ) const; + Point PixelToLogic( const Point& rDevicePt, + const MapMode& rMapMode ) const; + Size PixelToLogic( const Size& rDeviceSize, + const MapMode& rMapMode ) const; + tools::Rectangle PixelToLogic( const tools::Rectangle& rDeviceRect, + const MapMode& rMapMode ) const; + + Size LogicToLogic( const Size& rSzSource, + const MapMode* pMapModeSource, + const MapMode* pMapModeDest ) const; + + const AllSettings& GetSettings() const; + void SetSettings( const AllSettings& rSettings ); + void SetSettings( const AllSettings& rSettings, bool bChild ); + + tools::Rectangle GetTextRect( const tools::Rectangle& rRect, + const OUString& rStr, DrawTextFlags nStyle = DrawTextFlags::WordBreak, + TextRectInfo* pInfo = nullptr, + const vcl::ITextLayout* _pTextLayout = nullptr ) const; + float GetDPIScaleFactor() const; + tools::Long GetOutOffXPixel() const; + tools::Long GetOutOffYPixel() const; + + void EnableMapMode( bool bEnable = true ); + bool IsMapModeEnabled() const; + void SetMapMode(); + void SetMapMode( const MapMode& rNewMapMode ); + + // Enabling/disabling RTL only makes sense for OutputDevices that use a mirroring SalGraphicsLayout + virtual void EnableRTL( bool bEnable = true); + bool IsRTLEnabled() const; + + void SetFont( const vcl::Font& rNewFont ); + const vcl::Font& GetFont() const; + + /** Width of the text. + + See also GetTextBoundRect() for more explanation + code examples. + */ + tools::Long GetTextWidth( const OUString& rStr, sal_Int32 nIndex = 0, sal_Int32 nLen = -1, + vcl::text::TextLayoutCache const* = nullptr, + SalLayoutGlyphs const*const pLayoutCache = nullptr) const; + + /** Height where any character of the current font fits; in logic coordinates. + + See also GetTextBoundRect() for more explanation + code examples. + */ + tools::Long GetTextHeight() const; + float approximate_digit_width() const; + + void SetTextColor( const Color& rColor ); + const Color& GetTextColor() const; + + void SetTextFillColor(); + void SetTextFillColor( const Color& rColor ); + Color GetTextFillColor() const; + bool IsTextFillColor() const; + + void SetTextLineColor(); + void SetTextLineColor( const Color& rColor ); + const Color& GetTextLineColor() const; + bool IsTextLineColor() const; + + void SetOverlineColor(); + void SetOverlineColor( const Color& rColor ); + const Color& GetOverlineColor() const; + bool IsOverlineColor() const; + + void SetTextAlign( TextAlign eAlign ); + TextAlign GetTextAlign() const; + + /** Query the platform layer for control support + */ + bool IsNativeControlSupported( ControlType nType, ControlPart nPart ) const; + + static OUString GetNonMnemonicString(const OUString& rStr) { return OutputDevice::GetNonMnemonicString(rStr); } + + /** Query the native control's actual drawing region (including adornment) + */ + bool GetNativeControlRegion( + ControlType nType, + ControlPart nPart, + const tools::Rectangle& rControlRegion, + ControlState nState, + const ImplControlValue& aValue, + tools::Rectangle &rNativeBoundingRegion, + tools::Rectangle &rNativeContentRegion ) const; +protected: + SAL_DLLPRIVATE float approximate_char_width() const; +private: + SAL_DLLPRIVATE void ImplEnableRTL(bool bEnable); +}; + +} + +#endif // INCLUDED_VCL_WINDOW_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/windowstate.hxx b/include/vcl/windowstate.hxx new file mode 100644 index 000000000..dcf0f4e9a --- /dev/null +++ b/include/vcl/windowstate.hxx @@ -0,0 +1,83 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_WINDOWSTATE_HXX +#define INCLUDED_VCL_WINDOWSTATE_HXX + +#include <vcl/dllapi.h> +#include <vcl/vclenum.hxx> +#include <rtl/string.hxx> + +class VCL_PLUGIN_PUBLIC WindowStateData +{ +private: + WindowStateMask mnValidMask; + int mnX; + int mnY; + unsigned int mnWidth; + unsigned int mnHeight; + int mnMaximizedX; + int mnMaximizedY; + unsigned int mnMaximizedWidth; + unsigned int mnMaximizedHeight; + WindowStateState mnState; + +public: + WindowStateData() + : mnValidMask(WindowStateMask::NONE) + , mnX(0) + , mnY(0) + , mnWidth(0) + , mnHeight(0) + , mnMaximizedX(0) + , mnMaximizedY(0) + , mnMaximizedWidth(0) + , mnMaximizedHeight(0) + , mnState(WindowStateState::NONE) + { + } + + void SetMask(WindowStateMask nValidMask) { mnValidMask = nValidMask; } + WindowStateMask GetMask() const { return mnValidMask; } + + void SetX(int nX) { mnX = nX; } + int GetX() const { return mnX; } + void SetY(int nY) { mnY = nY; } + int GetY() const { return mnY; } + void SetWidth(unsigned int nWidth) { mnWidth = nWidth; } + unsigned int GetWidth() const { return mnWidth; } + void SetHeight(unsigned int nHeight) { mnHeight = nHeight; } + unsigned int GetHeight() const { return mnHeight; } + void SetState(WindowStateState nState) { mnState = nState; } + WindowStateState GetState() const { return mnState; } + void SetMaximizedX(int nRX) { mnMaximizedX = nRX; } + int GetMaximizedX() const { return mnMaximizedX; } + void SetMaximizedY(int nRY) { mnMaximizedY = nRY; } + int GetMaximizedY() const { return mnMaximizedY; } + void SetMaximizedWidth(unsigned int nRWidth) { mnMaximizedWidth = nRWidth; } + unsigned int GetMaximizedWidth() const { return mnMaximizedWidth; } + void SetMaximizedHeight(unsigned int nRHeight) { mnMaximizedHeight = nRHeight; } + unsigned int GetMaximizedHeight() const { return mnMaximizedHeight; } + + OString ToStr() const; +}; + +#endif // INCLUDED_VCL_WINDOWSTATE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/winscheduler.hxx b/include/vcl/winscheduler.hxx new file mode 100644 index 000000000..a984b4544 --- /dev/null +++ b/include/vcl/winscheduler.hxx @@ -0,0 +1,44 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_WINSCHEDULER_HXX +#define INCLUDED_VCL_WINSCHEDULER_HXX + +#ifndef _WIN32 +#error This header is just usable on Windows +#else + +#include <vcl/dllapi.h> + +struct VCL_DLLPUBLIC WinScheduler final +{ + /// Hack for Windows native dialogs, which run the main loop, so we can't + /// use the direct processing shortcut. + static void SetForceRealTimer(); + + // Posting a dummy messages might be needed to ensure that main loop eventually returns from + // GetMessage ("wakes up") in modes without a visible window. This, e.g., might be needed to + // let main thread recheck a condition set from another thread. + static void PostDummyMessage(); +}; + +#endif // _WIN32 +#endif // INCLUDED_VCL_WINSCHEDULER_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/wizardmachine.hxx b/include/vcl/wizardmachine.hxx new file mode 100644 index 000000000..a2ce93663 --- /dev/null +++ b/include/vcl/wizardmachine.hxx @@ -0,0 +1,356 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_VCL_WIZARDMACHINE_HXX +#define INCLUDED_VCL_WIZARDMACHINE_HXX + +#include <memory> +#include <vcl/dllapi.h> +#include <vcl/builderpage.hxx> + +namespace weld { + class Builder; + class Container; +} + +struct WizPageData; +struct ImplWizButtonData; + +// wizard states +#define WZS_INVALID_STATE (::vcl::WizardTypes::WizardState(-1)) + +namespace vcl +{ + //= WizardTypes + namespace WizardTypes + { + typedef sal_Int16 WizardState; + enum CommitPageReason + { + eTravelForward, // traveling forward (maybe with skipping pages) + eTravelBackward, // traveling backward (maybe with skipping pages) + eFinish, // the wizard is about to be finished + eValidate // the data should be validated only, no traveling will happen + }; + }; + + class SAL_NO_VTABLE IWizardPageController + { + public: + + // This methods behave somewhat different than ActivatePage/DeactivatePage + // The latter are handled by the base class itself whenever changing the pages is in the offing, + // i.e., when it's already decided which page is the next. + // We may have situations where the next page depends on the state of the current, which needs + // to be committed for this. + // So initializePage and commitPage are designated to initializing/committing data on the page. + virtual void initializePage() = 0; + virtual bool commitPage( WizardTypes::CommitPageReason _eReason ) = 0; + + /** determines whether or not it is allowed to advance to a next page + + You should make this dependent on the current state of the page only, not on + states on other pages of the whole dialog. + + The default implementation always returns <TRUE/>. + */ + virtual bool canAdvance() const = 0; + + protected: + ~IWizardPageController() {} + }; + + //= OWizardPage + class VCL_DLLPUBLIC OWizardPage : public BuilderPage, public IWizardPageController + { + public: + OWizardPage(weld::Container* pPage, weld::DialogController* pController, const OUString& rUIXMLDescription, const OString& rID); + virtual ~OWizardPage() override; + + // IWizardPageController overridables + virtual void initializePage() override; + virtual bool commitPage( WizardTypes::CommitPageReason _eReason ) override; + virtual bool canAdvance() const override; + + protected: + // BuilderPage overridables + virtual void Activate() override; + + /** updates the travel-related UI elements of the OWizardMachine we live in (if any) + + If the parent of the tab page is an OWizardMachine, then updateTravelUI at this instance + is called. Otherwise, nothing happens. + */ + void updateDialogTravelUI(); + }; + + //= OWizardMachine + struct WizardMachineImplData; + /** implements some kind of finite automata, where the states of the automata exactly correlate + with tab pages. + + That is, the machine can have up to n states, where at each point in time exactly one state is + the current one. A state being current is represented as one of n tab pages being displayed + currently. + + The class handles the UI for traveling between the states (e.g. it administrates the <em>Next</em> and + <em>Previous</em> buttons which you usually find in a wizard. + + Derived classes have to implement the travel logic by overriding <member>determineNextState</member>, + which has to determine the state which follows the current state. Since this may depend + on the actual data presented in the wizard (e.g. checkboxes checked, or something like this), + they can implement non-linear traveling this way. + */ + class VCL_DLLPUBLIC WizardMachine : public weld::AssistantController + { + protected: + BuilderPage* m_pCurTabPage; + private: + WizardTypes::WizardState m_nCurState; + WizPageData* m_pFirstPage; + + protected: + std::unique_ptr<weld::Button> m_xFinish; + std::unique_ptr<weld::Button> m_xCancel; + std::unique_ptr<weld::Button> m_xNextPage; + std::unique_ptr<weld::Button> m_xPrevPage; + std::unique_ptr<weld::Button> m_xHelp; + + private: + // hold members in this structure to allow keeping compatible when members are added + std::unique_ptr<WizardMachineImplData> m_pImpl; + + public: + WizardMachine(weld::Window* _pParent, WizardButtonFlags _nButtonFlags ); + virtual ~WizardMachine() override; + + bool Finish(short nResult = RET_CANCEL); + bool ShowPage(WizardTypes::WizardState nState); + + bool ShowNextPage(); + bool ShowPrevPage(); + + void AddPage( std::unique_ptr<BuilderPage> xPage ); + void RemovePage( const BuilderPage* pPage ); + void SetPage( WizardTypes::WizardState nLevel, std::unique_ptr<BuilderPage> xPage ); + BuilderPage* GetPage( WizardTypes::WizardState eState ) const; + + /// enable (or disable) buttons + void enableButtons(WizardButtonFlags _nWizardButtonFlags, bool _bEnable); + /// set the default style for a button + void defaultButton(WizardButtonFlags _nWizardButtonFlags); + /// set the default style for a button + void defaultButton(weld::Button* _pNewDefButton); + + /// set the base of the title to use - the title of the current page is appended + void setTitleBase(const OUString& _rTitleBase); + + /// determines whether there is a next state to which we can advance + virtual bool canAdvance() const; + + /** updates the user interface which deals with traveling in the wizard + + The default implementation simply checks whether both the current page and the wizard + itself allow to advance to the next state (<code>canAdvance</code>), and enables the "Next" + button if and only if this is the case. + */ + virtual void updateTravelUI(); + + protected: + virtual void ActivatePage(); + virtual bool DeactivatePage(); + + // our own overridables + + /// to override to create new pages + virtual std::unique_ptr<BuilderPage> createPage(WizardTypes::WizardState _nState) = 0; + + /// will be called when a new page is about to be displayed + virtual void enterState(WizardTypes::WizardState _nState); + + /** will be called when the current state is about to be left for the given reason + + The base implementation in this class will simply call <member>OWizardPage::commitPage</member> + for the current page, and return whatever this call returns. + + @param _eReason + The reason why the state is to be left. + @return + <TRUE/> if and only if the page is allowed to be left + */ + virtual bool prepareLeaveCurrentState( WizardTypes::CommitPageReason eReason ); + + /** will be called when the given state is left + + This is the very last possibility for derived classes to veto the deactivation + of a page. + + @todo Normally, we would not need the return value here - derived classes now have + the possibility to veto page deactivations in <member>prepareLeaveCurrentState</member>. However, + changing this return type is too incompatible at the moment ... + + @return + <TRUE/> if and only if the page is allowed to be left + */ + virtual bool leaveState(WizardTypes::WizardState nState); + + /** determine the next state to travel from the given one + + The default behaviour is linear traveling, overwrite this to change it + + Return WZS_INVALID_STATE to prevent traveling. + */ + virtual WizardTypes::WizardState determineNextState(WizardTypes::WizardState nCurrentState) const; + + /** called when the finish button is pressed + <p>By default, only the base class' Finish method (which is not virtual) is called</p> + */ + virtual bool onFinish(); + + /// travel to the next state + bool travelNext(); + + /// travel to the previous state + bool travelPrevious(); + + /** enables the automatic enabled/disabled state of the "Next" button + + If this is <TRUE/>, then upon entering a new state, the "Next" button will automatically be + enabled if and only if determineNextState does not return WZS_INVALID_STATE. + */ + void enableAutomaticNextButtonState(); + bool isAutomaticNextButtonStateEnabled() const; + + /** removes a page from the history. Should be called when the page is being disabled + */ + void removePageFromHistory(WizardTypes::WizardState nToRemove); + + /** skip a state + + The method behaves as if from the current state, <arg>_nSteps</arg> <method>travelNext</method>s were + called, but without actually creating or displaying the \EDntermediate pages. Only the + (<arg>_nSteps</arg> + 1)th page is created. + + The skipped states appear in the state history, so <method>travelPrevious</method> will make use of them. + + A very essential precondition for using this method is that your <method>determineNextState</method> + method is able to determine the next state without actually having the page of the current state. + + @see skipUntil + @see skipBackwardUntil + */ + void skip(); + + /** skips one or more states, until a given state is reached + + The method behaves as if from the current state, <method>travelNext</method>s were called + successively, until <arg>_nTargetState</arg> is reached, but without actually creating or + displaying the \EDntermediate pages. + + The skipped states appear in the state history, so <method>travelPrevious</method> will make use of them. + + @return + <TRUE/> if and only if traveling was successful + + @see skip + @see skipBackwardUntil + */ + bool skipUntil(WizardTypes::WizardState nTargetState); + + /** moves back one or more states, until a given state is reached + + This method allows traveling backwards more than one state without actually showing the intermediate + states. + + For instance, if you want to travel two steps backward at a time, you could used + two travelPrevious calls, but this would <em>show</em> both pages, which is not necessary, + since you're interested in the target page only. Using <member>skipBackwardUntil</member> relieves + you of this. + + @return + <TRUE/> if and only if traveling was successful + + @see skipUntil + @see skip + */ + bool skipBackwardUntil(WizardTypes::WizardState nTargetState); + + /** returns the current state of the machine + + Vulgo, this is the identifier of the current tab page :) + */ + WizardTypes::WizardState getCurrentState() const { return m_nCurState; } + + virtual IWizardPageController* getPageController(BuilderPage* pCurrentPage) const; + + /** retrieves a copy of the state history, i.e. all states we already visited + */ + void getStateHistory(std::vector<WizardTypes::WizardState>& out_rHistory); + + public: + class AccessGuard + { + friend class WizardTravelSuspension; + private: + AccessGuard() { } + }; + + void suspendTraveling( AccessGuard ); + void resumeTraveling( AccessGuard ); + bool isTravelingSuspended() const; + + protected: + BuilderPage* GetOrCreatePage(const WizardTypes::WizardState i_nState); + + private: + DECL_DLLPRIVATE_LINK(OnNextPage, weld::Button&, void); + DECL_DLLPRIVATE_LINK(OnPrevPage, weld::Button&, void); + DECL_DLLPRIVATE_LINK(OnFinish, weld::Button&, void); + DECL_DLLPRIVATE_LINK(OnCancel, weld::Button&, void); + + VCL_DLLPRIVATE void implUpdateTitle(); + VCL_DLLPRIVATE void implConstruct( const WizardButtonFlags _nButtonFlags ); + }; + + + /// helper class to temporarily suspend any traveling in the wizard + class WizardTravelSuspension + { + public: + WizardTravelSuspension(WizardMachine& rWizard) + : m_pWizard(&rWizard) + { + m_pWizard->suspendTraveling(WizardMachine::AccessGuard()); + } + + ~WizardTravelSuspension() + { + m_pWizard->resumeTraveling(WizardMachine::AccessGuard()); + } + + private: + WizardMachine* m_pWizard; + }; +} // namespace vcl + +#define WIZARDDIALOG_BUTTON_STDOFFSET_X 6 +#define WIZARDDIALOG_BUTTON_SMALLSTDOFFSET_X 3 + +#endif // INCLUDED_VCL_WIZARDMACHINE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/wmf.hxx b/include/vcl/wmf.hxx new file mode 100644 index 000000000..4acc21465 --- /dev/null +++ b/include/vcl/wmf.hxx @@ -0,0 +1,41 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_WMF_HXX +#define INCLUDED_VCL_WMF_HXX + +#include <vcl/dllapi.h> + +class FilterConfigItem; +class GDIMetaFile; +class SvStream; +class Graphic; + +VCL_DLLPUBLIC bool ReadWindowMetafile( SvStream& rStream, GDIMetaFile& rMTF ); + +VCL_DLLPUBLIC bool ConvertGDIMetaFileToWMF( const GDIMetaFile & rMTF, SvStream & rTargetStream, FilterConfigItem const * pConfigItem, bool bPlaceable = true ); +VCL_DLLPUBLIC bool ConvertGraphicToWMF( const Graphic & rGraphic, SvStream & rTargetStream, FilterConfigItem const * pConfigItem, bool bPlaceable = true ); + +bool ConvertGDIMetaFileToEMF(const GDIMetaFile & rMTF, SvStream & rTargetStream); + +VCL_DLLPUBLIC bool WriteWindowMetafileBits( SvStream& rStream, const GDIMetaFile& rMTF ); + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/wmfexternal.hxx b/include/vcl/wmfexternal.hxx new file mode 100644 index 000000000..fcff240a5 --- /dev/null +++ b/include/vcl/wmfexternal.hxx @@ -0,0 +1,59 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_WMFEXTERNAL_HXX +#define INCLUDED_VCL_WMFEXTERNAL_HXX + +#include <vcl/dllapi.h> +#include <com/sun/star/uno/Sequence.hxx> + +namespace com::sun::star::beans +{ +struct PropertyValue; +} + +struct VCL_DLLPUBLIC WmfExternal +{ + sal_uInt16 xExt; + sal_uInt16 yExt; + + /** One of the following values: + <ul> + <li>MM_TEXT</li> + <li>MM_LOMETRIC</li> + <li>MM_HIMETRIC</li> + <li>MM_LOENGLISH</li> + <li>MM_HIENGLISH</li> + <li>MM_TWIPS</li> + <li>MM_ISOTROPIC</li> + <li>MM_ANISOTROPIC</li> + </ul> + If this value is 0, then no external mapmode has been defined, + the internal one should then be used. + */ + sal_uInt16 mapMode; + + WmfExternal(); + css::uno::Sequence<css::beans::PropertyValue> getSequence() const; + bool setSequence(const css::uno::Sequence<css::beans::PropertyValue>& rSequence); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/wrkwin.hxx b/include/vcl/wrkwin.hxx new file mode 100644 index 000000000..dfc6cc1b3 --- /dev/null +++ b/include/vcl/wrkwin.hxx @@ -0,0 +1,104 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_WRKWIN_HXX +#define INCLUDED_VCL_WRKWIN_HXX + +#include <vcl/dllapi.h> +#include <vcl/syswin.hxx> +#include <o3tl/typed_flags_set.hxx> + +namespace com::sun::star::uno { class Any; } +struct SystemParentData; + + +// Presentation Flags +enum class PresentationFlags +{ + NONE = 0x0000, + HideAllApps = 0x0001, +}; + +namespace o3tl +{ + template<> struct typed_flags<PresentationFlags> : is_typed_flags<PresentationFlags, 0x0001> {}; +} + + +class VCL_DLLPUBLIC WorkWindow : public SystemWindow +{ +private: + PresentationFlags mnPresentationFlags; + bool mbPresentationMode:1, + mbPresentationVisible:1, + mbPresentationFull:1, + mbFullScreenMode:1; + + SAL_DLLPRIVATE void ImplInitWorkWindowData(); + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle, const css::uno::Any& aSystemWorkWindowToken ); + +private: + WorkWindow( const WorkWindow& rWin ) = delete; + WorkWindow& operator =( const WorkWindow& rWin ) = delete; + +protected: + explicit WorkWindow( WindowType nType ); + SAL_DLLPRIVATE void ImplInit( vcl::Window* pParent, WinBits nStyle, SystemParentData* pSystemParentData = nullptr ); + SAL_DLLPRIVATE void ImplSetFrameState( WindowStateState aFrameState ); + +public: + explicit WorkWindow( vcl::Window* pParent, WinBits nStyle = WB_STDWORK ); + explicit WorkWindow( vcl::Window* pParent, const css::uno::Any& aSystemWorkWindowToken, WinBits nStyle = WB_STDWORK ); + explicit WorkWindow( SystemParentData* pParent ); // Not in the REMOTE-Version + virtual ~WorkWindow() override; + virtual void dispose() override; + + virtual bool Close() override; + + void ShowFullScreenMode( bool bFullScreenMode, + sal_Int32 nDisplayScreen ); + /** + @overload void ShowFullScreenMode(bool bFullScreenMode, sal_Int32 nDisplayScreen) + */ + void ShowFullScreenMode( bool bFullScreenMode ); + bool IsFullScreenMode() const { return mbFullScreenMode; } + + void StartPresentationMode( bool bPresentation, + PresentationFlags nFlags, + sal_Int32 nDisplayScreen ); + /** + @overload void StartPresentationMode( PresentationFlags nFlags, sal_uInt32 nDisplayScreen) + */ + void StartPresentationMode( PresentationFlags nFlags ); + bool IsPresentationMode() const { return mbPresentationMode; } + + bool IsMinimized() const; + + void SetPluginParent( SystemParentData* pParent ); + + void Minimize(); + void Restore(); + + void Maximize( bool bMaximize = true ); + bool IsMaximized() const; +}; + +#endif // INCLUDED_VCL_WRKWIN_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/vcl/xtextedt.hxx b/include/vcl/xtextedt.hxx new file mode 100644 index 000000000..d9e06ddd8 --- /dev/null +++ b/include/vcl/xtextedt.hxx @@ -0,0 +1,39 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_VCL_XTEXTEDT_HXX +#define INCLUDED_VCL_XTEXTEDT_HXX + +#include <vcl/dllapi.h> +#include <vcl/texteng.hxx> + +namespace i18nutil { struct SearchOptions; } + +class VCL_DLLPUBLIC ExtTextEngine final : public TextEngine +{ +public: + ExtTextEngine(); + virtual ~ExtTextEngine() override; + + TextSelection MatchGroup( const TextPaM& rCursor ) const; + bool Search( TextSelection& rSel, const i18nutil::SearchOptions& rSearchOptions, bool bForward = true ) const; +}; + +#endif // INCLUDED_VCL_XTEXTEDT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |