diff options
72 files changed, 835 insertions, 388 deletions
diff --git a/basebmp/inc/basebmp/bitmapdevice.hxx b/basebmp/inc/basebmp/bitmapdevice.hxx index 134318b5aaf4..fec226500761 100644 --- a/basebmp/inc/basebmp/bitmapdevice.hxx +++ b/basebmp/inc/basebmp/bitmapdevice.hxx @@ -645,7 +645,7 @@ private: /** Factory method to create a BitmapDevice for given scanline format */ -BitmapDeviceSharedPtr createBitmapDevice( const basegfx::B2IVector& rSize, +BASEBMP_DLLPUBLIC BitmapDeviceSharedPtr createBitmapDevice( const basegfx::B2IVector& rSize, bool bTopDown, sal_Int32 nScanlineFormat ); @@ -656,7 +656,7 @@ BitmapDeviceSharedPtr createBitmapDevice( const basegfx::B2IVector& rSize, lookups for the whole range of pixel values from the specified format. */ -BitmapDeviceSharedPtr createBitmapDevice( const basegfx::B2IVector& rSize, +BASEBMP_DLLPUBLIC BitmapDeviceSharedPtr createBitmapDevice( const basegfx::B2IVector& rSize, bool bTopDown, sal_Int32 nScanlineFormat, const PaletteMemorySharedVector& rPalette ); @@ -667,7 +667,7 @@ BitmapDeviceSharedPtr createBitmapDevice( const basegfx::B2IVector& rSize Note: the provided memory must have sufficient size, to store the image of the specified area and format. */ -BitmapDeviceSharedPtr createBitmapDevice( const basegfx::B2IVector& rSize, +BASEBMP_DLLPUBLIC BitmapDeviceSharedPtr createBitmapDevice( const basegfx::B2IVector& rSize, bool bTopDown, sal_Int32 nScanlineFormat, const RawMemorySharedArray& rMem, @@ -682,7 +682,7 @@ BitmapDeviceSharedPtr createBitmapDevice( const basegfx::B2IVector& rSize area. Useful to implement rectangular clips (usually faster than setting up a 1bpp clip mask). */ -BitmapDeviceSharedPtr subsetBitmapDevice( const BitmapDeviceSharedPtr& rProto, +BASEBMP_DLLPUBLIC BitmapDeviceSharedPtr subsetBitmapDevice( const BitmapDeviceSharedPtr& rProto, const basegfx::B2IRange& rSubset ); /** Factory method to clone a BitmapDevice from a given prototype. @@ -691,7 +691,7 @@ BitmapDeviceSharedPtr subsetBitmapDevice( const BitmapDeviceSharedPtr& rProt copied, only the size can be varied. Note that the prototype's bitmap content is <em>not</em> copied, only a palette (if any). */ -BitmapDeviceSharedPtr cloneBitmapDevice( const basegfx::B2IVector& rSize, +BASEBMP_DLLPUBLIC BitmapDeviceSharedPtr cloneBitmapDevice( const basegfx::B2IVector& rSize, const BitmapDeviceSharedPtr& rProto ); } diff --git a/basegfx/CppunitTest_basegfx.mk b/basegfx/CppunitTest_basegfx.mk new file mode 100644 index 000000000000..e31b025b1f54 --- /dev/null +++ b/basegfx/CppunitTest_basegfx.mk @@ -0,0 +1,41 @@ +#************************************************************************* +# +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# Copyright 2000, 2011 Oracle and/or its affiliates. +# +# OpenOffice.org - a multi-platform office productivity suite +# +# This file is part of OpenOffice.org. +# +# OpenOffice.org is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 +# only, as published by the Free Software Foundation. +# +# OpenOffice.org is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License version 3 for more details +# (a copy is included in the LICENSE file that accompanied this code). +# +# You should have received a copy of the GNU Lesser General Public License +# version 3 along with OpenOffice.org. If not, see +# <http://www.openoffice.org/license.html> +# for a copy of the LGPLv3 License. +# +#************************************************************************* + +$(eval $(call gb_CppunitTest_CppunitTest,MODULE_NAME)) + +$(eval $(call gb_CppunitTest_add_exception_objects,MODULE_NAME, \ +)) + +$(eval $(call gb_CppunitTest_add_linked_libs,MODULE_NAME, \ + $(gb_STDLIBS) \ +)) + +$(eval $(call gb_CppunitTest_set_include,MODULE_NAME,\ + $$(INCLUDE) \ +)) + +# vim: set noet sw=4 ts=4: diff --git a/basegfx/Library_basegfx.mk b/basegfx/Library_basegfx.mk new file mode 100644 index 000000000000..22b804dcb8a8 --- /dev/null +++ b/basegfx/Library_basegfx.mk @@ -0,0 +1,118 @@ +#************************************************************************* +# +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# Copyright 2000, 2011 Oracle and/or its affiliates. +# +# OpenOffice.org - a multi-platform office productivity suite +# +# This file is part of OpenOffice.org. +# +# OpenOffice.org is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 +# only, as published by the Free Software Foundation. +# +# OpenOffice.org is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License version 3 for more details +# (a copy is included in the LICENSE file that accompanied this code). +# +# You should have received a copy of the GNU Lesser General Public License +# version 3 along with OpenOffice.org. If not, see +# <http://www.openoffice.org/license.html> +# for a copy of the LGPLv3 License. +# +#************************************************************************* + +$(eval $(call gb_Library_Library,basegfx)) + +$(eval $(call gb_Library_add_package_headers,basegfx,basegfx_inc)) + +$(eval $(call gb_Library_add_precompiled_header,basegfx,$(SRCDIR)/basegfx/inc/pch/precompiled_basegfx)) + +$(eval $(call gb_Library_set_include,basegfx,\ + -I$(SRCDIR)/basegfx/inc \ + -I$(SRCDIR)/basegfx/source/inc \ + -I$(SRCDIR)/basegfx/inc/pch \ + $$(INCLUDE) \ + -I$(OUTDIR)/inc/offuh \ +)) + +$(eval $(call gb_Library_set_defs,basegfx,\ + $$(DEFS) \ + -DBASEGFX_DLLIMPLEMENTATION \ +)) + +$(eval $(call gb_Library_add_linked_libs,basegfx,\ + sal \ + cppu \ + cppuhelper \ + $(gb_STDLIBS) \ +)) + +$(eval $(call gb_Library_add_exception_objects,basegfx,\ + basegfx/source/tools/liangbarsky \ + basegfx/source/tools/debugplotter \ + basegfx/source/tools/canvastools \ + basegfx/source/tools/gradienttools \ + basegfx/source/tools/keystoplerp \ + basegfx/source/tools/unopolypolygon \ + basegfx/source/tools/tools \ + basegfx/source/tools/b2dclipstate \ + basegfx/source/numeric/ftools \ + basegfx/source/tuple/b3ituple \ + basegfx/source/tuple/b3dtuple \ + basegfx/source/tuple/b2ituple \ + basegfx/source/tuple/b2dtuple \ + basegfx/source/tuple/b3i64tuple \ + basegfx/source/tuple/b2i64tuple \ + basegfx/source/range/b1drange \ + basegfx/source/range/b2dpolyrange \ + basegfx/source/range/b2xrange \ + basegfx/source/range/b3drange \ + basegfx/source/range/b2drangeclipper \ + basegfx/source/range/b2drange \ + basegfx/source/vector/b3ivector \ + basegfx/source/vector/b2ivector \ + basegfx/source/vector/b2dvector \ + basegfx/source/vector/b3dvector \ + basegfx/source/polygon/b3dpolygon \ + basegfx/source/polygon/b2dtrapezoid \ + basegfx/source/polygon/b3dpolygontools \ + basegfx/source/polygon/b2dlinegeometry \ + basegfx/source/polygon/b3dpolypolygontools \ + basegfx/source/polygon/b3dpolygonclipper \ + basegfx/source/polygon/b2dpolygonclipper \ + basegfx/source/polygon/b2dpolypolygoncutter \ + basegfx/source/polygon/b2dpolypolygonrasterconverter \ + basegfx/source/polygon/b2dpolygon \ + basegfx/source/polygon/b2dpolygontriangulator \ + basegfx/source/polygon/b2dpolypolygon \ + basegfx/source/polygon/b3dpolypolygon \ + basegfx/source/polygon/b2dsvgpolypolygon \ + basegfx/source/polygon/b2dpolygoncutandtouch \ + basegfx/source/polygon/b2dpolypolygontools \ + basegfx/source/polygon/b2dpolygontools \ + basegfx/source/pixel/bpixel \ + basegfx/source/matrix/b2dhommatrixtools \ + basegfx/source/matrix/b3dhommatrix \ + basegfx/source/matrix/b2dhommatrix \ + basegfx/source/point/b3ipoint \ + basegfx/source/point/b3dhompoint \ + basegfx/source/point/b2dpoint \ + basegfx/source/point/b3dpoint \ + basegfx/source/point/b2dhompoint \ + basegfx/source/point/b2ipoint \ + basegfx/source/curve/b2dbeziertools \ + basegfx/source/curve/b2dcubicbezier \ + basegfx/source/curve/b2dquadraticbezier \ + basegfx/source/color/bcolormodifier \ + basegfx/source/color/bcolor \ + basegfx/source/color/bcolortools \ + basegfx/source/raster/bpixelraster \ + basegfx/source/raster/bzpixelraster \ + basegfx/source/raster/rasterconvert3d \ +)) + +# vim: set noet sw=4 ts=4: diff --git a/basegfx/Makefile b/basegfx/Makefile new file mode 100644 index 000000000000..90947b2e5f48 --- /dev/null +++ b/basegfx/Makefile @@ -0,0 +1,38 @@ +#************************************************************************* +# +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# Copyright 2000, 2011 Oracle and/or its affiliates. +# +# OpenOffice.org - a multi-platform office productivity suite +# +# This file is part of OpenOffice.org. +# +# OpenOffice.org is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 +# only, as published by the Free Software Foundation. +# +# OpenOffice.org is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License version 3 for more details +# (a copy is included in the LICENSE file that accompanied this code). +# +# You should have received a copy of the GNU Lesser General Public License +# version 3 along with OpenOffice.org. If not, see +# <http://www.openoffice.org/license.html> +# for a copy of the LGPLv3 License. +# +#************************************************************************* + +ifeq ($(strip $(SOLARENV)),) +$(error No environment set!) +endif + +gb_PARTIALBUILD := T +GBUILDDIR := $(SOLARENV)/gbuild +include $(GBUILDDIR)/gbuild.mk + +$(eval $(call gb_Module_make_global_targets,$(shell ls $(dir $(realpath $(firstword $(MAKEFILE_LIST))))/Module*.mk))) + +# vim: set noet sw=4 ts=4: diff --git a/basegfx/Module_basegfx.mk b/basegfx/Module_basegfx.mk new file mode 100644 index 000000000000..91f173ea8a25 --- /dev/null +++ b/basegfx/Module_basegfx.mk @@ -0,0 +1,38 @@ +#************************************************************************* +# +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# Copyright 2000, 2011 Oracle and/or its affiliates. +# +# OpenOffice.org - a multi-platform office productivity suite +# +# This file is part of OpenOffice.org. +# +# OpenOffice.org is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 +# only, as published by the Free Software Foundation. +# +# OpenOffice.org is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License version 3 for more details +# (a copy is included in the LICENSE file that accompanied this code). +# +# You should have received a copy of the GNU Lesser General Public License +# version 3 along with OpenOffice.org. If not, see +# <http://www.openoffice.org/license.html> +# for a copy of the LGPLv3 License. +# +#************************************************************************* + +$(eval $(call gb_Module_Module,basegfx)) + +$(eval $(call gb_Module_add_targets,basegfx,\ + Library_basegfx \ + Package_inc \ +)) + +$(eval $(call gb_Module_add_check_targets,basegfx,\ +)) + +# vim: set noet sw=4 ts=4: diff --git a/basegfx/Package_inc.mk b/basegfx/Package_inc.mk new file mode 100644 index 000000000000..1f8fbd63542d --- /dev/null +++ b/basegfx/Package_inc.mk @@ -0,0 +1,112 @@ +#************************************************************************* +# +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# Copyright 2000, 2011 Oracle and/or its affiliates. +# +# OpenOffice.org - a multi-platform office productivity suite +# +# This file is part of OpenOffice.org. +# +# OpenOffice.org is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 +# only, as published by the Free Software Foundation. +# +# OpenOffice.org is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License version 3 for more details +# (a copy is included in the LICENSE file that accompanied this code). +# +# You should have received a copy of the GNU Lesser General Public License +# version 3 along with OpenOffice.org. If not, see +# <http://www.openoffice.org/license.html> +# for a copy of the LGPLv3 License. +# +#************************************************************************* + +$(eval $(call gb_Package_Package,basegfx_inc,$(SRCDIR)/basegfx/inc)) + +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/tools/lerp.hxx,basegfx/tools/lerp.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/tools/keystoplerp.hxx,basegfx/tools/keystoplerp.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/tools/debugplotter.hxx,basegfx/tools/debugplotter.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/tools/canvastools.hxx,basegfx/tools/canvastools.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/tools/rectcliptools.hxx,basegfx/tools/rectcliptools.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/tools/b2dclipstate.hxx,basegfx/tools/b2dclipstate.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/tools/unopolypolygon.hxx,basegfx/tools/unopolypolygon.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/tools/tools.hxx,basegfx/tools/tools.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/tools/gradienttools.hxx,basegfx/tools/gradienttools.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/numeric/ftools.hxx,basegfx/numeric/ftools.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/tuple/b3i64tuple.hxx,basegfx/tuple/b3i64tuple.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/tuple/b3dtuple.hxx,basegfx/tuple/b3dtuple.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/tuple/b3ituple.hxx,basegfx/tuple/b3ituple.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/tuple/b2i64tuple.hxx,basegfx/tuple/b2i64tuple.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/tuple/b2ituple.hxx,basegfx/tuple/b2ituple.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/tuple/b2dtuple.hxx,basegfx/tuple/b2dtuple.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/b2drangeclipper.hxx,basegfx/range/b2drangeclipper.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/b3irange.hxx,basegfx/range/b3irange.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/b3dvolume.hxx,basegfx/range/b3dvolume.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/basicbox.hxx,basegfx/range/basicbox.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/b2dconnectedranges.hxx,basegfx/range/b2dconnectedranges.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/b3drange.hxx,basegfx/range/b3drange.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/b2drange.hxx,basegfx/range/b2drange.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/rangeexpander.hxx,basegfx/range/rangeexpander.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/b2irange.hxx,basegfx/range/b2irange.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/b1ibox.hxx,basegfx/range/b1ibox.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/b2dpolyrange.hxx,basegfx/range/b2dpolyrange.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/b3ivolume.hxx,basegfx/range/b3ivolume.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/b1irange.hxx,basegfx/range/b1irange.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/b2drectangle.hxx,basegfx/range/b2drectangle.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/b2irectangle.hxx,basegfx/range/b2irectangle.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/b1drange.hxx,basegfx/range/b1drange.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/b2ibox.hxx,basegfx/range/b2ibox.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/b3ibox.hxx,basegfx/range/b3ibox.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/range/basicrange.hxx,basegfx/range/basicrange.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/vector/b3dsize.hxx,basegfx/vector/b3dsize.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/vector/b2ivector.hxx,basegfx/vector/b2ivector.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/vector/b2dvector.hxx,basegfx/vector/b2dvector.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/vector/b3dvector.hxx,basegfx/vector/b3dvector.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/vector/b2dsize.hxx,basegfx/vector/b2dsize.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/vector/b2isize.hxx,basegfx/vector/b2isize.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/vector/b2enums.hxx,basegfx/vector/b2enums.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/vector/b3ivector.hxx,basegfx/vector/b3ivector.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/vector/b3isize.hxx,basegfx/vector/b3isize.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b2dtrapezoid.hxx,basegfx/polygon/b2dtrapezoid.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b2dpolypolygoncutter.hxx,basegfx/polygon/b2dpolypolygoncutter.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b2dpolypolygon.hxx,basegfx/polygon/b2dpolypolygon.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b2dpolypolygontools.hxx,basegfx/polygon/b2dpolypolygontools.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b2dpolygon.hxx,basegfx/polygon/b2dpolygon.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b2dpolygonclipper.hxx,basegfx/polygon/b2dpolygonclipper.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b2dpolypolygonfillrule.hxx,basegfx/polygon/b2dpolypolygonfillrule.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b2dpolygontriangulator.hxx,basegfx/polygon/b2dpolygontriangulator.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b3dpolygontools.hxx,basegfx/polygon/b3dpolygontools.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b2dpolygontools.hxx,basegfx/polygon/b2dpolygontools.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b3dpolypolygon.hxx,basegfx/polygon/b3dpolypolygon.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b2dpolygoncutandtouch.hxx,basegfx/polygon/b2dpolygoncutandtouch.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b2dlinegeometry.hxx,basegfx/polygon/b2dlinegeometry.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b3dpolypolygontools.hxx,basegfx/polygon/b3dpolypolygontools.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx,basegfx/polygon/b2dpolypolygonrasterconverter.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b3dpolygon.hxx,basegfx/polygon/b3dpolygon.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/polygon/b3dpolygonclipper.hxx,basegfx/polygon/b3dpolygonclipper.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/pixel/bpixel.hxx,basegfx/pixel/bpixel.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/matrix/b2dhommatrix.hxx,basegfx/matrix/b2dhommatrix.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/matrix/b3dhommatrix.hxx,basegfx/matrix/b3dhommatrix.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/matrix/b2dhommatrixtools.hxx,basegfx/matrix/b2dhommatrixtools.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/point/b3dhompoint.hxx,basegfx/point/b3dhompoint.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/point/b3ipoint.hxx,basegfx/point/b3ipoint.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/point/b3dpoint.hxx,basegfx/point/b3dpoint.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/point/b2dpoint.hxx,basegfx/point/b2dpoint.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/point/b2dhompoint.hxx,basegfx/point/b2dhompoint.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/point/b2ipoint.hxx,basegfx/point/b2ipoint.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/curve/b2dcubicbezier.hxx,basegfx/curve/b2dcubicbezier.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/curve/b2dquadraticbezier.hxx,basegfx/curve/b2dquadraticbezier.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/curve/b2dbeziertools.hxx,basegfx/curve/b2dbeziertools.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/color/bcolor.hxx,basegfx/color/bcolor.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/color/bcolortools.hxx,basegfx/color/bcolortools.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/color/bcolormodifier.hxx,basegfx/color/bcolormodifier.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/raster/bpixelraster.hxx,basegfx/raster/bpixelraster.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/raster/rasterconvert3d.hxx,basegfx/raster/rasterconvert3d.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/raster/bzpixelraster.hxx,basegfx/raster/bzpixelraster.hxx)) +$(eval $(call gb_Package_add_file,basegfx_inc,inc/basegfx/basegfxdllapi.h,basegfx/basegfxdllapi.h)) + +# vim: set noet sw=4 ts=4: diff --git a/basegfx/inc/basegfx/basegfxdllapi.h b/basegfx/inc/basegfx/basegfxdllapi.h new file mode 100644 index 000000000000..2088ea293e92 --- /dev/null +++ b/basegfx/inc/basegfx/basegfxdllapi.h @@ -0,0 +1,37 @@ +/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+#ifndef INCLUDED_BASEGFXDLLAPI_H
+#define INCLUDED_BASEGFXDLLAPI_H
+
+#if defined BASEGFX_DLLIMPLEMENTATION
+#define BASEGFX_DLLPUBLIC SAL_DLLPUBLIC_EXPORT
+#else
+#define BASEGFX_DLLPUBLIC SAL_DLLPUBLIC_IMPORT
+#endif
+#define BASEGFX_DLLPRIVATE SAL_DLLPRIVATE
+
+#endif
diff --git a/basegfx/inc/basegfx/color/bcolor.hxx b/basegfx/inc/basegfx/color/bcolor.hxx index db66dd8dbdee..496b381b1322 100644 --- a/basegfx/inc/basegfx/color/bcolor.hxx +++ b/basegfx/inc/basegfx/color/bcolor.hxx @@ -32,6 +32,7 @@ #include <com/sun/star/uno/Reference.hxx> #include <com/sun/star/uno/Sequence.hxx> #include <vector> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// // predeclarations @@ -52,7 +53,7 @@ namespace basegfx @see B3DTuple */ - class BColor : public B3DTuple + class BASEGFX_DLLPUBLIC BColor : public B3DTuple { public: /** Create a Color with red, green and blue components from [0.0 to 1.0] diff --git a/basegfx/inc/basegfx/color/bcolormodifier.hxx b/basegfx/inc/basegfx/color/bcolormodifier.hxx index 962da760f850..0804eb635a87 100644 --- a/basegfx/inc/basegfx/color/bcolormodifier.hxx +++ b/basegfx/inc/basegfx/color/bcolormodifier.hxx @@ -30,6 +30,7 @@ #include <basegfx/color/bcolor.hxx> #include <vector> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// @@ -48,7 +49,7 @@ namespace basegfx /** Class to hold a color, value and mode for a color modification. Color modification is done calling the getModifiedColor() method */ - class BColorModifier + class BASEGFX_DLLPUBLIC BColorModifier { protected: ::basegfx::BColor maBColor; @@ -88,7 +89,7 @@ namespace basegfx /** Class to hold a stack of BColorModifiers and to get the modified color with applying all existing entry changes */ - class BColorModifierStack + class BASEGFX_DLLPUBLIC BColorModifierStack { protected: ::std::vector< BColorModifier > maBColorModifiers; diff --git a/basegfx/inc/basegfx/color/bcolortools.hxx b/basegfx/inc/basegfx/color/bcolortools.hxx index 9121b145afa7..e5b54e6829fd 100644 --- a/basegfx/inc/basegfx/color/bcolortools.hxx +++ b/basegfx/inc/basegfx/color/bcolortools.hxx @@ -29,6 +29,7 @@ #define _BGFX_COLOR_BCOLORTOOLS_HXX #include <sal/types.h> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// @@ -39,29 +40,29 @@ namespace basegfx namespace tools { /// Transform from RGB to HSL - BColor rgb2hsl(const BColor& rRGBColor); + BASEGFX_DLLPUBLIC BColor rgb2hsl(const BColor& rRGBColor); /// Transform from HSL to RGB - BColor hsl2rgb(const BColor& rHSLColor); + BASEGFX_DLLPUBLIC BColor hsl2rgb(const BColor& rHSLColor); /// Transform from RGB to HSV - BColor rgb2hsv(const BColor& rRGBColor); + BASEGFX_DLLPUBLIC BColor rgb2hsv(const BColor& rRGBColor); /// Transform from HSV to RGB - BColor hsv2rgb(const BColor& rHSVColor); + BASEGFX_DLLPUBLIC BColor hsv2rgb(const BColor& rHSVColor); /// Transform from R'G'B' to YIQ (NTSC color model - Y is used in monochrome mode) - BColor rgb2yiq(const BColor& rRGBColor); + BASEGFX_DLLPUBLIC BColor rgb2yiq(const BColor& rRGBColor); /// Transform from YIQ to R'G'B' (NTSC color model - Y is used in monochrome mode) - BColor yiq2rgb(const BColor& rYIQColor); + BASEGFX_DLLPUBLIC BColor yiq2rgb(const BColor& rYIQColor); /// Transform from R'G'B' to Y'PbPr (the [0,1]x[-.5,.5]x[-.5,.5] equivalent of Y'CbCr (which is scaled into 8bit)) - BColor rgb2ypbpr(const BColor& rRGBColor); + BASEGFX_DLLPUBLIC BColor rgb2ypbpr(const BColor& rRGBColor); /// Transform from Y'PbPr (the [0,1]x[-.5,.5]x[-.5,.5] equivalent of Y'CbCr (which is scaled into 8bit)) into R'G'B' - BColor ypbpr2rgb(const BColor& rYPbPrColor); + BASEGFX_DLLPUBLIC BColor ypbpr2rgb(const BColor& rYPbPrColor); /// Transform from CIE XYZ into Rec. 709 RGB (D65 white point) - BColor ciexyz2rgb( const BColor& rXYZColor ); + BASEGFX_DLLPUBLIC BColor ciexyz2rgb( const BColor& rXYZColor ); /// Transform from Rec. 709 RGB (D65 white point) into CIE XYZ - BColor rgb2ciexyz( const BColor& rRGBColor ); + BASEGFX_DLLPUBLIC BColor rgb2ciexyz( const BColor& rRGBColor ); } } // end of namespace basegfx diff --git a/basegfx/inc/basegfx/curve/b2dbeziertools.hxx b/basegfx/inc/basegfx/curve/b2dbeziertools.hxx index 3cc34fec5482..fa06ebcdbd05 100644 --- a/basegfx/inc/basegfx/curve/b2dbeziertools.hxx +++ b/basegfx/inc/basegfx/curve/b2dbeziertools.hxx @@ -30,6 +30,7 @@ #include <sal/types.h> #include <vector> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// // predefines @@ -43,7 +44,7 @@ namespace basegfx namespace basegfx { - class B2DCubicBezierHelper + class BASEGFX_DLLPUBLIC B2DCubicBezierHelper { private: ::std::vector< double > maLengthArray; diff --git a/basegfx/inc/basegfx/curve/b2dcubicbezier.hxx b/basegfx/inc/basegfx/curve/b2dcubicbezier.hxx index ea58a0a50b80..9603a423b224 100644 --- a/basegfx/inc/basegfx/curve/b2dcubicbezier.hxx +++ b/basegfx/inc/basegfx/curve/b2dcubicbezier.hxx @@ -30,6 +30,7 @@ #include <basegfx/point/b2dpoint.hxx> #include <basegfx/range/b2drange.hxx> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// // predeclarations @@ -43,7 +44,7 @@ namespace basegfx namespace basegfx { - class B2DCubicBezier + class BASEGFX_DLLPUBLIC B2DCubicBezier { B2DPoint maStartPoint; B2DPoint maEndPoint; diff --git a/basegfx/inc/basegfx/curve/b2dquadraticbezier.hxx b/basegfx/inc/basegfx/curve/b2dquadraticbezier.hxx index 08cd6be59c78..4f3ee7169a1e 100644 --- a/basegfx/inc/basegfx/curve/b2dquadraticbezier.hxx +++ b/basegfx/inc/basegfx/curve/b2dquadraticbezier.hxx @@ -29,12 +29,13 @@ #define _BGFX_CURVE_B2DQUADRATICBEZIER_HXX #include <basegfx/point/b2dpoint.hxx> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// namespace basegfx { - class B2DQuadraticBezier + class BASEGFX_DLLPUBLIC B2DQuadraticBezier { ::basegfx::B2DPoint maStartPoint; ::basegfx::B2DPoint maEndPoint; diff --git a/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx b/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx index 910224897301..3a8d9fea2390 100644 --- a/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx +++ b/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx @@ -30,13 +30,14 @@ #include <sal/types.h> #include <o3tl/cow_wrapper.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { class B2DTuple; class Impl2DHomMatrix; - class B2DHomMatrix + class BASEGFX_DLLPUBLIC B2DHomMatrix { public: typedef o3tl::cow_wrapper< Impl2DHomMatrix > ImplType; diff --git a/basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx b/basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx index 7ce9e75c3058..047480a818dc 100644 --- a/basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx +++ b/basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx @@ -31,6 +31,7 @@ #include <sal/types.h> #include <basegfx/matrix/b2dhommatrix.hxx> #include <basegfx/vector/b2dvector.hxx> +#include <basegfx/basegfxdllapi.h> namespace rtl { class OUString; } @@ -48,16 +49,16 @@ namespace basegfx would introduce slight roundoff errors, instead of exactly mirroring the coordinate system) */ - void createSinCosOrthogonal(double& o_rSin, double& rCos, double fRadiant); + BASEGFX_DLLPUBLIC void createSinCosOrthogonal(double& o_rSin, double& rCos, double fRadiant); /** Tooling methods for on-the-fly matrix generation e.g. for inline multiplications */ - B2DHomMatrix createScaleB2DHomMatrix(double fScaleX, double fScaleY); - B2DHomMatrix createShearXB2DHomMatrix(double fShearX); - B2DHomMatrix createShearYB2DHomMatrix(double fShearY); - B2DHomMatrix createRotateB2DHomMatrix(double fRadiant); - B2DHomMatrix createTranslateB2DHomMatrix(double fTranslateX, double fTranslateY); + BASEGFX_DLLPUBLIC B2DHomMatrix createScaleB2DHomMatrix(double fScaleX, double fScaleY); + BASEGFX_DLLPUBLIC B2DHomMatrix createShearXB2DHomMatrix(double fShearX); + BASEGFX_DLLPUBLIC B2DHomMatrix createShearYB2DHomMatrix(double fShearY); + BASEGFX_DLLPUBLIC B2DHomMatrix createRotateB2DHomMatrix(double fRadiant); + BASEGFX_DLLPUBLIC B2DHomMatrix createTranslateB2DHomMatrix(double fTranslateX, double fTranslateY); /// inline versions for parameters as tuples inline B2DHomMatrix createScaleB2DHomMatrix(const B2DTuple& rScale) @@ -77,7 +78,7 @@ namespace basegfx matrix multiplications. Inline versions for parameters as tuples added, too. */ - B2DHomMatrix createScaleShearXRotateTranslateB2DHomMatrix( + BASEGFX_DLLPUBLIC B2DHomMatrix createScaleShearXRotateTranslateB2DHomMatrix( double fScaleX, double fScaleY, double fShearX, double fRadiant, @@ -95,7 +96,7 @@ namespace basegfx rTranslate.getX(), rTranslate.getY()); } - B2DHomMatrix createShearXRotateTranslateB2DHomMatrix( + BASEGFX_DLLPUBLIC B2DHomMatrix createShearXRotateTranslateB2DHomMatrix( double fShearX, double fRadiant, double fTranslateX, double fTranslateY); @@ -110,7 +111,7 @@ namespace basegfx rTranslate.getX(), rTranslate.getY()); } - B2DHomMatrix createScaleTranslateB2DHomMatrix( + BASEGFX_DLLPUBLIC B2DHomMatrix createScaleTranslateB2DHomMatrix( double fScaleX, double fScaleY, double fTranslateX, double fTranslateY); inline B2DHomMatrix createScaleTranslateB2DHomMatrix( @@ -123,7 +124,7 @@ namespace basegfx } /// special for the often used case of rotation around a point - B2DHomMatrix createRotateAroundPoint( + BASEGFX_DLLPUBLIC B2DHomMatrix createRotateAroundPoint( double fPointX, double fPointY, double fRadiant); inline B2DHomMatrix createRotateAroundPoint( @@ -144,7 +145,7 @@ namespace basegfx { namespace tools { - class B2DHomMatrixBufferedDecompose + class BASEGFX_DLLPUBLIC B2DHomMatrixBufferedDecompose { private: B2DVector maScale; @@ -183,7 +184,7 @@ namespace basegfx { namespace tools { - class B2DHomMatrixBufferedOnDemandDecompose + class BASEGFX_DLLPUBLIC B2DHomMatrixBufferedOnDemandDecompose { private: B2DHomMatrix maB2DHomMatrix; diff --git a/basegfx/inc/basegfx/matrix/b3dhommatrix.hxx b/basegfx/inc/basegfx/matrix/b3dhommatrix.hxx index bc35fcde321e..4391d7b8d8e6 100644 --- a/basegfx/inc/basegfx/matrix/b3dhommatrix.hxx +++ b/basegfx/inc/basegfx/matrix/b3dhommatrix.hxx @@ -32,13 +32,14 @@ #include <basegfx/point/b3dpoint.hxx> #include <basegfx/vector/b3dvector.hxx> #include <o3tl/cow_wrapper.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { class B3DTuple; class Impl3DHomMatrix; - class B3DHomMatrix + class BASEGFX_DLLPUBLIC B3DHomMatrix { public: typedef o3tl::cow_wrapper< Impl3DHomMatrix > ImplType; diff --git a/basegfx/inc/basegfx/numeric/ftools.hxx b/basegfx/inc/basegfx/numeric/ftools.hxx index 65a6566dae25..10ebd89f610c 100644 --- a/basegfx/inc/basegfx/numeric/ftools.hxx +++ b/basegfx/inc/basegfx/numeric/ftools.hxx @@ -29,6 +29,7 @@ #define _BGFX_NUMERIC_FTOOLS_HXX #include <rtl/math.hxx> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// // standard PI defines from solar.h, but we do not want to link against tools @@ -144,7 +145,7 @@ namespace basegfx } - class fTools + class BASEGFX_DLLPUBLIC fTools { /// Threshold value for equalZero() static double mfSmallValue; diff --git a/basegfx/inc/basegfx/pixel/bpixel.hxx b/basegfx/inc/basegfx/pixel/bpixel.hxx index 2684ff44e5d6..b40a05f8b082 100644 --- a/basegfx/inc/basegfx/pixel/bpixel.hxx +++ b/basegfx/inc/basegfx/pixel/bpixel.hxx @@ -31,6 +31,7 @@ #include <sal/types.h> #include <basegfx/numeric/ftools.hxx> #include <basegfx/color/bcolor.hxx> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// // predeclarations @@ -39,7 +40,7 @@ namespace basegfx { - class BPixel + class BASEGFX_DLLPUBLIC BPixel { protected: union diff --git a/basegfx/inc/basegfx/point/b2dhompoint.hxx b/basegfx/inc/basegfx/point/b2dhompoint.hxx index 254ee9251dd3..07815e3feabe 100644 --- a/basegfx/inc/basegfx/point/b2dhompoint.hxx +++ b/basegfx/inc/basegfx/point/b2dhompoint.hxx @@ -29,6 +29,7 @@ #define _BGFX_POINT_B2DHOMPOINT_HXX #include <basegfx/point/b2dpoint.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { @@ -45,7 +46,7 @@ namespace basegfx @see B2DTuple */ - class B2DHomPoint + class BASEGFX_DLLPUBLIC B2DHomPoint { protected: /// This member contains the coordinate part of the point @@ -205,31 +206,31 @@ namespace basegfx // external operators ////////////////////////////////////////////////////////////////////////// - B2DHomPoint minimum(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB); + BASEGFX_DLLPUBLIC B2DHomPoint minimum(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB); - B2DHomPoint maximum(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB); + BASEGFX_DLLPUBLIC B2DHomPoint maximum(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB); - B2DHomPoint absolute(const B2DHomPoint& rVec); + BASEGFX_DLLPUBLIC B2DHomPoint absolute(const B2DHomPoint& rVec); - B2DHomPoint interpolate(B2DHomPoint& rOld1, B2DHomPoint& rOld2, double t); + BASEGFX_DLLPUBLIC B2DHomPoint interpolate(B2DHomPoint& rOld1, B2DHomPoint& rOld2, double t); - B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2); + BASEGFX_DLLPUBLIC B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2); - B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2, B2DHomPoint& rOld3); + BASEGFX_DLLPUBLIC B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2, B2DHomPoint& rOld3); - B2DHomPoint operator+(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB); + BASEGFX_DLLPUBLIC B2DHomPoint operator+(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB); - B2DHomPoint operator-(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB); + BASEGFX_DLLPUBLIC B2DHomPoint operator-(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB); - B2DHomPoint operator*(const B2DHomPoint& rVec, double t); + BASEGFX_DLLPUBLIC B2DHomPoint operator*(const B2DHomPoint& rVec, double t); - B2DHomPoint operator*(double t, const B2DHomPoint& rVec); + BASEGFX_DLLPUBLIC B2DHomPoint operator*(double t, const B2DHomPoint& rVec); - B2DHomPoint operator*( const B2DHomMatrix& rMat, const B2DHomPoint& rPoint ); + BASEGFX_DLLPUBLIC B2DHomPoint operator*( const B2DHomMatrix& rMat, const B2DHomPoint& rPoint ); - B2DHomPoint operator/(const B2DHomPoint& rVec, double t); + BASEGFX_DLLPUBLIC B2DHomPoint operator/(const B2DHomPoint& rVec, double t); - B2DHomPoint operator/(double t, const B2DHomPoint& rVec); + BASEGFX_DLLPUBLIC B2DHomPoint operator/(double t, const B2DHomPoint& rVec); } // end of namespace basegfx #endif /* _BGFX_POINT_B2DHOMPOINT_HXX */ diff --git a/basegfx/inc/basegfx/point/b2dpoint.hxx b/basegfx/inc/basegfx/point/b2dpoint.hxx index 273a1c54e3ba..dd169a549d7c 100644 --- a/basegfx/inc/basegfx/point/b2dpoint.hxx +++ b/basegfx/inc/basegfx/point/b2dpoint.hxx @@ -30,6 +30,7 @@ #include <basegfx/tuple/b2dtuple.hxx> #include <basegfx/point/b2ipoint.hxx> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// @@ -46,7 +47,7 @@ namespace basegfx @see B2DTuple */ - class B2DPoint : public ::basegfx::B2DTuple + class BASEGFX_DLLPUBLIC B2DPoint : public ::basegfx::B2DTuple { public: /** Create a 2D Point @@ -143,7 +144,7 @@ namespace basegfx Since this is a Point, translational components of the matrix are used. */ - B2DPoint operator*( const B2DHomMatrix& rMat, const B2DPoint& rPoint ); + BASEGFX_DLLPUBLIC B2DPoint operator*( const B2DHomMatrix& rMat, const B2DPoint& rPoint ); } // end of namespace basegfx ////////////////////////////////////////////////////////////////////////////// diff --git a/basegfx/inc/basegfx/point/b2ipoint.hxx b/basegfx/inc/basegfx/point/b2ipoint.hxx index dec51735de7c..accd5938574e 100644 --- a/basegfx/inc/basegfx/point/b2ipoint.hxx +++ b/basegfx/inc/basegfx/point/b2ipoint.hxx @@ -29,6 +29,7 @@ #define _BGFX_POINT_B2IPOINT_HXX #include <basegfx/tuple/b2ituple.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { @@ -43,7 +44,7 @@ namespace basegfx @see B2ITuple */ - class B2IPoint : public ::basegfx::B2ITuple + class BASEGFX_DLLPUBLIC B2IPoint : public ::basegfx::B2ITuple { public: /** Create a 2D Point diff --git a/basegfx/inc/basegfx/point/b3dhompoint.hxx b/basegfx/inc/basegfx/point/b3dhompoint.hxx index 7417d7528d16..64ea6415a0e8 100644 --- a/basegfx/inc/basegfx/point/b3dhompoint.hxx +++ b/basegfx/inc/basegfx/point/b3dhompoint.hxx @@ -29,6 +29,7 @@ #define _BGFX_POINT_B3DHOMPOINT_HXX #include <basegfx/point/b3dpoint.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { @@ -45,7 +46,7 @@ namespace basegfx @see B3DTuple */ - class B3DHomPoint + class BASEGFX_DLLPUBLIC B3DHomPoint { protected: /// This member contains the coordinate part of the point diff --git a/basegfx/inc/basegfx/point/b3dpoint.hxx b/basegfx/inc/basegfx/point/b3dpoint.hxx index 943f74c1352d..3a0724f217de 100644 --- a/basegfx/inc/basegfx/point/b3dpoint.hxx +++ b/basegfx/inc/basegfx/point/b3dpoint.hxx @@ -29,6 +29,7 @@ #define _BGFX_POINT_B3DPOINT_HXX #include <basegfx/tuple/b3dtuple.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { @@ -43,7 +44,7 @@ namespace basegfx @see B3DTuple */ - class B3DPoint : public ::basegfx::B3DTuple + class BASEGFX_DLLPUBLIC B3DPoint : public ::basegfx::B3DTuple { public: /** Create a 3D Point @@ -143,7 +144,7 @@ namespace basegfx Since this is a Point, translational components of the matrix are used. */ - B3DPoint operator*( const B3DHomMatrix& rMat, const B3DPoint& rPoint ); + BASEGFX_DLLPUBLIC B3DPoint operator*( const B3DHomMatrix& rMat, const B3DPoint& rPoint ); } // end of namespace basegfx diff --git a/basegfx/inc/basegfx/point/b3ipoint.hxx b/basegfx/inc/basegfx/point/b3ipoint.hxx index f20fe3d99c79..5c80937ef77f 100644 --- a/basegfx/inc/basegfx/point/b3ipoint.hxx +++ b/basegfx/inc/basegfx/point/b3ipoint.hxx @@ -29,6 +29,7 @@ #define _BGFX_POINT_B3IPOINT_HXX #include <basegfx/tuple/b3ituple.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { @@ -43,7 +44,7 @@ namespace basegfx @see B3ITuple */ - class B3IPoint : public ::basegfx::B3ITuple + class BASEGFX_DLLPUBLIC B3IPoint : public ::basegfx::B3ITuple { public: /** Create a 3D Point diff --git a/basegfx/inc/basegfx/polygon/b2dlinegeometry.hxx b/basegfx/inc/basegfx/polygon/b2dlinegeometry.hxx index fd8997fcda4d..23017a4de210 100644 --- a/basegfx/inc/basegfx/polygon/b2dlinegeometry.hxx +++ b/basegfx/inc/basegfx/polygon/b2dlinegeometry.hxx @@ -32,6 +32,7 @@ #include <basegfx/numeric/ftools.hxx> #include <basegfx/polygon/b2dpolypolygon.hxx> #include <basegfx/polygon/b2dpolygon.hxx> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// @@ -72,7 +73,7 @@ namespace basegfx @return The Line start and end polygon, correctly rotated and scaled */ - B2DPolyPolygon createAreaGeometryForLineStartEnd( + BASEGFX_DLLPUBLIC B2DPolyPolygon createAreaGeometryForLineStartEnd( const B2DPolygon& rCandidate, const B2DPolyPolygon& rArrow, bool bStart, @@ -128,7 +129,7 @@ namespace basegfx it's line width. Contains bezier segments and edge roundings as needed and defined. */ - B2DPolyPolygon createAreaGeometry( + BASEGFX_DLLPUBLIC B2DPolyPolygon createAreaGeometry( const B2DPolygon& rCandidate, double fHalfLineWidth, B2DLineJoin eJoin = B2DLINEJOIN_ROUND, diff --git a/basegfx/inc/basegfx/polygon/b2dpolygon.hxx b/basegfx/inc/basegfx/polygon/b2dpolygon.hxx index a12120b5f441..db807f38e7ff 100644 --- a/basegfx/inc/basegfx/polygon/b2dpolygon.hxx +++ b/basegfx/inc/basegfx/polygon/b2dpolygon.hxx @@ -32,6 +32,7 @@ #include <o3tl/cow_wrapper.hxx> #include <basegfx/vector/b2enums.hxx> #include <basegfx/range/b2drange.hxx> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// // predeclarations @@ -50,7 +51,7 @@ namespace basegfx namespace basegfx { - class B2DPolygon + class BASEGFX_DLLPUBLIC B2DPolygon { public: typedef o3tl::cow_wrapper< ImplB2DPolygon > ImplType; diff --git a/basegfx/inc/basegfx/polygon/b2dpolygonclipper.hxx b/basegfx/inc/basegfx/polygon/b2dpolygonclipper.hxx index d13d3d0a862c..83fa106dac72 100644 --- a/basegfx/inc/basegfx/polygon/b2dpolygonclipper.hxx +++ b/basegfx/inc/basegfx/polygon/b2dpolygonclipper.hxx @@ -30,6 +30,7 @@ #include <basegfx/polygon/b2dpolypolygon.hxx> #include <basegfx/polygon/b2dpolygon.hxx> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// @@ -46,21 +47,21 @@ namespace basegfx // a clip axis parallel to X.Axis and 100 above it, use bParallelToXAxis = true and fValueOnOtherAxis = 100. // The value bAboveAxis defines on which side the return value will be (true -> above X, right of Y). // The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true). - B2DPolyPolygon clipPolyPolygonOnParallelAxis(const B2DPolyPolygon& rCandidate, bool bParallelToXAxis, bool bAboveAxis, double fValueOnOtherAxis, bool bStroke); - B2DPolyPolygon clipPolygonOnParallelAxis(const B2DPolygon& rCandidate, bool bParallelToXAxis, bool bAboveAxis, double fValueOnOtherAxis, bool bStroke); + BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolyPolygonOnParallelAxis(const B2DPolyPolygon& rCandidate, bool bParallelToXAxis, bool bAboveAxis, double fValueOnOtherAxis, bool bStroke); + BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolygonOnParallelAxis(const B2DPolygon& rCandidate, bool bParallelToXAxis, bool bAboveAxis, double fValueOnOtherAxis, bool bStroke); // Clip the given PolyPolygon against the given range. bInside defines if the result will contain the // parts which are contained in the range or vice versa. // The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true). - B2DPolyPolygon clipPolyPolygonOnRange(const B2DPolyPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke); - B2DPolyPolygon clipPolygonOnRange(const B2DPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke); + BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolyPolygonOnRange(const B2DPolyPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke); + BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolygonOnRange(const B2DPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke); // Clip given PolyPolygon against the endless edge (ray) defined by the given two points. bAbove defines on which side // of the edge the result will be together with the definition of the edge. If the edge is seen as a vector // from A to B and bAbove is true, the result will contain the geometry left of the vector. // The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true). - B2DPolyPolygon clipPolyPolygonOnEdge(const B2DPolyPolygon& rCandidate, const B2DPoint& rPointA, const B2DPoint& rPointB, bool bAbove, bool bStroke); - B2DPolyPolygon clipPolygonOnEdge(const B2DPolygon& rCandidate, const B2DPoint& rPointA, const B2DPoint& rPointB, bool bAbove, bool bStroke); + BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolyPolygonOnEdge(const B2DPolyPolygon& rCandidate, const B2DPoint& rPointA, const B2DPoint& rPointB, bool bAbove, bool bStroke); + BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolygonOnEdge(const B2DPolygon& rCandidate, const B2DPoint& rPointA, const B2DPoint& rPointB, bool bAbove, bool bStroke); // Clip given PolyPolygon against given clipping polygon. // The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true). @@ -68,13 +69,13 @@ namespace basegfx // With filled polygons, You get all PolyPolygon parts which were inside rClip. // The switch bInside decides if the parts inside the clip polygon or outside shall be created. // The clip polygon is always assumed closed, even when it's isClosed() is false. - B2DPolyPolygon clipPolyPolygonOnPolyPolygon(const B2DPolyPolygon& rCandidate, const B2DPolyPolygon& rClip, bool bInside, bool bStroke); - B2DPolyPolygon clipPolygonOnPolyPolygon(const B2DPolygon& rCandidate, const B2DPolyPolygon& rClip, bool bInside, bool bStroke); + BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolyPolygonOnPolyPolygon(const B2DPolyPolygon& rCandidate, const B2DPolyPolygon& rClip, bool bInside, bool bStroke); + BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolygonOnPolyPolygon(const B2DPolygon& rCandidate, const B2DPolyPolygon& rClip, bool bInside, bool bStroke); // clip the given polygon against the given range. the resulting polygon will always contain // the inside parts which will always be interpreted as areas. the incoming polygon is expected // to be a simple triangle list. the result is also a simple triangle list. - B2DPolygon clipTriangleListOnRange( const B2DPolygon& rCandidate, const B2DRange& rRange ); + BASEGFX_DLLPUBLIC B2DPolygon clipTriangleListOnRange( const B2DPolygon& rCandidate, const B2DRange& rRange ); } // end of namespace tools } // end of namespace basegfx diff --git a/basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx b/basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx index a9d6e0a1b6fe..5f47b3c9f8c3 100644 --- a/basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx +++ b/basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx @@ -30,6 +30,7 @@ #include <basegfx/polygon/b2dpolygon.hxx> #include <basegfx/polygon/b2dpolypolygon.hxx> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// @@ -39,39 +40,39 @@ namespace basegfx { // look for self-intersections and self-touches (points on an edge) in given polygon and add // extra points there. Result will have no touches or intersections on an edge, only on points - B2DPolygon addPointsAtCutsAndTouches(const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolygon addPointsAtCutsAndTouches(const B2DPolygon& rCandidate); // look for polypolygon-intersections and polypolygon-touches (point of poly A on an edge of poly B) in given PolyPolygon and add // extra points there. Result will have no touches or intersections between contained polygons on an edge, only on points. For // convenience, the correction for self-intersections for each member polygon will be used, too. // Changed: Self intersections are searched by default, but may be switched off by 2nd parameter. - B2DPolyPolygon addPointsAtCutsAndTouches(const B2DPolyPolygon& rCandidate, bool bSelfIntersections = true); + BASEGFX_DLLPUBLIC B2DPolyPolygon addPointsAtCutsAndTouches(const B2DPolyPolygon& rCandidate, bool bSelfIntersections = true); // look for intersections of rCandidate with all polygons from rMask and add extra points there. Do // not change or add points to rMask. - B2DPolygon addPointsAtCutsAndTouches(const B2DPolyPolygon& rMask, const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolygon addPointsAtCutsAndTouches(const B2DPolyPolygon& rMask, const B2DPolygon& rCandidate); // look for intersections of rCandidate with all polygons from rMask and add extra points there. Do // not change or add points to rMask. - B2DPolyPolygon addPointsAtCutsAndTouches(const B2DPolyPolygon& rMask, const B2DPolyPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolyPolygon addPointsAtCutsAndTouches(const B2DPolyPolygon& rMask, const B2DPolyPolygon& rCandidate); // look for intersections of rCandidate with the edge from rStart to rEnd and add extra points there. // Points are only added in the range of the edge, not on the endless vector. - B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate, const B2DPoint& rStart, const B2DPoint& rEnd); - B2DPolyPolygon addPointsAtCuts(const B2DPolyPolygon& rCandidate, const B2DPoint& rStart, const B2DPoint& rEnd); + BASEGFX_DLLPUBLIC B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate, const B2DPoint& rStart, const B2DPoint& rEnd); + BASEGFX_DLLPUBLIC B2DPolyPolygon addPointsAtCuts(const B2DPolyPolygon& rCandidate, const B2DPoint& rStart, const B2DPoint& rEnd); // look for intersections of rCandidate with the mask Polygon and add extra points there. // The mask polygon is assumed to be closed, even when it's not explicitely. - B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate, const B2DPolyPolygon& rMask); - B2DPolyPolygon addPointsAtCuts(const B2DPolyPolygon& rCandidate, const B2DPolyPolygon& rMask); + BASEGFX_DLLPUBLIC B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate, const B2DPolyPolygon& rMask); + BASEGFX_DLLPUBLIC B2DPolyPolygon addPointsAtCuts(const B2DPolyPolygon& rCandidate, const B2DPolyPolygon& rMask); // look for self-intersections in given polygon and add extra points there. Result will have no // intersections on an edge - B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate); // add points at all self-intersections of single polygons (depends on bSelfIntersections) // and at polygon-polygon intersections - B2DPolyPolygon addPointsAtCuts(const B2DPolyPolygon& rCandidate, bool bSelfIntersections = true); + BASEGFX_DLLPUBLIC B2DPolyPolygon addPointsAtCuts(const B2DPolyPolygon& rCandidate, bool bSelfIntersections = true); } // end of namespace tools } // end of namespace basegfx diff --git a/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx b/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx index 7d1d0bc9660c..977b498a9e1f 100644 --- a/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx +++ b/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx @@ -34,6 +34,7 @@ #include <basegfx/polygon/b2dpolypolygon.hxx> #include <basegfx/polygon/b3dpolygon.hxx> #include <vector> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// @@ -48,8 +49,8 @@ namespace basegfx // B2DPolygon tools // open/close with point add/remove and control point corrections - void openWithGeometryChange(B2DPolygon& rCandidate); - void closeWithGeometryChange(B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC void openWithGeometryChange(B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC void closeWithGeometryChange(B2DPolygon& rCandidate); /** Check if given polygon is closed. @@ -60,20 +61,20 @@ namespace basegfx start/end points) and sets the Closed()-state of the polygon correctly. */ - void checkClosed(B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC void checkClosed(B2DPolygon& rCandidate); // Get successor and predecessor indices. Returning the same index means there // is none. Same for successor. - sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const B2DPolygon& rCandidate); - sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const B2DPolygon& rCandidate); // Get orientation of Polygon - B2VectorOrientation getOrientation(const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2VectorOrientation getOrientation(const B2DPolygon& rCandidate); // isInside tests for B2dPoint and other B2dPolygon. On border is not inside as long as // not true is given in bWithBorder flag. - bool isInside(const B2DPolygon& rCandidate, const B2DPoint& rPoint, bool bWithBorder = false); - bool isInside(const B2DPolygon& rCandidate, const B2DPolygon& rPolygon, bool bWithBorder = false); + BASEGFX_DLLPUBLIC bool isInside(const B2DPolygon& rCandidate, const B2DPoint& rPoint, bool bWithBorder = false); + BASEGFX_DLLPUBLIC bool isInside(const B2DPolygon& rCandidate, const B2DPolygon& rPolygon, bool bWithBorder = false); /** Get the range of a polygon including bezier control points @@ -85,7 +86,7 @@ namespace basegfx @return The outer range of the bezier curve containing bezier control points */ - B2DRange getRangeWithControlPoints(const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DRange getRangeWithControlPoints(const B2DPolygon& rCandidate); /** Get the range of a polygon @@ -98,53 +99,53 @@ namespace basegfx @return The outer range of the bezier curve */ - B2DRange getRange(const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DRange getRange(const B2DPolygon& rCandidate); // get signed area of polygon - double getSignedArea(const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC double getSignedArea(const B2DPolygon& rCandidate); // get area of polygon - double getArea(const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC double getArea(const B2DPolygon& rCandidate); /** get length of polygon edge from point nIndex to nIndex + 1 */ - double getEdgeLength(const B2DPolygon& rCandidate, sal_uInt32 nIndex); + BASEGFX_DLLPUBLIC double getEdgeLength(const B2DPolygon& rCandidate, sal_uInt32 nIndex); /** get length of polygon */ - double getLength(const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC double getLength(const B2DPolygon& rCandidate); // get position on polygon for absolute given distance. If // length is given, it is assumed the correct polygon length, if 0.0 it is calculated // using getLength(...) - B2DPoint getPositionAbsolute(const B2DPolygon& rCandidate, double fDistance, double fLength = 0.0); + BASEGFX_DLLPUBLIC B2DPoint getPositionAbsolute(const B2DPolygon& rCandidate, double fDistance, double fLength = 0.0); // get position on polygon for relative given distance in range [0.0 .. 1.0]. If // length is given, it is assumed the correct polygon length, if 0.0 it is calculated // using getLength(...) - B2DPoint getPositionRelative(const B2DPolygon& rCandidate, double fDistance, double fLength = 0.0); + BASEGFX_DLLPUBLIC B2DPoint getPositionRelative(const B2DPolygon& rCandidate, double fDistance, double fLength = 0.0); // get a snippet from given polygon for absolute distances. The polygon is assumed // to be opened (not closed). fFrom and fTo need to be in range [0.0 .. fLength], where // fTo >= fFrom. If length is given, it is assumed the correct polygon length, // if 0.0 it is calculated using getLength(...) - B2DPolygon getSnippetAbsolute(const B2DPolygon& rCandidate, double fFrom, double fTo, double fLength = 0.0); + BASEGFX_DLLPUBLIC B2DPolygon getSnippetAbsolute(const B2DPolygon& rCandidate, double fFrom, double fTo, double fLength = 0.0); // get a snippet from given polygon for relative distances. The polygon is assumed // to be opened (not closed). fFrom and fTo need to be in range [0.0 .. 1.0], where // fTo >= fFrom. If length is given, it is assumed the correct polygon length, // if 0.0 it is calculated using getLength(...) - B2DPolygon getSnippetRelative(const B2DPolygon& rCandidate, double fFrom = 0.0, double fTo = 1.0, double fLength = 0.0); + BASEGFX_DLLPUBLIC B2DPolygon getSnippetRelative(const B2DPolygon& rCandidate, double fFrom = 0.0, double fTo = 1.0, double fLength = 0.0); // Continuity check for point with given index - B2VectorContinuity getContinuityInPoint(const B2DPolygon& rCandidate, sal_uInt32 nIndex); + BASEGFX_DLLPUBLIC B2VectorContinuity getContinuityInPoint(const B2DPolygon& rCandidate, sal_uInt32 nIndex); // Subdivide all contained curves. Use distanceBound value if given. - B2DPolygon adaptiveSubdivideByDistance(const B2DPolygon& rCandidate, double fDistanceBound = 0.0); + BASEGFX_DLLPUBLIC B2DPolygon adaptiveSubdivideByDistance(const B2DPolygon& rCandidate, double fDistanceBound = 0.0); // Subdivide all contained curves. Use angleBound value if given. - B2DPolygon adaptiveSubdivideByAngle(const B2DPolygon& rCandidate, double fAngleBound = 0.0); + BASEGFX_DLLPUBLIC B2DPolygon adaptiveSubdivideByAngle(const B2DPolygon& rCandidate, double fAngleBound = 0.0); // #i37443# Subdivide all contained curves. - B2DPolygon adaptiveSubdivideByCount(const B2DPolygon& rCandidate, sal_uInt32 nCount = 0L); + BASEGFX_DLLPUBLIC B2DPolygon adaptiveSubdivideByCount(const B2DPolygon& rCandidate, sal_uInt32 nCount = 0L); // Definitions for the cut flags used from the findCut methods typedef sal_uInt16 CutFlagValue; @@ -161,7 +162,7 @@ namespace basegfx // Calculate cut between the points given by the two indices. pCut1 // and pCut2 will contain the cut coordinate on each edge in ]0.0, 1.0] // (if given) and the return value will contain a cut description. - CutFlagValue findCut( + BASEGFX_DLLPUBLIC CutFlagValue findCut( const B2DPolygon& rCandidate, sal_uInt32 nIndex1, sal_uInt32 nIndex2, CutFlagValue aCutFlags = CUTFLAG_DEFAULT, @@ -169,7 +170,7 @@ namespace basegfx // This version is working with two indexed edges from different // polygons. - CutFlagValue findCut( + BASEGFX_DLLPUBLIC CutFlagValue findCut( const B2DPolygon& rCandidate1, sal_uInt32 nIndex1, const B2DPolygon& rCandidate2, sal_uInt32 nIndex2, CutFlagValue aCutFlags = CUTFLAG_DEFAULT, @@ -177,7 +178,7 @@ namespace basegfx // This version works with two points and vectors to define the // edges for the cut test. - CutFlagValue findCut( + BASEGFX_DLLPUBLIC CutFlagValue findCut( const B2DPoint& rEdge1Start, const B2DVector& rEdge1Delta, const B2DPoint& rEdge2Start, const B2DVector& rEdge2Delta, CutFlagValue aCutFlags = CUTFLAG_DEFAULT, @@ -186,7 +187,7 @@ namespace basegfx // test if point is on the given edge in range ]0.0..1.0[ without // the start/end points. If so, return true and put the parameter // value in pCut (if provided) - bool isPointOnEdge( + BASEGFX_DLLPUBLIC bool isPointOnEdge( const B2DPoint& rPoint, const B2DPoint& rEdgeStart, const B2DVector& rEdgeDelta, @@ -225,7 +226,7 @@ namespace basegfx The sumed-up length of the rDotDashArray. If zero, it will be calculated internally. */ - void applyLineDashing( + BASEGFX_DLLPUBLIC void applyLineDashing( const B2DPolygon& rCandidate, const ::std::vector<double>& rDotDashArray, B2DPolyPolygon* pLineTarget, @@ -236,13 +237,13 @@ namespace basegfx // by the two given points. Can be used for HitTesting. The epsilon-range // is defined to be the rectangle centered to the given edge, using height // 2 x fDistance, and the circle around both points with radius fDistance. - bool isInEpsilonRange(const B2DPoint& rEdgeStart, const B2DPoint& rEdgeEnd, const B2DPoint& rTestPosition, double fDistance); + BASEGFX_DLLPUBLIC bool isInEpsilonRange(const B2DPoint& rEdgeStart, const B2DPoint& rEdgeEnd, const B2DPoint& rTestPosition, double fDistance); // test if point is inside epsilon-range around the given Polygon. Can be used // for HitTesting. The epsilon-range is defined to be the rectangle centered // to the given edge, using height 2 x fDistance, and the circle around both points // with radius fDistance. - bool isInEpsilonRange(const B2DPolygon& rCandidate, const B2DPoint& rTestPosition, double fDistance); + BASEGFX_DLLPUBLIC bool isInEpsilonRange(const B2DPolygon& rCandidate, const B2DPoint& rTestPosition, double fDistance); /** Create a polygon from a rectangle. @@ -253,7 +254,7 @@ namespace basegfx Radius of the edge rounding, relative to the rectangle size. 0.0 means no rounding, 1.0 will lead to an ellipse */ - B2DPolygon createPolygonFromRect( const B2DRectangle& rRect, double fRadius ); + BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromRect( const B2DRectangle& rRect, double fRadius ); /** Create a polygon from a rectangle. @@ -265,15 +266,15 @@ namespace basegfx Radius of the edge rounding, relative to the rectangle size. 0.0 means no rounding, 1.0 will lead to an ellipse */ - B2DPolygon createPolygonFromRect( const B2DRectangle& rRect, double fRadiusX, double fRadiusY ); + BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromRect( const B2DRectangle& rRect, double fRadiusX, double fRadiusY ); /** Create a polygon from a rectangle. */ - B2DPolygon createPolygonFromRect( const B2DRectangle& rRect ); + BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromRect( const B2DRectangle& rRect ); /** Create the unit polygon */ - B2DPolygon createUnitPolygon(); + BASEGFX_DLLPUBLIC B2DPolygon createUnitPolygon(); /** Create a circle polygon with given radius. @@ -287,7 +288,7 @@ namespace basegfx @param fRadius Radius of the circle */ - B2DPolygon createPolygonFromCircle( const B2DPoint& rCenter, double fRadius ); + BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromCircle( const B2DPoint& rCenter, double fRadius ); /** create a polygon which describes the unit circle and close it @@ -299,7 +300,7 @@ namespace basegfx this is the lowest one). This is needed since when lines are dashed, toe old geometry started at bottom point, else it would look different. */ - B2DPolygon createPolygonFromUnitCircle(sal_uInt32 nStartQuadrant = 0); + BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromUnitCircle(sal_uInt32 nStartQuadrant = 0); /** Create an ellipse polygon with given radii. @@ -316,13 +317,13 @@ namespace basegfx @param fRadiusY Radius of the ellipse in Y direction */ - B2DPolygon createPolygonFromEllipse( const B2DPoint& rCenter, double fRadiusX, double fRadiusY ); + BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromEllipse( const B2DPoint& rCenter, double fRadiusX, double fRadiusY ); /** Create an unit ellipse polygon with the given angles, from start to end */ - B2DPolygon createPolygonFromEllipseSegment( const B2DPoint& rCenter, double fRadiusX, double fRadiusY, double fStart, double fEnd ); + BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromEllipseSegment( const B2DPoint& rCenter, double fRadiusX, double fRadiusY, double fStart, double fEnd ); - B2DPolygon createPolygonFromUnitEllipseSegment( double fStart, double fEnd ); + BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromUnitEllipseSegment( double fStart, double fEnd ); /** Predicate whether a given polygon is a rectangle. @@ -334,111 +335,111 @@ namespace basegfx enumerations of a rectangle's vertices). Note that intermediate points and duplicate points are ignored. */ - bool isRectangle( const B2DPolygon& rPoly ); + BASEGFX_DLLPUBLIC bool isRectangle( const B2DPolygon& rPoly ); // create 3d polygon from given 2d polygon. The given fZCoordinate is used to expand the // third coordinate. - B3DPolygon createB3DPolygonFromB2DPolygon(const B2DPolygon& rCandidate, double fZCoordinate = 0.0); + BASEGFX_DLLPUBLIC B3DPolygon createB3DPolygonFromB2DPolygon(const B2DPolygon& rCandidate, double fZCoordinate = 0.0); // create 2d PolyPolygon from given 3d PolyPolygon. All coordinates are transformed using the given // matrix and the resulting x,y is used to form the new polygon. - B2DPolygon createB2DPolygonFromB3DPolygon(const B3DPolygon& rCandidate, const B3DHomMatrix& rMat); + BASEGFX_DLLPUBLIC B2DPolygon createB2DPolygonFromB3DPolygon(const B3DPolygon& rCandidate, const B3DHomMatrix& rMat); // create simplified version of the original polygon by // replacing segments with spikes/loops and self intersections // by several trivial sub-segments - B2DPolygon createSimplifiedPolygon(const B2DPolygon&); + BASEGFX_DLLPUBLIC B2DPolygon createSimplifiedPolygon(const B2DPolygon&); // calculate the distance to the given endless ray and return. The relative position on the edge is returned in Cut. // That position may be less than 0.0 or more than 1.0 - double getDistancePointToEndlessRay(const B2DPoint& rPointA, const B2DPoint& rPointB, const B2DPoint& rTestPoint, double& rCut); + BASEGFX_DLLPUBLIC double getDistancePointToEndlessRay(const B2DPoint& rPointA, const B2DPoint& rPointB, const B2DPoint& rTestPoint, double& rCut); // calculate the smallest distance to given edge and return. The relative position on the edge is returned in Cut. // That position is in the range [0.0 .. 1.0] and the returned distance is adapted accordingly to the start or end // point of the edge - double getSmallestDistancePointToEdge(const B2DPoint& rPointA, const B2DPoint& rPointB, const B2DPoint& rTestPoint, double& rCut); + BASEGFX_DLLPUBLIC double getSmallestDistancePointToEdge(const B2DPoint& rPointA, const B2DPoint& rPointB, const B2DPoint& rTestPoint, double& rCut); // for each contained edge calculate the smallest distance. Return the index to the smallest // edge in rEdgeIndex. The relative position on the edge is returned in rCut. // If nothing was found (e.g. empty input plygon), DBL_MAX is returned. - double getSmallestDistancePointToPolygon(const B2DPolygon& rCandidate, const B2DPoint& rTestPoint, sal_uInt32& rEdgeIndex, double& rCut); + BASEGFX_DLLPUBLIC double getSmallestDistancePointToPolygon(const B2DPolygon& rCandidate, const B2DPoint& rTestPoint, sal_uInt32& rEdgeIndex, double& rCut); // distort single point. rOriginal describes the original range, where the given points describe the distorted corresponding points. - B2DPoint distort(const B2DPoint& rCandidate, const B2DRange& rOriginal, const B2DPoint& rTopLeft, const B2DPoint& rTopRight, const B2DPoint& rBottomLeft, const B2DPoint& rBottomRight); + BASEGFX_DLLPUBLIC B2DPoint distort(const B2DPoint& rCandidate, const B2DRange& rOriginal, const B2DPoint& rTopLeft, const B2DPoint& rTopRight, const B2DPoint& rBottomLeft, const B2DPoint& rBottomRight); // distort polygon. rOriginal describes the original range, where the given points describe the distorted corresponding points. - B2DPolygon distort(const B2DPolygon& rCandidate, const B2DRange& rOriginal, const B2DPoint& rTopLeft, const B2DPoint& rTopRight, const B2DPoint& rBottomLeft, const B2DPoint& rBottomRight); + BASEGFX_DLLPUBLIC B2DPolygon distort(const B2DPolygon& rCandidate, const B2DRange& rOriginal, const B2DPoint& rTopLeft, const B2DPoint& rTopRight, const B2DPoint& rBottomLeft, const B2DPoint& rBottomRight); // rotate polygon around given point with given angle. - B2DPolygon rotateAroundPoint(const B2DPolygon& rCandidate, const B2DPoint& rCenter, double fAngle); + BASEGFX_DLLPUBLIC B2DPolygon rotateAroundPoint(const B2DPolygon& rCandidate, const B2DPoint& rCenter, double fAngle); // expand all segments (which are not yet) to curve segments. This is done with setting the control // vectors on the 1/3 resp. 2/3 distances on each segment. - B2DPolygon expandToCurve(const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolygon expandToCurve(const B2DPolygon& rCandidate); // expand given segment to curve segment. This is done with setting the control // vectors on the 1/3 resp. 2/3 distances. The return value describes if a change took place. - bool expandToCurveInPoint(B2DPolygon& rCandidate, sal_uInt32 nIndex); + BASEGFX_DLLPUBLIC bool expandToCurveInPoint(B2DPolygon& rCandidate, sal_uInt32 nIndex); // set continuity for the whole curve. If not a curve, nothing will change. Non-curve points are not changed, too. B2DPolygon setContinuity(const B2DPolygon& rCandidate, B2VectorContinuity eContinuity); // set continuity for given index. If not a curve, nothing will change. Non-curve points are not changed, too. // The return value describes if a change took place. - bool setContinuityInPoint(B2DPolygon& rCandidate, sal_uInt32 nIndex, B2VectorContinuity eContinuity); + BASEGFX_DLLPUBLIC bool setContinuityInPoint(B2DPolygon& rCandidate, sal_uInt32 nIndex, B2VectorContinuity eContinuity); // test if polygon contains neutral points. A neutral point is one whos orientation is neutral // e.g. positioned on the edge of it's predecessor and successor - bool hasNeutralPoints(const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC bool hasNeutralPoints(const B2DPolygon& rCandidate); // remove neutral points. A neutral point is one whos orientation is neutral // e.g. positioned on the edge of it's predecessor and successor - B2DPolygon removeNeutralPoints(const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolygon removeNeutralPoints(const B2DPolygon& rCandidate); // tests if polygon is convex - bool isConvex(const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC bool isConvex(const B2DPolygon& rCandidate); // calculates the orientation at edge nIndex - B2VectorOrientation getOrientationForIndex(const B2DPolygon& rCandidate, sal_uInt32 nIndex); + BASEGFX_DLLPUBLIC B2VectorOrientation getOrientationForIndex(const B2DPolygon& rCandidate, sal_uInt32 nIndex); // calculates if given point is on given line, taking care of the numerical epsilon - bool isPointOnLine(const B2DPoint& rStart, const B2DPoint& rEnd, const B2DPoint& rCandidate, bool bWithPoints = false); + BASEGFX_DLLPUBLIC bool isPointOnLine(const B2DPoint& rStart, const B2DPoint& rEnd, const B2DPoint& rCandidate, bool bWithPoints = false); // calculates if given point is on given polygon, taking care of the numerical epsilon. Uses // isPointOnLine internally - bool isPointOnPolygon(const B2DPolygon& rCandidate, const B2DPoint& rPoint, bool bWithPoints = true); + BASEGFX_DLLPUBLIC bool isPointOnPolygon(const B2DPolygon& rCandidate, const B2DPoint& rPoint, bool bWithPoints = true); // test if candidate is inside triangle - bool isPointInTriangle(const B2DPoint& rA, const B2DPoint& rB, const B2DPoint& rC, const B2DPoint& rCandidate, bool bWithBorder = false); + BASEGFX_DLLPUBLIC bool isPointInTriangle(const B2DPoint& rA, const B2DPoint& rB, const B2DPoint& rC, const B2DPoint& rCandidate, bool bWithBorder = false); // test if candidateA and candidateB are on the same side of the given line - bool arePointsOnSameSideOfLine(const B2DPoint& rStart, const B2DPoint& rEnd, const B2DPoint& rCandidateA, const B2DPoint& rCandidateB, bool bWithLine = false); + BASEGFX_DLLPUBLIC bool arePointsOnSameSideOfLine(const B2DPoint& rStart, const B2DPoint& rEnd, const B2DPoint& rCandidateA, const B2DPoint& rCandidateB, bool bWithLine = false); // add triangles for given rCandidate to rTarget. For each triangle, 3 points will be added to rCandidate. // All triangles will go from the start point of rCandidate to two consecutive points, building (rCandidate.count() - 2) // triangles. - void addTriangleFan(const B2DPolygon& rCandidate, B2DPolygon& rTarget); + BASEGFX_DLLPUBLIC void addTriangleFan(const B2DPolygon& rCandidate, B2DPolygon& rTarget); // grow for polygon. Move all geometry in each point in the direction of the normal in that point // with the given amount. Value may be negative. - B2DPolygon growInNormalDirection(const B2DPolygon& rCandidate, double fValue); + BASEGFX_DLLPUBLIC B2DPolygon growInNormalDirection(const B2DPolygon& rCandidate, double fValue); // force all sub-polygons to a point count of nSegments - B2DPolygon reSegmentPolygon(const B2DPolygon& rCandidate, sal_uInt32 nSegments); + BASEGFX_DLLPUBLIC B2DPolygon reSegmentPolygon(const B2DPolygon& rCandidate, sal_uInt32 nSegments); // create polygon state at t from 0.0 to 1.0 between the two polygons. Both polygons must have the same // organisation, e.g. same amount of points - B2DPolygon interpolate(const B2DPolygon& rOld1, const B2DPolygon& rOld2, double t); + BASEGFX_DLLPUBLIC B2DPolygon interpolate(const B2DPolygon& rOld1, const B2DPolygon& rOld2, double t); - bool isPolyPolygonEqualRectangle( const B2DPolyPolygon& rPolyPoly, const B2DRange& rRect ); + BASEGFX_DLLPUBLIC bool isPolyPolygonEqualRectangle( const B2DPolyPolygon& rPolyPoly, const B2DRange& rRect ); // #i76891# Try to remove existing curve segments if they are simply edges - B2DPolygon simplifyCurveSegments(const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolygon simplifyCurveSegments(const B2DPolygon& rCandidate); // makes the given indexed point the new polygon start point. To do that, the points in the // polygon will be rotated. This is only valid for closed polygons, for non-closed ones // an assertion will be triggered - B2DPolygon makeStartPoint(const B2DPolygon& rCandidate, sal_uInt32 nIndexOfNewStatPoint); + BASEGFX_DLLPUBLIC B2DPolygon makeStartPoint(const B2DPolygon& rCandidate, sal_uInt32 nIndexOfNewStatPoint); /** create edges of given length along given B2DPolygon @@ -468,7 +469,7 @@ namespace basegfx @return The newly created polygon */ - B2DPolygon createEdgesOfGivenLength(const B2DPolygon& rCandidate, double fLength, double fStart = 0.0, double fEnd = 0.0); + BASEGFX_DLLPUBLIC B2DPolygon createEdgesOfGivenLength(const B2DPolygon& rCandidate, double fLength, double fStart = 0.0, double fEnd = 0.0); /** Create Waveline along given polygon The implementation is based on createEdgesOfGivenLength and creates a curve @@ -485,7 +486,7 @@ namespace basegfx @param fgWaveHeight The height of the waveline (amplitude) */ - B2DPolygon createWaveline(const B2DPolygon& rCandidate, double fWaveWidth, double fWaveHeight); + BASEGFX_DLLPUBLIC B2DPolygon createWaveline(const B2DPolygon& rCandidate, double fWaveWidth, double fWaveHeight); /** split each edge of a polygon in exactly nSubEdges equidistant edges @@ -507,12 +508,12 @@ namespace basegfx into nSubEdges part curved edges of equidistant length. If not, straight edges will just be copied. */ - B2DPolygon reSegmentPolygonEdges(const B2DPolygon& rCandidate, sal_uInt32 nSubEdges, bool bHandleCurvedEdges, bool bHandleStraightEdges); + BASEGFX_DLLPUBLIC B2DPolygon reSegmentPolygonEdges(const B2DPolygon& rCandidate, sal_uInt32 nSubEdges, bool bHandleCurvedEdges, bool bHandleStraightEdges); ////////////////////////////////////////////////////////////////////// // comparators with tolerance for 2D Polygons - bool equal(const B2DPolygon& rCandidateA, const B2DPolygon& rCandidateB, const double& rfSmallValue); - bool equal(const B2DPolygon& rCandidateA, const B2DPolygon& rCandidateB); + BASEGFX_DLLPUBLIC bool equal(const B2DPolygon& rCandidateA, const B2DPolygon& rCandidateB, const double& rfSmallValue); + BASEGFX_DLLPUBLIC bool equal(const B2DPolygon& rCandidateA, const B2DPolygon& rCandidateB); /** snap some polygon coordinates to discrete coordinates @@ -526,7 +527,7 @@ namespace basegfx @return The modified version of the source polygon */ - B2DPolygon snapPointsOfHorizontalOrVerticalEdges(const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolygon snapPointsOfHorizontalOrVerticalEdges(const B2DPolygon& rCandidate); } // end of namespace tools } // end of namespace basegfx diff --git a/basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx b/basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx index e23d640b8833..191997bc01cb 100644 --- a/basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx +++ b/basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx @@ -30,6 +30,7 @@ #include <basegfx/polygon/b2dpolypolygon.hxx> #include <vector> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// @@ -38,10 +39,10 @@ namespace basegfx namespace triangulator { // triangulate given polygon - ::basegfx::B2DPolygon triangulate(const ::basegfx::B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC ::basegfx::B2DPolygon triangulate(const ::basegfx::B2DPolygon& rCandidate); // triangulate given PolyPolygon - ::basegfx::B2DPolygon triangulate(const ::basegfx::B2DPolyPolygon& rCandidate); + BASEGFX_DLLPUBLIC ::basegfx::B2DPolygon triangulate(const ::basegfx::B2DPolyPolygon& rCandidate); } // end of namespace triangulator } // end of namespace basegfx diff --git a/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx b/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx index 0032cc47ce4e..51837be9d3c7 100644 --- a/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx +++ b/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx @@ -31,6 +31,7 @@ #include <sal/types.h> #include <o3tl/cow_wrapper.hxx> #include <basegfx/range/b2drange.hxx> +#include <basegfx/basegfxdllapi.h> // predeclarations class ImplB2DPolyPolygon; @@ -45,7 +46,7 @@ namespace basegfx namespace basegfx { - class B2DPolyPolygon + class BASEGFX_DLLPUBLIC B2DPolyPolygon { public: typedef o3tl::cow_wrapper< ImplB2DPolyPolygon > ImplType; diff --git a/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx b/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx index 7e648302c5e5..df84e57edf1a 100644 --- a/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx +++ b/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx @@ -29,6 +29,7 @@ #define _BGFX_POLYGON_B2DPOLYPOLYGONCUTTER_HXX #include <basegfx/polygon/b2dpolypolygon.hxx> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// @@ -43,18 +44,18 @@ namespace basegfx // Self crossovers of the contained sub-polygons are implicitely handled, but to not lose // the topological information, it may be necessary to remove self-intersections of the // contained sub-polygons in a preparing step and to explicitely correct their orientations. - B2DPolyPolygon solveCrossovers(const B2DPolyPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolyPolygon solveCrossovers(const B2DPolyPolygon& rCandidate); // Version for single polygons. This is for solving self-intersections. Result will be free of // crossovers. When result contains multiple polygons, it may be necessary to rearrange their // orientations since holes may have been created (use correctOrientations eventually). - B2DPolyPolygon solveCrossovers(const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolyPolygon solveCrossovers(const B2DPolygon& rCandidate); // Neutral polygons will be stripped. Neutral polygons are ones who's orientation is // neutral, so normally they have no volume -> just closed paths. A polygon with the same // positive and negative oriented volume is also neutral, so this may not be wanted. It is // safe to call with crossover-free polygons, though (that's where it's mostly used). - B2DPolyPolygon stripNeutralPolygons(const B2DPolyPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolyPolygon stripNeutralPolygons(const B2DPolyPolygon& rCandidate); // Remove not necessary polygons. Works only correct with crossover-free polygons. For each // polygon, the depth for the PolyPolygon is calculated. The orientation is used to identify holes. @@ -67,7 +68,7 @@ namespace basegfx // one polygon to another and use this mode -> only parts where two polygons overlapped will be kept. // In combination with correct orientation of the input orientations and the SolveCrossover calls this // can be combined for logical polygon operations or polygon clipping. - B2DPolyPolygon stripDispensablePolygons(const B2DPolyPolygon& rCandidate, bool bKeepAboveZero = false); + BASEGFX_DLLPUBLIC B2DPolyPolygon stripDispensablePolygons(const B2DPolyPolygon& rCandidate, bool bKeepAboveZero = false); // For convenience: The four basic operations OR, XOR, AND and DIFF for // two PolyPolygons. These are combinations of the above methods. To not be forced @@ -86,20 +87,20 @@ namespace basegfx // Preparations: solve self-intersections and intersections, remove neutral // parts and correct orientations. - B2DPolyPolygon prepareForPolygonOperation(const B2DPolygon& rCandidate); - B2DPolyPolygon prepareForPolygonOperation(const B2DPolyPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolyPolygon prepareForPolygonOperation(const B2DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolyPolygon prepareForPolygonOperation(const B2DPolyPolygon& rCandidate); // OR: Return all areas where CandidateA or CandidateB exist - B2DPolyPolygon solvePolygonOperationOr(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB); + BASEGFX_DLLPUBLIC B2DPolyPolygon solvePolygonOperationOr(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB); // XOR: Return all areas where CandidateA or CandidateB exist, but not both - B2DPolyPolygon solvePolygonOperationXor(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB); + BASEGFX_DLLPUBLIC B2DPolyPolygon solvePolygonOperationXor(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB); // AND: Return all areas where CandidateA and CandidateB exist - B2DPolyPolygon solvePolygonOperationAnd(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB); + BASEGFX_DLLPUBLIC B2DPolyPolygon solvePolygonOperationAnd(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB); // DIFF: Return all areas where CandidateA is not covered by CandidateB (cut B out of A) - B2DPolyPolygon solvePolygonOperationDiff(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB); + BASEGFX_DLLPUBLIC B2DPolyPolygon solvePolygonOperationDiff(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB); /** merge all single PolyPolygons to a single, OR-ed PolyPolygon @@ -108,7 +109,7 @@ namespace basegfx @return A single PolyPolygon containing the Or-merged result */ - B2DPolyPolygon mergeToSinglePolyPolygon(const std::vector< basegfx::B2DPolyPolygon >& rInput); + BASEGFX_DLLPUBLIC B2DPolyPolygon mergeToSinglePolyPolygon(const std::vector< basegfx::B2DPolyPolygon >& rInput); } // end of namespace tools } // end of namespace basegfx diff --git a/basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx b/basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx index a77f1a371a8a..899d6ab7a32f 100644 --- a/basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx +++ b/basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx @@ -34,6 +34,7 @@ #include <basegfx/polygon/b2dpolypolygonfillrule.hxx> #include <vector> #include <utility> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// @@ -48,7 +49,7 @@ namespace basegfx @derive Overwrite span() with the render output method of your choice. */ - class B2DPolyPolygonRasterConverter + class BASEGFX_DLLPUBLIC B2DPolyPolygonRasterConverter { public: /** Create raster-converter for given poly-polygon diff --git a/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx b/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx index 1115a96ef8da..666b04478a43 100644 --- a/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx +++ b/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx @@ -33,6 +33,7 @@ #include <basegfx/polygon/b2dpolygon.hxx> #include <basegfx/polygon/b3dpolypolygon.hxx> #include <vector> +#include <basegfx/basegfxdllapi.h> namespace rtl { @@ -54,27 +55,27 @@ namespace basegfx // Check and evtl. correct orientations of all contained Polygons so that // the orientations of contained polygons will variate to express areas and // holes - B2DPolyPolygon correctOrientations(const B2DPolyPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolyPolygon correctOrientations(const B2DPolyPolygon& rCandidate); // make sure polygon with index 0L is not a hole. This may evtl. change the // sequence of polygons, but allows to use polygon with index 0L to // get the correct normal for the whole polyPolygon - B2DPolyPolygon correctOutmostPolygon(const B2DPolyPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolyPolygon correctOutmostPolygon(const B2DPolyPolygon& rCandidate); // Subdivide all contained curves. Use distanceBound value if given. - B2DPolyPolygon adaptiveSubdivideByDistance(const B2DPolyPolygon& rCandidate, double fDistanceBound = 0.0); + BASEGFX_DLLPUBLIC B2DPolyPolygon adaptiveSubdivideByDistance(const B2DPolyPolygon& rCandidate, double fDistanceBound = 0.0); // Subdivide all contained curves. Use distanceBound value if given. Else, a convenient one // is created. - B2DPolyPolygon adaptiveSubdivideByAngle(const B2DPolyPolygon& rCandidate, double fAngleBound = 0.0); + BASEGFX_DLLPUBLIC B2DPolyPolygon adaptiveSubdivideByAngle(const B2DPolyPolygon& rCandidate, double fAngleBound = 0.0); // Subdivide all contained curves. Use nCount divisions if given. Else, a convenient one // is created. - B2DPolyPolygon adaptiveSubdivideByCount(const B2DPolyPolygon& rCandidate, sal_uInt32 nCount = 0L); + BASEGFX_DLLPUBLIC B2DPolyPolygon adaptiveSubdivideByCount(const B2DPolyPolygon& rCandidate, sal_uInt32 nCount = 0L); // isInside test for B2dPoint. On border is not inside as long as not true is given // in bWithBorder flag. It is assumed that the orientations of the given polygon are correct. - bool isInside(const B2DPolyPolygon& rCandidate, const B2DPoint& rPoint, bool bWithBorder = false); + BASEGFX_DLLPUBLIC bool isInside(const B2DPolyPolygon& rCandidate, const B2DPoint& rPoint, bool bWithBorder = false); /** get range of PolyPolygon. Control points are included. @@ -87,7 +88,7 @@ namespace basegfx @return The outer range including control points */ - B2DRange getRangeWithControlPoints(const B2DPolyPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DRange getRangeWithControlPoints(const B2DPolyPolygon& rCandidate); /** Get the range of a polyPolygon @@ -100,13 +101,13 @@ namespace basegfx @return The outer range of the polygon */ - B2DRange getRange(const B2DPolyPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DRange getRange(const B2DPolyPolygon& rCandidate); /** Apply given LineDashing to given polyPolygon For a description see applyLineDashing in b2dpolygontoos.hxx */ - void applyLineDashing( + BASEGFX_DLLPUBLIC void applyLineDashing( const B2DPolyPolygon& rCandidate, const ::std::vector<double>& rDotDashArray, B2DPolyPolygon* pLineTarget, @@ -116,7 +117,7 @@ namespace basegfx // test if point is inside epsilon-range around the given PolyPolygon. Can be used // for HitTesting. The epsilon-range is defined to be the tube around the PolyPolygon // with distance fDistance and rounded edges (start and end point). - bool isInEpsilonRange(const B2DPolyPolygon& rCandidate, const B2DPoint& rTestPosition, double fDistance); + BASEGFX_DLLPUBLIC bool isInEpsilonRange(const B2DPolyPolygon& rCandidate, const B2DPoint& rTestPosition, double fDistance); /** Read poly-polygon from SVG. @@ -132,7 +133,7 @@ namespace basegfx @return true, if the string was successfully parsed */ - bool importFromSvgD( B2DPolyPolygon& o_rPolyPoly, + BASEGFX_DLLPUBLIC bool importFromSvgD( B2DPolyPolygon& o_rPolyPoly, const ::rtl::OUString& rSvgDAttribute ); /** Read poly-polygon from SVG. @@ -149,53 +150,53 @@ namespace basegfx @return true, if the string was successfully parsed */ - bool importFromSvgPoints( B2DPolygon& o_rPoly, + BASEGFX_DLLPUBLIC bool importFromSvgPoints( B2DPolygon& o_rPoly, const ::rtl::OUString& rSvgPointsAttribute ); // grow for polyPolygon. Move all geometry in each point in the direction of the normal in that point // with the given amount. Value may be negative. - B2DPolyPolygon growInNormalDirection(const B2DPolyPolygon& rCandidate, double fValue); + BASEGFX_DLLPUBLIC B2DPolyPolygon growInNormalDirection(const B2DPolyPolygon& rCandidate, double fValue); // This method will correct a pair of polyPolygons where the goal is to keep same point count // to allow direct point association and also to remove self-intersections produced by shrinks. // This method will eventually change both polyPolygons to reach that goal because there are cases // where it is necessary to add new cut points to the original - void correctGrowShrinkPolygonPair(B2DPolyPolygon& rOriginal, B2DPolyPolygon& rGrown); + BASEGFX_DLLPUBLIC void correctGrowShrinkPolygonPair(B2DPolyPolygon& rOriginal, B2DPolyPolygon& rGrown); // force all sub-polygons to a point count of nSegments - B2DPolyPolygon reSegmentPolyPolygon(const B2DPolyPolygon& rCandidate, sal_uInt32 nSegments); + BASEGFX_DLLPUBLIC B2DPolyPolygon reSegmentPolyPolygon(const B2DPolyPolygon& rCandidate, sal_uInt32 nSegments); // create polygon state at t from 0.0 to 1.0 between the two polygons. Both polygons must have the same // organisation, e.g. same amount of polygons - B2DPolyPolygon interpolate(const B2DPolyPolygon& rOld1, const B2DPolyPolygon& rOld2, double t); + BASEGFX_DLLPUBLIC B2DPolyPolygon interpolate(const B2DPolyPolygon& rOld1, const B2DPolyPolygon& rOld2, double t); // create 3d PolyPolygon from given 2d PolyPolygon. The given fZCoordinate is used to expand the // third coordinate. - B3DPolyPolygon createB3DPolyPolygonFromB2DPolyPolygon(const B2DPolyPolygon& rCandidate, double fZCoordinate = 0.0); + BASEGFX_DLLPUBLIC B3DPolyPolygon createB3DPolyPolygonFromB2DPolyPolygon(const B2DPolyPolygon& rCandidate, double fZCoordinate = 0.0); // create 2d PolyPolygon from given 3d PolyPolygon. All coordinates are transformed using the given // matrix and the resulting x,y is used to form the new polygon. - B2DPolyPolygon createB2DPolyPolygonFromB3DPolyPolygon(const B3DPolyPolygon& rCandidate, const B3DHomMatrix& rMat); + BASEGFX_DLLPUBLIC B2DPolyPolygon createB2DPolyPolygonFromB3DPolyPolygon(const B3DPolyPolygon& rCandidate, const B3DHomMatrix& rMat); // for each contained edge in each contained polygon calculate the smallest distance. Return the index to the smallest // edge in rEdgeIndex and the index to the polygon in rPolygonIndex. The relative position on the edge is returned in rCut. // If nothing was found (e.g. empty input plygon), DBL_MAX is returned. - double getSmallestDistancePointToPolyPolygon(const B2DPolyPolygon& rCandidate, const B2DPoint& rTestPoint, sal_uInt32& rPolygonIndex, sal_uInt32& rEdgeIndex, double& rCut); + BASEGFX_DLLPUBLIC double getSmallestDistancePointToPolyPolygon(const B2DPolyPolygon& rCandidate, const B2DPoint& rTestPoint, sal_uInt32& rPolygonIndex, sal_uInt32& rEdgeIndex, double& rCut); // distort PolyPolygon. rOriginal describes the original range, where the given points describe the distorted // corresponding points. - B2DPolyPolygon distort(const B2DPolyPolygon& rCandidate, const B2DRange& rOriginal, const B2DPoint& rTopLeft, const B2DPoint& rTopRight, const B2DPoint& rBottomLeft, const B2DPoint& rBottomRight); + BASEGFX_DLLPUBLIC B2DPolyPolygon distort(const B2DPolyPolygon& rCandidate, const B2DRange& rOriginal, const B2DPoint& rTopLeft, const B2DPoint& rTopRight, const B2DPoint& rBottomLeft, const B2DPoint& rBottomRight); // rotate PolyPolygon around given point with given angle. - B2DPolyPolygon rotateAroundPoint(const B2DPolyPolygon& rCandidate, const B2DPoint& rCenter, double fAngle); + BASEGFX_DLLPUBLIC B2DPolyPolygon rotateAroundPoint(const B2DPolyPolygon& rCandidate, const B2DPoint& rCenter, double fAngle); // expand all segments (which are not yet) to curve segments. This is done with setting the control // vectors on the 1/3 resp. 2/3 distances on each segment. - B2DPolyPolygon expandToCurve(const B2DPolyPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolyPolygon expandToCurve(const B2DPolyPolygon& rCandidate); // set continuity for the whole curve. If not a curve, nothing will change. Non-curve points are not changed, too. - B2DPolyPolygon setContinuity(const B2DPolyPolygon& rCandidate, B2VectorContinuity eContinuity); + BASEGFX_DLLPUBLIC B2DPolyPolygon setContinuity(const B2DPolyPolygon& rCandidate, B2VectorContinuity eContinuity); /** Predicate whether a given poly-polygon is a rectangle. @@ -208,7 +209,7 @@ namespace basegfx vertices). Note that intermediate points and duplicate points are ignored. */ - bool isRectangle( const B2DPolyPolygon& rPoly ); + BASEGFX_DLLPUBLIC bool isRectangle( const B2DPolyPolygon& rPoly ); /** Export poly-polygon to SVG. @@ -233,12 +234,12 @@ namespace basegfx @return the generated SVG-D statement (the XML d attribute value alone, without any "<path ...>" or "d="...") */ - ::rtl::OUString exportToSvgD( const B2DPolyPolygon& rPolyPoly, + BASEGFX_DLLPUBLIC ::rtl::OUString exportToSvgD( const B2DPolyPolygon& rPolyPoly, bool bUseRelativeCoordinates=true, bool bDetectQuadraticBeziers=true ); // #i76891# Try to remove existing curve segments if they are simply edges - B2DPolyPolygon simplifyCurveSegments(const B2DPolyPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolyPolygon simplifyCurveSegments(const B2DPolyPolygon& rCandidate); /** split each edge of a polyPolygon in exactly nSubEdges equidistant edges @@ -252,12 +253,12 @@ namespace basegfx @param bHandleStraightEdges Please take a look at reSegmentPolygonEdges description, these are the same. */ - B2DPolyPolygon reSegmentPolyPolygonEdges(const B2DPolyPolygon& rCandidate, sal_uInt32 nSubEdges, bool bHandleCurvedEdges, bool bHandleStraightEdges); + BASEGFX_DLLPUBLIC B2DPolyPolygon reSegmentPolyPolygonEdges(const B2DPolyPolygon& rCandidate, sal_uInt32 nSubEdges, bool bHandleCurvedEdges, bool bHandleStraightEdges); ////////////////////////////////////////////////////////////////////// // comparators with tolerance for 2D PolyPolygons - bool equal(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB, const double& rfSmallValue); - bool equal(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB); + BASEGFX_DLLPUBLIC bool equal(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB, const double& rfSmallValue); + BASEGFX_DLLPUBLIC bool equal(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB); /** snap some polygon coordinates to discrete coordinates @@ -271,7 +272,7 @@ namespace basegfx @return The modified version of the source polygon */ - B2DPolyPolygon snapPointsOfHorizontalOrVerticalEdges(const B2DPolyPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2DPolyPolygon snapPointsOfHorizontalOrVerticalEdges(const B2DPolyPolygon& rCandidate); } // end of namespace tools } // end of namespace basegfx diff --git a/basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx b/basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx index 70ffdf2b7339..c3954f3024aa 100644 --- a/basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx +++ b/basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx @@ -34,13 +34,14 @@ #include <basegfx/polygon/b2dpolygon.hxx> #include <basegfx/polygon/b2dpolypolygon.hxx> #include <vector> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// namespace basegfx { // class to hold a single trapezoid - class B2DTrapezoid + class BASEGFX_DLLPUBLIC B2DTrapezoid { private: // Geometry data. YValues are down-oriented, this means bottom should @@ -96,13 +97,13 @@ namespace basegfx // lines have to be parallel to the X-Axis, thus this subdivision is NOT simply usable // for primitive decompositions. To use it, the shear and rotate parts of the // involved transformations HAVE to be taken into account. - void trapezoidSubdivide( + BASEGFX_DLLPUBLIC void trapezoidSubdivide( B2DTrapezoidVector& ro_Result, const B2DPolyPolygon& rSourcePolyPolygon); // directly create trapezoids from given edge. Depending on the given geometry, // none up to three trapezoids will be created - void createLineTrapezoidFromEdge( + BASEGFX_DLLPUBLIC void createLineTrapezoidFromEdge( B2DTrapezoidVector& ro_Result, const B2DPoint& rPointA, const B2DPoint& rPointB, @@ -111,7 +112,7 @@ namespace basegfx // create trapezoids for all edges of the given polygon. The closed state of // the polygon is taken into account. If curves are contaned, the default // AdaptiveSubdivision will be used. - void createLineTrapezoidFromB2DPolygon( + BASEGFX_DLLPUBLIC void createLineTrapezoidFromB2DPolygon( B2DTrapezoidVector& ro_Result, const B2DPolygon& rPolygon, double fLineWidth = 1.0); @@ -119,7 +120,7 @@ namespace basegfx // create trapezoids for all edges of the given polyPolygon. The closed state of // the PolyPolygon is taken into account. If curves are contaned, the default // AdaptiveSubdivision will be used. - void createLineTrapezoidFromB2DPolyPolygon( + BASEGFX_DLLPUBLIC void createLineTrapezoidFromB2DPolyPolygon( B2DTrapezoidVector& ro_Result, const B2DPolyPolygon& rPolyPolygon, double fLineWidth = 1.0); diff --git a/basegfx/inc/basegfx/polygon/b3dpolygon.hxx b/basegfx/inc/basegfx/polygon/b3dpolygon.hxx index 1732c1338042..1d6bf295cdec 100644 --- a/basegfx/inc/basegfx/polygon/b3dpolygon.hxx +++ b/basegfx/inc/basegfx/polygon/b3dpolygon.hxx @@ -30,6 +30,7 @@ #include <sal/types.h> #include <o3tl/cow_wrapper.hxx> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// // predeclarations @@ -50,7 +51,7 @@ namespace basegfx namespace basegfx { - class B3DPolygon + class BASEGFX_DLLPUBLIC B3DPolygon { public: typedef o3tl::cow_wrapper< ImplB3DPolygon > ImplType; diff --git a/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx b/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx index 71c7f36d50d8..dd785240c7f2 100644 --- a/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx +++ b/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx @@ -30,6 +30,7 @@ #include <basegfx/polygon/b3dpolypolygon.hxx> #include <basegfx/polygon/b3dpolygon.hxx> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// @@ -55,30 +56,30 @@ namespace basegfx // of the plane from the center (0.0). // The value bClipPositive defines on which side the return value will be (true -> on positive side of plane). // The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true). - B3DPolyPolygon clipPolyPolygonOnOrthogonalPlane(const B3DPolyPolygon& rCandidate, B3DOrientation ePlaneOrthogonal, bool bClipPositive, double fPlaneOffset, bool bStroke); + BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolyPolygonOnOrthogonalPlane(const B3DPolyPolygon& rCandidate, B3DOrientation ePlaneOrthogonal, bool bClipPositive, double fPlaneOffset, bool bStroke); // version for Polygons - B3DPolyPolygon clipPolygonOnOrthogonalPlane(const B3DPolygon& rCandidate, B3DOrientation ePlaneOrthogonal, bool bClipPositive, double fPlaneOffset, bool bStroke); + BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolygonOnOrthogonalPlane(const B3DPolygon& rCandidate, B3DOrientation ePlaneOrthogonal, bool bClipPositive, double fPlaneOffset, bool bStroke); // Clip the given PolyPolygon against the given range. bInside defines if the result will contain the // parts which are contained in the range or vice versa. // The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true). - B3DPolyPolygon clipPolyPolygonOnRange(const B3DPolyPolygon& rCandidate, const B3DRange& rRange, bool bInside, bool bStroke); + BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolyPolygonOnRange(const B3DPolyPolygon& rCandidate, const B3DRange& rRange, bool bInside, bool bStroke); // version for Polygons - B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B3DRange& rRange, bool bInside, bool bStroke); + BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B3DRange& rRange, bool bInside, bool bStroke); // versions for B2DRange, clips only against X,Y - B3DPolyPolygon clipPolyPolygonOnRange(const B3DPolyPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke); - B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke); + BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolyPolygonOnRange(const B3DPolyPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke); + BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke); // Clip the given PolyPolygon against given plane in 3D. The plane is defined by a plane normal and a point on the plane. // The value bClipPositive defines on which side the return value will be (true -> on positive side of plane). // The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true). - B3DPolyPolygon clipPolyPolygonOnPlane(const B3DPolyPolygon& rCandidate, const B3DPoint& rPointOnPlane, const B3DVector& rPlaneNormal, bool bClipPositive, bool bStroke); + BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolyPolygonOnPlane(const B3DPolyPolygon& rCandidate, const B3DPoint& rPointOnPlane, const B3DVector& rPlaneNormal, bool bClipPositive, bool bStroke); // version for Polygons - B3DPolyPolygon clipPolygonOnPlane(const B3DPolygon& rCandidate, const B3DPoint& rPointOnPlane, const B3DVector& rPlaneNormal, bool bClipPositive, bool bStroke); + BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolygonOnPlane(const B3DPolygon& rCandidate, const B3DPoint& rPointOnPlane, const B3DVector& rPlaneNormal, bool bClipPositive, bool bStroke); } // end of namespace tools } // end of namespace basegfx diff --git a/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx b/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx index 7945fc1bde00..6af99ef18a4a 100644 --- a/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx +++ b/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx @@ -33,6 +33,7 @@ #include <basegfx/polygon/b3dpolypolygon.hxx> #include <basegfx/vector/b2enums.hxx> #include <vector> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// @@ -53,58 +54,58 @@ namespace basegfx method corrects this (removes double start/end points) and sets the Closed()-state of the polygon correctly. */ - void checkClosed(B3DPolygon& rCandidate); + BASEGFX_DLLPUBLIC void checkClosed(B3DPolygon& rCandidate); // Get successor and predecessor indices. Returning the same index means there // is none. Same for successor. - sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const B3DPolygon& rCandidate); - sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const B3DPolygon& rCandidate); + BASEGFX_DLLPUBLIC sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const B3DPolygon& rCandidate); + BASEGFX_DLLPUBLIC sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const B3DPolygon& rCandidate); // Get orientation of Polygon - B2VectorOrientation getOrientation(const B3DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B2VectorOrientation getOrientation(const B3DPolygon& rCandidate); // get size of polygon. Control vectors are included in that ranges. - B3DRange getRange(const B3DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B3DRange getRange(const B3DPolygon& rCandidate); // get normal vector of polygon - B3DVector getNormal(const B3DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B3DVector getNormal(const B3DPolygon& rCandidate); // get normal vector of positive oriented polygon - B3DVector getPositiveOrientedNormal(const B3DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B3DVector getPositiveOrientedNormal(const B3DPolygon& rCandidate); // get signed area of polygon - double getSignedArea(const B3DPolygon& rCandidate); + BASEGFX_DLLPUBLIC double getSignedArea(const B3DPolygon& rCandidate); // get area of polygon - double getArea(const B3DPolygon& rCandidate); + BASEGFX_DLLPUBLIC double getArea(const B3DPolygon& rCandidate); // get signed area of polygon - double getSignedArea(const B3DPolygon& rCandidate); + BASEGFX_DLLPUBLIC double getSignedArea(const B3DPolygon& rCandidate); // get area of polygon - double getArea(const ::basegfx::B3DPolygon& rCandidate); + BASEGFX_DLLPUBLIC double getArea(const ::basegfx::B3DPolygon& rCandidate); // get length of polygon edge from point nIndex to nIndex + 1 - double getEdgeLength(const B3DPolygon& rCandidate, sal_uInt32 nIndex); + BASEGFX_DLLPUBLIC double getEdgeLength(const B3DPolygon& rCandidate, sal_uInt32 nIndex); // get length of polygon - double getLength(const B3DPolygon& rCandidate); + BASEGFX_DLLPUBLIC double getLength(const B3DPolygon& rCandidate); // get position on polygon for absolute given distance. If // length is given, it is assumed the correct polygon length, if 0.0 it is calculated // using getLength(...) - B3DPoint getPositionAbsolute(const B3DPolygon& rCandidate, double fDistance, double fLength = 0.0); + BASEGFX_DLLPUBLIC B3DPoint getPositionAbsolute(const B3DPolygon& rCandidate, double fDistance, double fLength = 0.0); // get position on polygon for relative given distance in range [0.0 .. 1.0]. If // length is given, it is assumed the correct polygon length, if 0.0 it is calculated // using getLength(...) - B3DPoint getPositionRelative(const B3DPolygon& rCandidate, double fDistance, double fLength = 0.0); + BASEGFX_DLLPUBLIC B3DPoint getPositionRelative(const B3DPolygon& rCandidate, double fDistance, double fLength = 0.0); /** Apply given LineDashing to given polygon For a description see applyLineDashing in b2dpolygontoos.hxx */ - void applyLineDashing( + BASEGFX_DLLPUBLIC void applyLineDashing( const B3DPolygon& rCandidate, const ::std::vector<double>& rDotDashArray, B3DPolyPolygon* pLineTarget, @@ -115,61 +116,61 @@ namespace basegfx rCandidate: the 3d geometry to change rCenter: the center of the 3d geometry */ - B3DPolygon applyDefaultNormalsSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter); + BASEGFX_DLLPUBLIC B3DPolygon applyDefaultNormalsSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter); /** invert normals for given 3d geometry. */ - B3DPolygon invertNormals( const B3DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B3DPolygon invertNormals( const B3DPolygon& rCandidate); /** Create/replace texture coordinates for given 3d geometry with parallel projected one rRange: the full range of the 3d geometry If bChangeX, x texture coordinate will be recalculated. If bChangeY, y texture coordinate will be recalculated. */ - B3DPolygon applyDefaultTextureCoordinatesParallel( const B3DPolygon& rCandidate, const B3DRange& rRange, bool bChangeX = true, bool bChangeY = true); + BASEGFX_DLLPUBLIC B3DPolygon applyDefaultTextureCoordinatesParallel( const B3DPolygon& rCandidate, const B3DRange& rRange, bool bChangeX = true, bool bChangeY = true); /** Create/replace texture coordinates for given 3d geometry with spherical one rCenter: the centre of the used 3d geometry If bChangeX, x texture coordinate will be recalculated. If bChangeY, y texture coordinate will be recalculated. */ - B3DPolygon applyDefaultTextureCoordinatesSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter, bool bChangeX = true, bool bChangeY = true); + BASEGFX_DLLPUBLIC B3DPolygon applyDefaultTextureCoordinatesSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter, bool bChangeX = true, bool bChangeY = true); // test if point is inside epsilon-range around an edge defined // by the two given points. Can be used for HitTesting. The epsilon-range // is defined to be the cylinder centered to the given edge, using radius // fDistance, and the sphere around both points with radius fDistance. - bool isInEpsilonRange(const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, const B3DPoint& rTestPosition, double fDistance); + BASEGFX_DLLPUBLIC bool isInEpsilonRange(const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, const B3DPoint& rTestPosition, double fDistance); // test if point is inside epsilon-range around the given Polygon. Can be used // for HitTesting. The epsilon-range is defined to be the cylinder centered to // the given edge, using radius fDistance, and the sphere around both points with radius fDistance. - bool isInEpsilonRange(const B3DPolygon& rCandidate, const B3DPoint& rTestPosition, double fDistance); + BASEGFX_DLLPUBLIC bool isInEpsilonRange(const B3DPolygon& rCandidate, const B3DPoint& rTestPosition, double fDistance); // isInside tests for B3DPoint and other B3DPolygon. On border is not inside as long as // not true is given in bWithBorder flag. - bool isInside(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithBorder = false); - bool isInside(const B3DPolygon& rCandidate, const B3DPolygon& rPolygon, bool bWithBorder = false); + BASEGFX_DLLPUBLIC bool isInside(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithBorder = false); + BASEGFX_DLLPUBLIC bool isInside(const B3DPolygon& rCandidate, const B3DPolygon& rPolygon, bool bWithBorder = false); // calculates if given point is on given line, taking care of the numerical epsilon - bool isPointOnLine(const B3DPoint& rStart, const B3DPoint& rEnd, const B3DPoint& rCandidate, bool bWithPoints = false); + BASEGFX_DLLPUBLIC bool isPointOnLine(const B3DPoint& rStart, const B3DPoint& rEnd, const B3DPoint& rCandidate, bool bWithPoints = false); // calculates if given point is on given polygon, taking care of the numerical epsilon. Uses // isPointOnLine internally - bool isPointOnPolygon(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithPoints = true); + BASEGFX_DLLPUBLIC bool isPointOnPolygon(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithPoints = true); // helper to get a fCut position between a plane (given with normal and a point) // and a line given by start and end point - bool getCutBetweenLineAndPlane(const B3DVector& rPlaneNormal, const B3DPoint& rPlanePoint, const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, double& fCut); + BASEGFX_DLLPUBLIC bool getCutBetweenLineAndPlane(const B3DVector& rPlaneNormal, const B3DPoint& rPlanePoint, const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, double& fCut); // helper to get a fCut position between a 3d Polygon // and a line given by start and end point - bool getCutBetweenLineAndPolygon(const B3DPolygon& rCandidate, const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, double& fCut); + BASEGFX_DLLPUBLIC bool getCutBetweenLineAndPolygon(const B3DPolygon& rCandidate, const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, double& fCut); ////////////////////////////////////////////////////////////////////// // comparators with tolerance for 3D Polygons - bool equal(const B3DPolygon& rCandidateA, const B3DPolygon& rCandidateB, const double& rfSmallValue); - bool equal(const B3DPolygon& rCandidateA, const B3DPolygon& rCandidateB); + BASEGFX_DLLPUBLIC bool equal(const B3DPolygon& rCandidateA, const B3DPolygon& rCandidateB, const double& rfSmallValue); + BASEGFX_DLLPUBLIC bool equal(const B3DPolygon& rCandidateA, const B3DPolygon& rCandidateB); /** snap some polygon coordinates to discrete coordinates @@ -183,7 +184,7 @@ namespace basegfx @return The modified version of the source polygon */ - B3DPolygon snapPointsOfHorizontalOrVerticalEdges(const B3DPolygon& rCandidate); + BASEGFX_DLLPUBLIC B3DPolygon snapPointsOfHorizontalOrVerticalEdges(const B3DPolygon& rCandidate); } // end of namespace tools } // end of namespace basegfx diff --git a/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx b/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx index 76e0c2f844c0..1561354d820f 100644 --- a/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx +++ b/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx @@ -30,6 +30,7 @@ #include <sal/types.h> #include <o3tl/cow_wrapper.hxx> +#include <basegfx/basegfxdllapi.h> // predeclarations class ImplB3DPolyPolygon; @@ -45,7 +46,7 @@ namespace basegfx namespace basegfx { - class B3DPolyPolygon + class BASEGFX_DLLPUBLIC B3DPolyPolygon { public: typedef o3tl::cow_wrapper< ImplB3DPolyPolygon > ImplType; diff --git a/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx b/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx index 813be9839a9a..6278986ddc1e 100644 --- a/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx +++ b/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx @@ -33,6 +33,7 @@ #include <vector> #include <basegfx/numeric/ftools.hxx> #include <basegfx/point/b3dpoint.hxx> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// @@ -47,13 +48,13 @@ namespace basegfx // B3DPolyPolygon tools // get size of PolyPolygon. Control vectors are included in that ranges. - B3DRange getRange(const B3DPolyPolygon& rCandidate); + BASEGFX_DLLPUBLIC B3DRange getRange(const B3DPolyPolygon& rCandidate); /** Apply given LineDashing to given polyPolygon For a description see applyLineDashing in b2dpolygontoos.hxx */ - void applyLineDashing( + BASEGFX_DLLPUBLIC void applyLineDashing( const B3DPolyPolygon& rCandidate, const ::std::vector<double>& rDotDashArray, B3DPolyPolygon* pLineTarget, @@ -62,26 +63,26 @@ namespace basegfx /** Create a unit 3D line polyPolygon which defines a cube. */ - B3DPolyPolygon createUnitCubePolyPolygon(); + BASEGFX_DLLPUBLIC B3DPolyPolygon createUnitCubePolyPolygon(); /** Create a unit 3D fill polyPolygon which defines a cube. */ - B3DPolyPolygon createUnitCubeFillPolyPolygon(); + BASEGFX_DLLPUBLIC B3DPolyPolygon createUnitCubeFillPolyPolygon(); /** Create a 3D line polyPolygon from a B3DRange which defines a cube. */ - B3DPolyPolygon createCubePolyPolygonFromB3DRange( const B3DRange& rRange); + BASEGFX_DLLPUBLIC B3DPolyPolygon createCubePolyPolygonFromB3DRange( const B3DRange& rRange); /** Create a 3D fill polyPolygon from a B3DRange which defines a cube. */ - B3DPolyPolygon createCubeFillPolyPolygonFromB3DRange( const B3DRange& rRange); + BASEGFX_DLLPUBLIC B3DPolyPolygon createCubeFillPolyPolygonFromB3DRange( const B3DRange& rRange); /** Create a unit 3D line polyPolygon which defines a sphere with the given count of hor and ver segments. Result will be centered at (0.0, 0.0, 0.0) and sized [-1.0 .. 1.0] in all dimensions. If nHorSeg == 0 and/or nVerSeg == 0, a default will be calculated to have a step at least each 15 degrees. With VerStart, VerStop and hor range in cartesian may be specified to create a partial sphere only. */ - B3DPolyPolygon createUnitSpherePolyPolygon( + BASEGFX_DLLPUBLIC B3DPolyPolygon createUnitSpherePolyPolygon( sal_uInt32 nHorSeg = 0L, sal_uInt32 nVerSeg = 0L, double fVerStart = F_PI2, double fVerStop = -F_PI2, double fHorStart = 0.0, double fHorStop = F_2PI); @@ -90,7 +91,7 @@ namespace basegfx If nHorSeg == 0 and/or nVerSeg == 0, a default will be calculated to have a step at least each 15 degrees. With VerStart, VerStop and hor range in cartesian may be specified to create a partial sphere only. */ - B3DPolyPolygon createSpherePolyPolygonFromB3DRange( + BASEGFX_DLLPUBLIC B3DPolyPolygon createSpherePolyPolygonFromB3DRange( const B3DRange& rRange, sal_uInt32 nHorSeg = 0L, sal_uInt32 nVerSeg = 0L, double fVerStart = F_PI2, double fVerStop = -F_PI2, @@ -99,7 +100,7 @@ namespace basegfx /** same as createUnitSpherePolyPolygon, but creates filled polygons (closed and oriented) There is one extra, the bool bNormals defines if normals will be set, default is false */ - B3DPolyPolygon createUnitSphereFillPolyPolygon( + BASEGFX_DLLPUBLIC B3DPolyPolygon createUnitSphereFillPolyPolygon( sal_uInt32 nHorSeg = 0L, sal_uInt32 nVerSeg = 0L, bool bNormals = false, double fVerStart = F_PI2, double fVerStop = -F_PI2, @@ -108,7 +109,7 @@ namespace basegfx /** same as createSpherePolyPolygonFromB3DRange, but creates filled polygons (closed and oriented) There is one extra, the bool bNormals defines if normals will be set, default is false */ - B3DPolyPolygon createSphereFillPolyPolygonFromB3DRange( + BASEGFX_DLLPUBLIC B3DPolyPolygon createSphereFillPolyPolygonFromB3DRange( const B3DRange& rRange, sal_uInt32 nHorSeg = 0L, sal_uInt32 nVerSeg = 0L, bool bNormals = false, @@ -119,34 +120,34 @@ namespace basegfx rCandidate: the 3d geometry to change rCenter: the center of the 3d geometry */ - B3DPolyPolygon applyDefaultNormalsSphere( const B3DPolyPolygon& rCandidate, const B3DPoint& rCenter); + BASEGFX_DLLPUBLIC B3DPolyPolygon applyDefaultNormalsSphere( const B3DPolyPolygon& rCandidate, const B3DPoint& rCenter); /** invert normals for given 3d geometry. */ - B3DPolyPolygon invertNormals( const B3DPolyPolygon& rCandidate); + BASEGFX_DLLPUBLIC B3DPolyPolygon invertNormals( const B3DPolyPolygon& rCandidate); /** Create/replace texture coordinates for given 3d geometry with parallel projected one rRange: the full range of the 3d geometry If bChangeX, x texture coordinate will be recalculated. If bChangeY, y texture coordinate will be recalculated. */ - B3DPolyPolygon applyDefaultTextureCoordinatesParallel( const B3DPolyPolygon& rCandidate, const B3DRange& rRange, bool bChangeX = true, bool bChangeY = true); + BASEGFX_DLLPUBLIC B3DPolyPolygon applyDefaultTextureCoordinatesParallel( const B3DPolyPolygon& rCandidate, const B3DRange& rRange, bool bChangeX = true, bool bChangeY = true); /** Create/replace texture coordinates for given 3d geometry with spherical one rCenter: the centre of the used 3d geometry If bChangeX, x texture coordinate will be recalculated. If bChangeY, y texture coordinate will be recalculated. */ - B3DPolyPolygon applyDefaultTextureCoordinatesSphere( const B3DPolyPolygon& rCandidate, const B3DPoint& rCenter, bool bChangeX = true, bool bChangeY = true); + BASEGFX_DLLPUBLIC B3DPolyPolygon applyDefaultTextureCoordinatesSphere( const B3DPolyPolygon& rCandidate, const B3DPoint& rCenter, bool bChangeX = true, bool bChangeY = true); // isInside test for B3DPoint. On border is not inside as long as not true is given // in bWithBorder flag. It is assumed that the orientations of the given polygon are correct. - bool isInside(const B3DPolyPolygon& rCandidate, const B3DPoint& rPoint, bool bWithBorder = false); + BASEGFX_DLLPUBLIC bool isInside(const B3DPolyPolygon& rCandidate, const B3DPoint& rPoint, bool bWithBorder = false); ////////////////////////////////////////////////////////////////////// // comparators with tolerance for 3D PolyPolygons - bool equal(const B3DPolyPolygon& rCandidateA, const B3DPolyPolygon& rCandidateB, const double& rfSmallValue); - bool equal(const B3DPolyPolygon& rCandidateA, const B3DPolyPolygon& rCandidateB); + BASEGFX_DLLPUBLIC bool equal(const B3DPolyPolygon& rCandidateA, const B3DPolyPolygon& rCandidateB, const double& rfSmallValue); + BASEGFX_DLLPUBLIC bool equal(const B3DPolyPolygon& rCandidateA, const B3DPolyPolygon& rCandidateB); } // end of namespace tools } // end of namespace basegfx diff --git a/basegfx/inc/basegfx/range/b1drange.hxx b/basegfx/inc/basegfx/range/b1drange.hxx index eba1536f4ee6..995f2e95777f 100644 --- a/basegfx/inc/basegfx/range/b1drange.hxx +++ b/basegfx/inc/basegfx/range/b1drange.hxx @@ -29,13 +29,14 @@ #define _BGFX_RANGE_B1DRANGE_HXX #include <basegfx/range/basicrange.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { class B1IRange; - class B1DRange + class BASEGFX_DLLPUBLIC B1DRange { ::basegfx::BasicRange< double, DoubleTraits > maRange; diff --git a/basegfx/inc/basegfx/range/b1ibox.hxx b/basegfx/inc/basegfx/range/b1ibox.hxx index cb4ab8770a49..9535f0346a04 100644 --- a/basegfx/inc/basegfx/range/b1ibox.hxx +++ b/basegfx/inc/basegfx/range/b1ibox.hxx @@ -29,11 +29,12 @@ #define _BGFX_RANGE_B1IBOX_HXX #include <basegfx/range/basicbox.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { - class B1IBox + class BASEGFX_DLLPUBLIC B1IBox { ::basegfx::BasicBox maRange; diff --git a/basegfx/inc/basegfx/range/b1irange.hxx b/basegfx/inc/basegfx/range/b1irange.hxx index 6c65fbaebff4..45db9d3fbecf 100644 --- a/basegfx/inc/basegfx/range/b1irange.hxx +++ b/basegfx/inc/basegfx/range/b1irange.hxx @@ -29,11 +29,12 @@ #define _BGFX_RANGE_B1IRANGE_HXX #include <basegfx/range/basicrange.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { - class B1IRange + class BASEGFX_DLLPUBLIC B1IRange { ::basegfx::BasicRange< sal_Int32, Int32Traits > maRange; diff --git a/basegfx/inc/basegfx/range/b2dpolyrange.hxx b/basegfx/inc/basegfx/range/b2dpolyrange.hxx index 2202869dc921..256a17845e5f 100644 --- a/basegfx/inc/basegfx/range/b2dpolyrange.hxx +++ b/basegfx/inc/basegfx/range/b2dpolyrange.hxx @@ -34,6 +34,7 @@ #include <o3tl/cow_wrapper.hxx> #include <boost/tuple/tuple.hpp> #include <basegfx/vector/b2enums.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { @@ -58,7 +59,7 @@ namespace basegfx contain 'holes' - this is encoded via polygon orientation at the poly-polygon, and via explicit flags for the poly-range. */ - class B2DPolyRange + class BASEGFX_DLLPUBLIC B2DPolyRange { public: typedef boost::tuple<B2DRange,B2VectorOrientation> ElementType ; diff --git a/basegfx/inc/basegfx/range/b2drange.hxx b/basegfx/inc/basegfx/range/b2drange.hxx index fc3a6fe53659..7d00f9bc0ee7 100644 --- a/basegfx/inc/basegfx/range/b2drange.hxx +++ b/basegfx/inc/basegfx/range/b2drange.hxx @@ -33,6 +33,7 @@ #include <basegfx/tuple/b2dtuple.hxx> #include <basegfx/range/basicrange.hxx> #include <vector> +#include <basegfx/basegfxdllapi.h> namespace basegfx @@ -41,7 +42,7 @@ namespace basegfx class B2IRange; class B2DHomMatrix; - class B2DRange + class BASEGFX_DLLPUBLIC B2DRange { public: typedef double ValueType; @@ -264,7 +265,7 @@ namespace basegfx @return the nearest integer for this range */ - B2IRange fround(const B2DRange& rRange); + BASEGFX_DLLPUBLIC B2IRange fround(const B2DRange& rRange); /** Compute the set difference of the two given ranges @@ -285,7 +286,7 @@ namespace basegfx @return the input vector */ - ::std::vector< B2DRange >& computeSetDifference( ::std::vector< B2DRange >& o_rResult, + BASEGFX_DLLPUBLIC ::std::vector< B2DRange >& computeSetDifference( ::std::vector< B2DRange >& o_rResult, const B2DRange& rFirst, const B2DRange& rSecond ); diff --git a/basegfx/inc/basegfx/range/b2drangeclipper.hxx b/basegfx/inc/basegfx/range/b2drangeclipper.hxx index 3285ffeaffe1..10c095afceec 100644 --- a/basegfx/inc/basegfx/range/b2drangeclipper.hxx +++ b/basegfx/inc/basegfx/range/b2drangeclipper.hxx @@ -33,6 +33,7 @@ #include <basegfx/range/b2dpolyrange.hxx> #include <vector> +#include <basegfx/basegfxdllapi.h> namespace basegfx { @@ -45,7 +46,7 @@ namespace basegfx poly-polygon with the same topology, and encoding inside/outsidedness via polygon orientation and layering. */ - B2DPolyPolygon solveCrossovers(const std::vector<B2DRange>& rRanges, + BASEGFX_DLLPUBLIC B2DPolyPolygon solveCrossovers(const std::vector<B2DRange>& rRanges, const std::vector<B2VectorOrientation>& rOrientations); } } diff --git a/basegfx/inc/basegfx/range/b2ibox.hxx b/basegfx/inc/basegfx/range/b2ibox.hxx index a188c7e8abe6..11a320c8c419 100644 --- a/basegfx/inc/basegfx/range/b2ibox.hxx +++ b/basegfx/inc/basegfx/range/b2ibox.hxx @@ -34,11 +34,12 @@ #include <basegfx/tuple/b2i64tuple.hxx> #include <basegfx/range/basicbox.hxx> #include <vector> +#include <basegfx/basegfxdllapi.h> namespace basegfx { - class B2IBox + class BASEGFX_DLLPUBLIC B2IBox { public: typedef sal_Int32 ValueType; diff --git a/basegfx/inc/basegfx/range/b2irange.hxx b/basegfx/inc/basegfx/range/b2irange.hxx index 8d4690283da0..92ce097df27b 100644 --- a/basegfx/inc/basegfx/range/b2irange.hxx +++ b/basegfx/inc/basegfx/range/b2irange.hxx @@ -34,11 +34,12 @@ #include <basegfx/tuple/b2i64tuple.hxx> #include <basegfx/range/basicrange.hxx> #include <vector> +#include <basegfx/basegfxdllapi.h> namespace basegfx { - class B2IRange + class BASEGFX_DLLPUBLIC B2IRange { public: typedef sal_Int32 ValueType; @@ -245,7 +246,7 @@ namespace basegfx @return the input vector */ - ::std::vector< B2IRange >& computeSetDifference( ::std::vector< B2IRange >& o_rResult, + BASEGFX_DLLPUBLIC ::std::vector< B2IRange >& computeSetDifference( ::std::vector< B2IRange >& o_rResult, const B2IRange& rFirst, const B2IRange& rSecond ); diff --git a/basegfx/inc/basegfx/range/b3drange.hxx b/basegfx/inc/basegfx/range/b3drange.hxx index 2a2a42aa0718..9474f55fc2a9 100644 --- a/basegfx/inc/basegfx/range/b3drange.hxx +++ b/basegfx/inc/basegfx/range/b3drange.hxx @@ -32,6 +32,7 @@ #include <basegfx/point/b3dpoint.hxx> #include <basegfx/tuple/b3dtuple.hxx> #include <basegfx/range/basicrange.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { @@ -39,7 +40,7 @@ namespace basegfx class B3IRange; class B3DHomMatrix; - class B3DRange + class BASEGFX_DLLPUBLIC B3DRange { typedef ::basegfx::BasicRange< double, DoubleTraits > MyBasicRange; @@ -295,7 +296,7 @@ namespace basegfx @return the nearest integer for this range */ - B3IRange fround(const B3DRange& rRange); + BASEGFX_DLLPUBLIC B3IRange fround(const B3DRange& rRange); } // end of namespace basegfx diff --git a/basegfx/inc/basegfx/range/b3ibox.hxx b/basegfx/inc/basegfx/range/b3ibox.hxx index f9693465a2bb..7aa9e9c82b64 100644 --- a/basegfx/inc/basegfx/range/b3ibox.hxx +++ b/basegfx/inc/basegfx/range/b3ibox.hxx @@ -33,10 +33,11 @@ #include <basegfx/tuple/b3ituple.hxx> #include <basegfx/tuple/b3i64tuple.hxx> #include <basegfx/range/basicbox.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { - class B3IBox + class BASEGFX_DLLPUBLIC B3IBox { BasicBox maRangeX; BasicBox maRangeY; diff --git a/basegfx/inc/basegfx/range/b3irange.hxx b/basegfx/inc/basegfx/range/b3irange.hxx index e2b9a08c3093..a35f16dcd3ea 100644 --- a/basegfx/inc/basegfx/range/b3irange.hxx +++ b/basegfx/inc/basegfx/range/b3irange.hxx @@ -33,10 +33,11 @@ #include <basegfx/tuple/b3ituple.hxx> #include <basegfx/tuple/b3i64tuple.hxx> #include <basegfx/range/basicrange.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { - class B3IRange + class BASEGFX_DLLPUBLIC B3IRange { typedef ::basegfx::BasicRange< sal_Int32, Int32Traits > MyBasicRange; diff --git a/basegfx/inc/basegfx/range/basicbox.hxx b/basegfx/inc/basegfx/range/basicbox.hxx index 0a5274bc9bc9..9cf56e89bb55 100644 --- a/basegfx/inc/basegfx/range/basicbox.hxx +++ b/basegfx/inc/basegfx/range/basicbox.hxx @@ -29,6 +29,7 @@ #define _BGFX_RANGE_BASICBOX_HXX #include <basegfx/range/basicrange.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx @@ -40,7 +41,7 @@ namespace basegfx <em>outside</em> of the range, in contrast to BasicRange, which considers them inside. */ - class BasicBox : public BasicRange< sal_Int32, Int32Traits > + class BASEGFX_DLLPUBLIC BasicBox : public BasicRange< sal_Int32, Int32Traits > { typedef BasicRange< sal_Int32, Int32Traits > Base; public: diff --git a/basegfx/inc/basegfx/raster/bpixelraster.hxx b/basegfx/inc/basegfx/raster/bpixelraster.hxx index c28adcdb2ef7..0805db5b5e6d 100644 --- a/basegfx/inc/basegfx/raster/bpixelraster.hxx +++ b/basegfx/inc/basegfx/raster/bpixelraster.hxx @@ -32,6 +32,7 @@ #include <sal/types.h> #include <basegfx/pixel/bpixel.hxx> #include <rtl/memory.h> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// // predeclarations @@ -40,7 +41,7 @@ namespace basegfx { - class BPixelRaster + class BASEGFX_DLLPUBLIC BPixelRaster { private: // do not allow copy constructor and assignment operator diff --git a/basegfx/inc/basegfx/raster/bzpixelraster.hxx b/basegfx/inc/basegfx/raster/bzpixelraster.hxx index 2c0905a78397..61a21c40dda7 100644 --- a/basegfx/inc/basegfx/raster/bzpixelraster.hxx +++ b/basegfx/inc/basegfx/raster/bzpixelraster.hxx @@ -30,6 +30,7 @@ #include <basegfx/raster/bpixelraster.hxx> #include <rtl/memory.h> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// // predeclarations @@ -38,7 +39,7 @@ namespace basegfx { - class BZPixelRaster : public BPixelRaster + class BASEGFX_DLLPUBLIC BZPixelRaster : public BPixelRaster { protected: // additionally, host a ZBuffer diff --git a/basegfx/inc/basegfx/raster/rasterconvert3d.hxx b/basegfx/inc/basegfx/raster/rasterconvert3d.hxx index fb777482246d..fde93a4710dd 100644 --- a/basegfx/inc/basegfx/raster/rasterconvert3d.hxx +++ b/basegfx/inc/basegfx/raster/rasterconvert3d.hxx @@ -34,6 +34,7 @@ #include <basegfx/vector/b3dvector.hxx> #include <basegfx/point/b2dpoint.hxx> #include <basegfx/vector/b2dvector.hxx> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// // predeclarations @@ -49,7 +50,7 @@ namespace basegfx namespace basegfx { - class ip_single + class BASEGFX_DLLPUBLIC ip_single { private: double mfVal; @@ -75,7 +76,7 @@ namespace basegfx namespace basegfx { - class ip_double + class BASEGFX_DLLPUBLIC ip_double { private: ip_single maX; @@ -101,7 +102,7 @@ namespace basegfx namespace basegfx { - class ip_triple + class BASEGFX_DLLPUBLIC ip_triple { private: ip_single maX; @@ -137,7 +138,7 @@ namespace basegfx { #define SCANLINE_EMPTY_INDEX (0xffffffff) - class InterpolatorProvider3D + class BASEGFX_DLLPUBLIC InterpolatorProvider3D { private: ::std::vector< ip_triple > maColorInterpolators; @@ -209,7 +210,7 @@ namespace basegfx namespace basegfx { - class RasterConversionLineEntry3D + class BASEGFX_DLLPUBLIC RasterConversionLineEntry3D { private: ip_single maX; @@ -307,7 +308,7 @@ namespace basegfx namespace basegfx { - class RasterConverter3D : public InterpolatorProvider3D + class BASEGFX_DLLPUBLIC RasterConverter3D : public InterpolatorProvider3D { private: // the line entries for an area conversion run diff --git a/basegfx/inc/basegfx/tools/b2dclipstate.hxx b/basegfx/inc/basegfx/tools/b2dclipstate.hxx index 7d336d8cb48e..db972a2f5850 100644 --- a/basegfx/inc/basegfx/tools/b2dclipstate.hxx +++ b/basegfx/inc/basegfx/tools/b2dclipstate.hxx @@ -33,6 +33,7 @@ #include <sal/types.h> #include <o3tl/cow_wrapper.hxx> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// @@ -57,7 +58,7 @@ namespace basegfx a clip representation is requested, and using faster code paths for common special cases (like all-rectangle clips) */ - class B2DClipState + class BASEGFX_DLLPUBLIC B2DClipState { public: typedef o3tl::cow_wrapper< ImplB2DClipState > ImplType; diff --git a/basegfx/inc/basegfx/tools/canvastools.hxx b/basegfx/inc/basegfx/tools/canvastools.hxx index 1903518d991b..3b160a4242d5 100755 --- a/basegfx/inc/basegfx/tools/canvastools.hxx +++ b/basegfx/inc/basegfx/tools/canvastools.hxx @@ -30,6 +30,7 @@ #include <com/sun/star/uno/Reference.hxx> #include <com/sun/star/uno/Sequence.hxx> +#include <basegfx/basegfxdllapi.h> namespace com { namespace sun { namespace star { namespace geometry @@ -79,118 +80,118 @@ namespace basegfx // Polygon conversions // =================================================================== - ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XPolyPolygon2D > + BASEGFX_DLLPUBLIC ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XPolyPolygon2D > xPolyPolygonFromB2DPolygon( const ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XGraphicDevice >& xGraphicDevice, const ::basegfx::B2DPolygon& rPoly ); - ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XPolyPolygon2D > + BASEGFX_DLLPUBLIC ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XPolyPolygon2D > xPolyPolygonFromB2DPolyPolygon( const ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XGraphicDevice >& xGraphicDevice, const ::basegfx::B2DPolyPolygon& rPolyPoly ); - ::com::sun::star::uno::Sequence< + BASEGFX_DLLPUBLIC ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::geometry::RealBezierSegment2D > > bezierSequenceSequenceFromB2DPolyPolygon( const ::basegfx::B2DPolyPolygon& rPolyPoly ); - ::com::sun::star::uno::Sequence< + BASEGFX_DLLPUBLIC ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::geometry::RealPoint2D > > pointSequenceSequenceFromB2DPolyPolygon( const ::basegfx::B2DPolyPolygon& rPolyPoly ); - ::basegfx::B2DPolygon polygonFromPoint2DSequence( + BASEGFX_DLLPUBLIC ::basegfx::B2DPolygon polygonFromPoint2DSequence( const ::com::sun::star::uno::Sequence< ::com::sun::star::geometry::RealPoint2D >& rPoints ); - ::basegfx::B2DPolyPolygon polyPolygonFromPoint2DSequenceSequence( + BASEGFX_DLLPUBLIC ::basegfx::B2DPolyPolygon polyPolygonFromPoint2DSequenceSequence( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::geometry::RealPoint2D > >& rPoints ); - ::basegfx::B2DPolygon polygonFromBezier2DSequence( + BASEGFX_DLLPUBLIC ::basegfx::B2DPolygon polygonFromBezier2DSequence( const ::com::sun::star::uno::Sequence< ::com::sun::star::geometry::RealBezierSegment2D >& rPoints ); - ::basegfx::B2DPolyPolygon polyPolygonFromBezier2DSequenceSequence( + BASEGFX_DLLPUBLIC ::basegfx::B2DPolyPolygon polyPolygonFromBezier2DSequenceSequence( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::geometry::RealBezierSegment2D > >& rPoints ); - ::basegfx::B2DPolyPolygon b2DPolyPolygonFromXPolyPolygon2D( + BASEGFX_DLLPUBLIC ::basegfx::B2DPolyPolygon b2DPolyPolygonFromXPolyPolygon2D( const ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XPolyPolygon2D >& rPoly ); // Matrix conversions // =================================================================== - ::com::sun::star::geometry::AffineMatrix2D& + BASEGFX_DLLPUBLIC ::com::sun::star::geometry::AffineMatrix2D& affineMatrixFromHomMatrix( ::com::sun::star::geometry::AffineMatrix2D& matrix, const ::basegfx::B2DHomMatrix& transform); - ::com::sun::star::geometry::AffineMatrix3D& affineMatrixFromHomMatrix3D( + BASEGFX_DLLPUBLIC ::com::sun::star::geometry::AffineMatrix3D& affineMatrixFromHomMatrix3D( ::com::sun::star::geometry::AffineMatrix3D& matrix, const ::basegfx::B3DHomMatrix& transform); - ::basegfx::B2DHomMatrix& + BASEGFX_DLLPUBLIC ::basegfx::B2DHomMatrix& homMatrixFromAffineMatrix( ::basegfx::B2DHomMatrix& transform, const ::com::sun::star::geometry::AffineMatrix2D& matrix ); - ::basegfx::B2DHomMatrix homMatrixFromAffineMatrix( const ::com::sun::star::geometry::AffineMatrix2D& matrix ); - ::basegfx::B3DHomMatrix homMatrixFromAffineMatrix3D( const ::com::sun::star::geometry::AffineMatrix3D& matrix ); + BASEGFX_DLLPUBLIC ::basegfx::B2DHomMatrix homMatrixFromAffineMatrix( const ::com::sun::star::geometry::AffineMatrix2D& matrix ); + BASEGFX_DLLPUBLIC ::basegfx::B3DHomMatrix homMatrixFromAffineMatrix3D( const ::com::sun::star::geometry::AffineMatrix3D& matrix ); - ::com::sun::star::geometry::Matrix2D& + BASEGFX_DLLPUBLIC ::com::sun::star::geometry::Matrix2D& matrixFromHomMatrix( ::com::sun::star::geometry::Matrix2D& matrix, const ::basegfx::B2DHomMatrix& transform); - ::basegfx::B2DHomMatrix& + BASEGFX_DLLPUBLIC ::basegfx::B2DHomMatrix& homMatrixFromMatrix( ::basegfx::B2DHomMatrix& transform, const ::com::sun::star::geometry::Matrix2D& matrix ); // Geometry conversions // =================================================================== - ::com::sun::star::geometry::RealSize2D size2DFromB2DSize( const ::basegfx::B2DVector& ); - ::com::sun::star::geometry::RealPoint2D point2DFromB2DPoint( const ::basegfx::B2DPoint& ); - ::com::sun::star::geometry::RealRectangle2D rectangle2DFromB2DRectangle( const ::basegfx::B2DRange& ); - ::com::sun::star::geometry::RealRectangle3D rectangle3DFromB3DRectangle( const ::basegfx::B3DRange& ); + BASEGFX_DLLPUBLIC ::com::sun::star::geometry::RealSize2D size2DFromB2DSize( const ::basegfx::B2DVector& ); + BASEGFX_DLLPUBLIC ::com::sun::star::geometry::RealPoint2D point2DFromB2DPoint( const ::basegfx::B2DPoint& ); + BASEGFX_DLLPUBLIC ::com::sun::star::geometry::RealRectangle2D rectangle2DFromB2DRectangle( const ::basegfx::B2DRange& ); + BASEGFX_DLLPUBLIC ::com::sun::star::geometry::RealRectangle3D rectangle3DFromB3DRectangle( const ::basegfx::B3DRange& ); - ::basegfx::B2DVector b2DSizeFromRealSize2D( const ::com::sun::star::geometry::RealSize2D& ); - ::basegfx::B2DPoint b2DPointFromRealPoint2D( const ::com::sun::star::geometry::RealPoint2D& ); - ::basegfx::B2DRange b2DRectangleFromRealRectangle2D( const ::com::sun::star::geometry::RealRectangle2D& ); - ::basegfx::B3DRange b3DRectangleFromRealRectangle3D( const ::com::sun::star::geometry::RealRectangle3D& ); + BASEGFX_DLLPUBLIC ::basegfx::B2DVector b2DSizeFromRealSize2D( const ::com::sun::star::geometry::RealSize2D& ); + BASEGFX_DLLPUBLIC ::basegfx::B2DPoint b2DPointFromRealPoint2D( const ::com::sun::star::geometry::RealPoint2D& ); + BASEGFX_DLLPUBLIC ::basegfx::B2DRange b2DRectangleFromRealRectangle2D( const ::com::sun::star::geometry::RealRectangle2D& ); + BASEGFX_DLLPUBLIC ::basegfx::B3DRange b3DRectangleFromRealRectangle3D( const ::com::sun::star::geometry::RealRectangle3D& ); - ::com::sun::star::geometry::IntegerSize2D integerSize2DFromB2ISize( const ::basegfx::B2IVector& ); - ::com::sun::star::geometry::IntegerPoint2D integerPoint2DFromB2IPoint( const ::basegfx::B2IPoint& ); - ::com::sun::star::geometry::IntegerRectangle2D integerRectangle2DFromB2IRectangle( const ::basegfx::B2IRange& ); + BASEGFX_DLLPUBLIC ::com::sun::star::geometry::IntegerSize2D integerSize2DFromB2ISize( const ::basegfx::B2IVector& ); + BASEGFX_DLLPUBLIC ::com::sun::star::geometry::IntegerPoint2D integerPoint2DFromB2IPoint( const ::basegfx::B2IPoint& ); + BASEGFX_DLLPUBLIC ::com::sun::star::geometry::IntegerRectangle2D integerRectangle2DFromB2IRectangle( const ::basegfx::B2IRange& ); - ::basegfx::B2IVector b2ISizeFromIntegerSize2D( const ::com::sun::star::geometry::IntegerSize2D& ); - ::basegfx::B2IPoint b2IPointFromIntegerPoint2D( const ::com::sun::star::geometry::IntegerPoint2D& ); - ::basegfx::B2IRange b2IRectangleFromIntegerRectangle2D( const ::com::sun::star::geometry::IntegerRectangle2D& ); + BASEGFX_DLLPUBLIC ::basegfx::B2IVector b2ISizeFromIntegerSize2D( const ::com::sun::star::geometry::IntegerSize2D& ); + BASEGFX_DLLPUBLIC ::basegfx::B2IPoint b2IPointFromIntegerPoint2D( const ::com::sun::star::geometry::IntegerPoint2D& ); + BASEGFX_DLLPUBLIC ::basegfx::B2IRange b2IRectangleFromIntegerRectangle2D( const ::com::sun::star::geometry::IntegerRectangle2D& ); - ::com::sun::star::awt::Size awtSizeFromB2ISize( const ::basegfx::B2IVector& ); - ::com::sun::star::awt::Point awtPointFromB2IPoint( const ::basegfx::B2IPoint& ); - ::com::sun::star::awt::Rectangle awtRectangleFromB2IRectangle( const ::basegfx::B2IRange& ); + BASEGFX_DLLPUBLIC ::com::sun::star::awt::Size awtSizeFromB2ISize( const ::basegfx::B2IVector& ); + BASEGFX_DLLPUBLIC ::com::sun::star::awt::Point awtPointFromB2IPoint( const ::basegfx::B2IPoint& ); + BASEGFX_DLLPUBLIC ::com::sun::star::awt::Rectangle awtRectangleFromB2IRectangle( const ::basegfx::B2IRange& ); - ::basegfx::B2IVector b2ISizeFromAwtSize( const ::com::sun::star::awt::Size& ); - ::basegfx::B2IPoint b2IPointFromAwtPoint( const ::com::sun::star::awt::Point& ); - ::basegfx::B2IRange b2IRectangleFromAwtRectangle( const ::com::sun::star::awt::Rectangle& ); + BASEGFX_DLLPUBLIC ::basegfx::B2IVector b2ISizeFromAwtSize( const ::com::sun::star::awt::Size& ); + BASEGFX_DLLPUBLIC ::basegfx::B2IPoint b2IPointFromAwtPoint( const ::com::sun::star::awt::Point& ); + BASEGFX_DLLPUBLIC ::basegfx::B2IRange b2IRectangleFromAwtRectangle( const ::com::sun::star::awt::Rectangle& ); // Geometry comparisons // =================================================================== - bool RealSize2DAreEqual( const ::com::sun::star::geometry::RealSize2D& rA, const ::com::sun::star::geometry::RealSize2D& rB ); - bool RealPoint2DAreEqual( const ::com::sun::star::geometry::RealPoint2D& rA, const ::com::sun::star::geometry::RealPoint2D& rB ); - bool RealRectangle2DAreEqual( const ::com::sun::star::geometry::RealRectangle2D& rA, const ::com::sun::star::geometry::RealRectangle2D& rB ); - bool RealRectangle3DAreEqual( const ::com::sun::star::geometry::RealRectangle3D& rA, const ::com::sun::star::geometry::RealRectangle3D& rB ); - bool AffineMatrix2DAreEqual( const ::com::sun::star::geometry::AffineMatrix2D& rA, const ::com::sun::star::geometry::AffineMatrix2D& rB ); + BASEGFX_DLLPUBLIC bool RealSize2DAreEqual( const ::com::sun::star::geometry::RealSize2D& rA, const ::com::sun::star::geometry::RealSize2D& rB ); + BASEGFX_DLLPUBLIC bool RealPoint2DAreEqual( const ::com::sun::star::geometry::RealPoint2D& rA, const ::com::sun::star::geometry::RealPoint2D& rB ); + BASEGFX_DLLPUBLIC bool RealRectangle2DAreEqual( const ::com::sun::star::geometry::RealRectangle2D& rA, const ::com::sun::star::geometry::RealRectangle2D& rB ); + BASEGFX_DLLPUBLIC bool RealRectangle3DAreEqual( const ::com::sun::star::geometry::RealRectangle3D& rA, const ::com::sun::star::geometry::RealRectangle3D& rB ); + BASEGFX_DLLPUBLIC bool AffineMatrix2DAreEqual( const ::com::sun::star::geometry::AffineMatrix2D& rA, const ::com::sun::star::geometry::AffineMatrix2D& rB ); - bool IntegerSize2DAreEqual( const ::com::sun::star::geometry::IntegerSize2D& rA, const ::com::sun::star::geometry::IntegerSize2D& rB ); - bool IntegerPoint2DAreEqual( const ::com::sun::star::geometry::IntegerPoint2D& rA, const ::com::sun::star::geometry::IntegerPoint2D& rB ); - bool IntegerRectangle2DAreEqual( const ::com::sun::star::geometry::IntegerRectangle2D& rA, const ::com::sun::star::geometry::IntegerRectangle2D& rB ); + BASEGFX_DLLPUBLIC bool IntegerSize2DAreEqual( const ::com::sun::star::geometry::IntegerSize2D& rA, const ::com::sun::star::geometry::IntegerSize2D& rB ); + BASEGFX_DLLPUBLIC bool IntegerPoint2DAreEqual( const ::com::sun::star::geometry::IntegerPoint2D& rA, const ::com::sun::star::geometry::IntegerPoint2D& rB ); + BASEGFX_DLLPUBLIC bool IntegerRectangle2DAreEqual( const ::com::sun::star::geometry::IntegerRectangle2D& rA, const ::com::sun::star::geometry::IntegerRectangle2D& rB ); - bool awtSizeAreEqual( const ::com::sun::star::awt::Size& rA, const ::com::sun::star::awt::Size& rB ); - bool awtPointAreEqual( const ::com::sun::star::awt::Point& rA, const ::com::sun::star::awt::Point& rB ); - bool awtRectangleAreEqual( const ::com::sun::star::awt::Rectangle& rA, const ::com::sun::star::awt::Rectangle& rB ); + BASEGFX_DLLPUBLIC bool awtSizeAreEqual( const ::com::sun::star::awt::Size& rA, const ::com::sun::star::awt::Size& rB ); + BASEGFX_DLLPUBLIC bool awtPointAreEqual( const ::com::sun::star::awt::Point& rA, const ::com::sun::star::awt::Point& rB ); + BASEGFX_DLLPUBLIC bool awtRectangleAreEqual( const ::com::sun::star::awt::Rectangle& rA, const ::com::sun::star::awt::Rectangle& rB ); /** Return smalltest integer range, which completely contains given floating point range. @@ -202,7 +203,7 @@ namespace basegfx @return the closest integer range, which completely contains rRange. */ - ::basegfx::B2IRange b2ISurroundingRangeFromB2DRange( const ::basegfx::B2DRange& rRange ); + BASEGFX_DLLPUBLIC ::basegfx::B2IRange b2ISurroundingRangeFromB2DRange( const ::basegfx::B2DRange& rRange ); /** Return smalltest B2DRange with integer values, which completely contains given floating point range. @@ -213,7 +214,7 @@ namespace basegfx @return the closest B2DRange with integer coordinates, which completely contains rRange. */ - ::basegfx::B2DRange b2DSurroundingIntegerRangeFromB2DRange( const ::basegfx::B2DRange& rRange ); + BASEGFX_DLLPUBLIC ::basegfx::B2DRange b2DSurroundingIntegerRangeFromB2DRange( const ::basegfx::B2DRange& rRange ); } } diff --git a/basegfx/inc/basegfx/tools/debugplotter.hxx b/basegfx/inc/basegfx/tools/debugplotter.hxx index ece104af3553..9070efd1d9f2 100644 --- a/basegfx/inc/basegfx/tools/debugplotter.hxx +++ b/basegfx/inc/basegfx/tools/debugplotter.hxx @@ -38,6 +38,7 @@ #include <vector> #include <utility> #include <iostream> +#include <basegfx/basegfxdllapi.h> namespace basegfx @@ -54,7 +55,7 @@ namespace basegfx To be able to generate one coherent block of output, this class delays actual writing to its destructor */ - class DebugPlotter : private ::boost::noncopyable + class BASEGFX_DLLPUBLIC DebugPlotter : private ::boost::noncopyable { public: /** Create new debug output object diff --git a/basegfx/inc/basegfx/tools/gradienttools.hxx b/basegfx/inc/basegfx/tools/gradienttools.hxx index 2f436fa1d717..6894aa2ff3ce 100644 --- a/basegfx/inc/basegfx/tools/gradienttools.hxx +++ b/basegfx/inc/basegfx/tools/gradienttools.hxx @@ -33,6 +33,7 @@ #include <basegfx/vector/b2dvector.hxx> #include <basegfx/matrix/b2dhommatrix.hxx> #include <basegfx/numeric/ftools.hxx> +#include <basegfx/basegfxdllapi.h> #include <vector> #include <algorithm> @@ -45,7 +46,7 @@ namespace basegfx 1.2-compatible gradients. Use the createXXXODFGradientInfo() methods below for initializing from ODF attributes. */ - struct ODFGradientInfo + struct BASEGFX_DLLPUBLIC ODFGradientInfo { /** transformation mapping from [0,1]^2 texture coordinate space to [0,1]^2 shape coordinate space @@ -97,7 +98,7 @@ namespace basegfx @param fAngle Gradient angle (from ODF) */ - ODFGradientInfo& createLinearODFGradientInfo(ODFGradientInfo& o_rGradientInfo, + BASEGFX_DLLPUBLIC ODFGradientInfo& createLinearODFGradientInfo(ODFGradientInfo& o_rGradientInfo, const B2DRange& rTargetArea, sal_uInt32 nSteps, double fBorder, @@ -156,7 +157,7 @@ namespace basegfx @param fAngle Gradient angle (from ODF) */ - ODFGradientInfo& createAxialODFGradientInfo(ODFGradientInfo& o_rGradientInfo, + BASEGFX_DLLPUBLIC ODFGradientInfo& createAxialODFGradientInfo(ODFGradientInfo& o_rGradientInfo, const B2DRange& rTargetArea, sal_uInt32 nSteps, double fBorder, @@ -211,7 +212,7 @@ namespace basegfx @param fAngle Gradient angle (from ODF) */ - ODFGradientInfo& createRadialODFGradientInfo(ODFGradientInfo& o_rGradientInfo, + BASEGFX_DLLPUBLIC ODFGradientInfo& createRadialODFGradientInfo(ODFGradientInfo& o_rGradientInfo, const B2DRange& rTargetArea, const B2DVector& rOffset, sal_uInt32 nSteps, @@ -270,7 +271,7 @@ namespace basegfx @param fAngle Gradient angle (from ODF) */ - ODFGradientInfo& createEllipticalODFGradientInfo(ODFGradientInfo& o_rGradientInfo, + BASEGFX_DLLPUBLIC ODFGradientInfo& createEllipticalODFGradientInfo(ODFGradientInfo& o_rGradientInfo, const B2DRange& rTargetArea, const B2DVector& rOffset, sal_uInt32 nSteps, @@ -318,7 +319,7 @@ namespace basegfx @param fAngle Gradient angle (from ODF) */ - ODFGradientInfo& createSquareODFGradientInfo(ODFGradientInfo& o_rGradientInfo, + BASEGFX_DLLPUBLIC ODFGradientInfo& createSquareODFGradientInfo(ODFGradientInfo& o_rGradientInfo, const B2DRange& rTargetArea, const B2DVector& rOffset, sal_uInt32 nSteps, @@ -379,7 +380,7 @@ namespace basegfx @param fAngle Gradient angle (from ODF) */ - ODFGradientInfo& createRectangularODFGradientInfo(ODFGradientInfo& o_rGradientInfo, + BASEGFX_DLLPUBLIC ODFGradientInfo& createRectangularODFGradientInfo(ODFGradientInfo& o_rGradientInfo, const B2DRange& rTargetArea, const B2DVector& rOffset, sal_uInt32 nSteps, diff --git a/basegfx/inc/basegfx/tools/keystoplerp.hxx b/basegfx/inc/basegfx/tools/keystoplerp.hxx index a54b3485b1a1..e1cd1fe12f5d 100644 --- a/basegfx/inc/basegfx/tools/keystoplerp.hxx +++ b/basegfx/inc/basegfx/tools/keystoplerp.hxx @@ -33,6 +33,7 @@ #include <basegfx/numeric/ftools.hxx> #include <vector> +#include <basegfx/basegfxdllapi.h> namespace com{ namespace sun{ namespace star{ namespace uno { template<typename T> class Sequence; @@ -53,7 +54,7 @@ namespace basegfx then calculate the relative alpha between the two buckets found. */ - class KeyStopLerp + class BASEGFX_DLLPUBLIC KeyStopLerp { public: typedef std::pair<std::ptrdiff_t,double> ResultType; diff --git a/basegfx/inc/basegfx/tools/tools.hxx b/basegfx/inc/basegfx/tools/tools.hxx index 896fd22c162d..d7c10b4bf9ac 100644 --- a/basegfx/inc/basegfx/tools/tools.hxx +++ b/basegfx/inc/basegfx/tools/tools.hxx @@ -29,6 +29,7 @@ #define _BGFX_TOOLS_TOOLS_HXX #include <sal/types.h> +#include <basegfx/basegfxdllapi.h> namespace basegfx { @@ -57,7 +58,7 @@ namespace basegfx @return true, when at least part of the line is visible after the clip, false otherwise */ - bool liangBarskyClip2D( ::basegfx::B2DPoint& io_rStart, + BASEGFX_DLLPUBLIC bool liangBarskyClip2D( ::basegfx::B2DPoint& io_rStart, ::basegfx::B2DPoint& io_rEnd, const ::basegfx::B2DRange& rClipRect ); @@ -119,7 +120,7 @@ namespace basegfx @param rFitTarget The rectangle to fit the parallelogram into. */ - void infiniteLineFromParallelogram( ::basegfx::B2DPoint& io_rLeftTop, + BASEGFX_DLLPUBLIC void infiniteLineFromParallelogram( ::basegfx::B2DPoint& io_rLeftTop, ::basegfx::B2DPoint& io_rLeftBottom, ::basegfx::B2DPoint& io_rRightTop, ::basegfx::B2DPoint& io_rRightBottom, diff --git a/basegfx/inc/basegfx/tools/unopolypolygon.hxx b/basegfx/inc/basegfx/tools/unopolypolygon.hxx index 8a4044e1ca4b..ab7afe42b135 100755 --- a/basegfx/inc/basegfx/tools/unopolypolygon.hxx +++ b/basegfx/inc/basegfx/tools/unopolypolygon.hxx @@ -35,6 +35,7 @@ #include <com/sun/star/rendering/XLinePolyPolygon2D.hpp> #include <com/sun/star/rendering/XBezierPolyPolygon2D.hpp> #include <basegfx/polygon/b2dpolypolygon.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx @@ -46,7 +47,7 @@ namespace unotools ::com::sun::star::rendering::XBezierPolyPolygon2D, ::com::sun::star::lang::XServiceInfo > UnoPolyPolygonBase; - class UnoPolyPolygon : private cppu::BaseMutex, + class BASEGFX_DLLPUBLIC UnoPolyPolygon : private cppu::BaseMutex, public UnoPolyPolygonBase { public: diff --git a/basegfx/inc/basegfx/tuple/b2dtuple.hxx b/basegfx/inc/basegfx/tuple/b2dtuple.hxx index 71dd227ac736..18e3f5c7117a 100644 --- a/basegfx/inc/basegfx/tuple/b2dtuple.hxx +++ b/basegfx/inc/basegfx/tuple/b2dtuple.hxx @@ -30,6 +30,7 @@ #include <sal/types.h> #include <basegfx/numeric/ftools.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { @@ -44,7 +45,7 @@ namespace basegfx @derive Use this class to implement Points or Vectors which are based on two double values */ - class B2DTuple + class BASEGFX_DLLPUBLIC B2DTuple { protected: double mfX; @@ -353,7 +354,7 @@ namespace basegfx @return the nearest integer for this tuple */ - B2ITuple fround(const B2DTuple& rTup); + BASEGFX_DLLPUBLIC B2ITuple fround(const B2DTuple& rTup); } // end of namespace basegfx #endif /* _BGFX_TUPLE_B2DTUPLE_HXX */ diff --git a/basegfx/inc/basegfx/tuple/b2i64tuple.hxx b/basegfx/inc/basegfx/tuple/b2i64tuple.hxx index 9c813c07a994..12830b175a36 100644 --- a/basegfx/inc/basegfx/tuple/b2i64tuple.hxx +++ b/basegfx/inc/basegfx/tuple/b2i64tuple.hxx @@ -30,6 +30,7 @@ #include <sal/types.h> #include <basegfx/tuple/b2dtuple.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx @@ -42,7 +43,7 @@ namespace basegfx @derive Use this class to implement Points or Vectors which are based on two sal_Int64 values */ - class B2I64Tuple + class BASEGFX_DLLPUBLIC B2I64Tuple { protected: sal_Int64 mnX; diff --git a/basegfx/inc/basegfx/tuple/b2ituple.hxx b/basegfx/inc/basegfx/tuple/b2ituple.hxx index da29b5509dec..1e5f1969ff92 100644 --- a/basegfx/inc/basegfx/tuple/b2ituple.hxx +++ b/basegfx/inc/basegfx/tuple/b2ituple.hxx @@ -29,7 +29,7 @@ #define _BGFX_TUPLE_B2ITUPLE_HXX #include <sal/types.h> - +#include <basegfx/basegfxdllapi.h> namespace basegfx { @@ -41,7 +41,7 @@ namespace basegfx @derive Use this class to implement Points or Vectors which are based on two sal_Int32 values */ - class B2ITuple + class BASEGFX_DLLPUBLIC B2ITuple { protected: sal_Int32 mnX; @@ -204,33 +204,33 @@ namespace basegfx class B2DTuple; - B2ITuple minimum(const B2ITuple& rTupA, const B2ITuple& rTupB); + BASEGFX_DLLPUBLIC B2ITuple minimum(const B2ITuple& rTupA, const B2ITuple& rTupB); - B2ITuple maximum(const B2ITuple& rTupA, const B2ITuple& rTupB); + BASEGFX_DLLPUBLIC B2ITuple maximum(const B2ITuple& rTupA, const B2ITuple& rTupB); - B2ITuple absolute(const B2ITuple& rTup); + BASEGFX_DLLPUBLIC B2ITuple absolute(const B2ITuple& rTup); - B2DTuple interpolate(const B2ITuple& rOld1, const B2ITuple& rOld2, double t); + BASEGFX_DLLPUBLIC B2DTuple interpolate(const B2ITuple& rOld1, const B2ITuple& rOld2, double t); - B2DTuple average(const B2ITuple& rOld1, const B2ITuple& rOld2); + BASEGFX_DLLPUBLIC B2DTuple average(const B2ITuple& rOld1, const B2ITuple& rOld2); - B2DTuple average(const B2ITuple& rOld1, const B2ITuple& rOld2, const B2ITuple& rOld3); + BASEGFX_DLLPUBLIC B2DTuple average(const B2ITuple& rOld1, const B2ITuple& rOld2, const B2ITuple& rOld3); - B2ITuple operator+(const B2ITuple& rTupA, const B2ITuple& rTupB); + BASEGFX_DLLPUBLIC B2ITuple operator+(const B2ITuple& rTupA, const B2ITuple& rTupB); - B2ITuple operator-(const B2ITuple& rTupA, const B2ITuple& rTupB); + BASEGFX_DLLPUBLIC B2ITuple operator-(const B2ITuple& rTupA, const B2ITuple& rTupB); - B2ITuple operator/(const B2ITuple& rTupA, const B2ITuple& rTupB); + BASEGFX_DLLPUBLIC B2ITuple operator/(const B2ITuple& rTupA, const B2ITuple& rTupB); - B2ITuple operator*(const B2ITuple& rTupA, const B2ITuple& rTupB); + BASEGFX_DLLPUBLIC B2ITuple operator*(const B2ITuple& rTupA, const B2ITuple& rTupB); - B2ITuple operator*(const B2ITuple& rTup, sal_Int32 t); + BASEGFX_DLLPUBLIC B2ITuple operator*(const B2ITuple& rTup, sal_Int32 t); - B2ITuple operator*(sal_Int32 t, const B2ITuple& rTup); + BASEGFX_DLLPUBLIC B2ITuple operator*(sal_Int32 t, const B2ITuple& rTup); - B2ITuple operator/(const B2ITuple& rTup, sal_Int32 t); + BASEGFX_DLLPUBLIC B2ITuple operator/(const B2ITuple& rTup, sal_Int32 t); - B2ITuple operator/(sal_Int32 t, const B2ITuple& rTup); + BASEGFX_DLLPUBLIC B2ITuple operator/(sal_Int32 t, const B2ITuple& rTup); } // end of namespace basegfx diff --git a/basegfx/inc/basegfx/tuple/b3dtuple.hxx b/basegfx/inc/basegfx/tuple/b3dtuple.hxx index 11fb797ff0ff..f0947c227612 100644 --- a/basegfx/inc/basegfx/tuple/b3dtuple.hxx +++ b/basegfx/inc/basegfx/tuple/b3dtuple.hxx @@ -30,6 +30,7 @@ #include <sal/types.h> #include <basegfx/numeric/ftools.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { @@ -44,7 +45,7 @@ namespace basegfx @derive Use this class to implement Points or Vectors which are based on three double values */ - class B3DTuple + class BASEGFX_DLLPUBLIC B3DTuple { protected: double mfX; @@ -427,7 +428,7 @@ namespace basegfx @return the nearest integer for this tuple */ - B3ITuple fround(const B3DTuple& rTup); + BASEGFX_DLLPUBLIC B3ITuple fround(const B3DTuple& rTup); } // end of namespace basegfx #endif /* _BGFX_TUPLE_B3DTUPLE_HXX */ diff --git a/basegfx/inc/basegfx/tuple/b3i64tuple.hxx b/basegfx/inc/basegfx/tuple/b3i64tuple.hxx index a2d754fe4f79..a4e6de8e02f7 100644 --- a/basegfx/inc/basegfx/tuple/b3i64tuple.hxx +++ b/basegfx/inc/basegfx/tuple/b3i64tuple.hxx @@ -30,6 +30,7 @@ #include <sal/types.h> #include <basegfx/tuple/b3dtuple.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx @@ -42,7 +43,7 @@ namespace basegfx @derive Use this class to implement Points or Vectors which are based on three sal_Int64 values */ - class B3I64Tuple + class BASEGFX_DLLPUBLIC B3I64Tuple { protected: sal_Int64 mnX; diff --git a/basegfx/inc/basegfx/tuple/b3ituple.hxx b/basegfx/inc/basegfx/tuple/b3ituple.hxx index 644ae07b6545..4de03f5f1227 100644 --- a/basegfx/inc/basegfx/tuple/b3ituple.hxx +++ b/basegfx/inc/basegfx/tuple/b3ituple.hxx @@ -30,7 +30,7 @@ #include <sal/types.h> #include <basegfx/tuple/b3dtuple.hxx> - +#include <basegfx/basegfxdllapi.h> namespace basegfx { @@ -42,7 +42,7 @@ namespace basegfx @derive Use this class to implement Points or Vectors which are based on three sal_Int32 values */ - class B3ITuple + class BASEGFX_DLLPUBLIC B3ITuple { protected: sal_Int32 mnX; diff --git a/basegfx/inc/basegfx/vector/b2dvector.hxx b/basegfx/inc/basegfx/vector/b2dvector.hxx index e4cd8f3f179a..60c600d3f9f5 100644 --- a/basegfx/inc/basegfx/vector/b2dvector.hxx +++ b/basegfx/inc/basegfx/vector/b2dvector.hxx @@ -31,6 +31,7 @@ #include <basegfx/tuple/b2dtuple.hxx> #include <basegfx/vector/b2ivector.hxx> #include <basegfx/vector/b2enums.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { @@ -45,7 +46,7 @@ namespace basegfx @see B2DTuple */ - class B2DVector : public ::basegfx::B2DTuple + class BASEGFX_DLLPUBLIC B2DVector : public ::basegfx::B2DTuple { public: /** Create a 2D Vector @@ -209,7 +210,7 @@ namespace basegfx @return The mathematical Orientation of the two involved 2D Vectors */ - B2VectorOrientation getOrientation( const B2DVector& rVecA, const B2DVector& rVecB ); + BASEGFX_DLLPUBLIC B2VectorOrientation getOrientation( const B2DVector& rVecA, const B2DVector& rVecB ); /** Calculate a perpendicular 2D Vector to the given one @@ -221,7 +222,7 @@ namespace basegfx @return A 2D Vector perpendicular to the one given in parameter rVec */ - B2DVector getPerpendicular( const B2DVector& rNormalizedVec ); + BASEGFX_DLLPUBLIC B2DVector getPerpendicular( const B2DVector& rNormalizedVec ); /** Calculate a perpendicular 2D Vector to the given one, normalize the given one as preparation @@ -232,7 +233,7 @@ namespace basegfx @return A normalized 2D Vector perpendicular to the one given in parameter rVec */ - B2DVector getNormalizedPerpendicular( const B2DVector& rVec ); + BASEGFX_DLLPUBLIC B2DVector getNormalizedPerpendicular( const B2DVector& rVec ); /** Test two vectors which need not to be normalized for parallelism @@ -246,21 +247,21 @@ namespace basegfx bool if the two values are parallel. Also true if one of the vectors is empty. */ - bool areParallel( const B2DVector& rVecA, const B2DVector& rVecB ); + BASEGFX_DLLPUBLIC bool areParallel( const B2DVector& rVecA, const B2DVector& rVecB ); /** Transform vector by given transformation matrix. Since this is a vector, translational components of the matrix are disregarded. */ - B2DVector operator*( const B2DHomMatrix& rMat, const B2DVector& rVec ); + BASEGFX_DLLPUBLIC B2DVector operator*( const B2DHomMatrix& rMat, const B2DVector& rVec ); /** Test continuity between given vectors. The two given vectors are assumed to describe control points on a common point. Calculate if there is a continuity between them. */ - B2VectorContinuity getContinuity( const B2DVector& rBackVector, const B2DVector& rForwardVector ); + BASEGFX_DLLPUBLIC B2VectorContinuity getContinuity( const B2DVector& rBackVector, const B2DVector& rForwardVector ); } // end of namespace basegfx diff --git a/basegfx/inc/basegfx/vector/b2ivector.hxx b/basegfx/inc/basegfx/vector/b2ivector.hxx index 9e2fe1009841..ebc81f83b51a 100644 --- a/basegfx/inc/basegfx/vector/b2ivector.hxx +++ b/basegfx/inc/basegfx/vector/b2ivector.hxx @@ -30,6 +30,7 @@ #include <basegfx/tuple/b2ituple.hxx> #include <basegfx/vector/b2enums.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { @@ -44,7 +45,7 @@ namespace basegfx @see B2ITuple */ - class B2IVector : public ::basegfx::B2ITuple + class BASEGFX_DLLPUBLIC B2IVector : public ::basegfx::B2ITuple { public: /** Create a 2D Vector @@ -185,7 +186,7 @@ namespace basegfx @return The mathematical Orientation of the two involved 2D Vectors */ - B2VectorOrientation getOrientation( const B2IVector& rVecA, const B2IVector& rVecB ); + BASEGFX_DLLPUBLIC B2VectorOrientation getOrientation( const B2IVector& rVecA, const B2IVector& rVecB ); /** Calculate a perpendicular 2D Vector to the given one @@ -195,7 +196,7 @@ namespace basegfx @return A 2D Vector perpendicular to the one given in parameter rVec */ - B2IVector getPerpendicular( const B2IVector& rVec ); + BASEGFX_DLLPUBLIC B2IVector getPerpendicular( const B2IVector& rVec ); /** Test two vectors which need not to be normalized for parallelism @@ -209,21 +210,21 @@ namespace basegfx bool if the two values are parallel. Also true if one of the vectors is empty. */ - bool areParallel( const B2IVector& rVecA, const B2IVector& rVecB ); + BASEGFX_DLLPUBLIC bool areParallel( const B2IVector& rVecA, const B2IVector& rVecB ); /** Transform vector by given transformation matrix. Since this is a vector, translational components of the matrix are disregarded. */ - B2IVector operator*( const B2DHomMatrix& rMat, const B2IVector& rVec ); + BASEGFX_DLLPUBLIC B2IVector operator*( const B2DHomMatrix& rMat, const B2IVector& rVec ); /** Test continuity between given vectors. The two given vectors are assumed to describe control points on a common point. Calculate if there is a continuity between them. */ - B2VectorContinuity getContinuity( const B2IVector& rBackVector, const B2IVector& rForwardVector ); + BASEGFX_DLLPUBLIC B2VectorContinuity getContinuity( const B2IVector& rBackVector, const B2IVector& rForwardVector ); } // end of namespace basegfx diff --git a/basegfx/inc/basegfx/vector/b3dvector.hxx b/basegfx/inc/basegfx/vector/b3dvector.hxx index c4c329881170..790343c14032 100644 --- a/basegfx/inc/basegfx/vector/b3dvector.hxx +++ b/basegfx/inc/basegfx/vector/b3dvector.hxx @@ -29,6 +29,7 @@ #define _BGFX_VECTOR_B3DVECTOR_HXX #include <basegfx/tuple/b3dtuple.hxx> +#include <basegfx/basegfxdllapi.h> ////////////////////////////////////////////////////////////////////////////// @@ -45,7 +46,7 @@ namespace basegfx @see B3DTuple */ - class B3DVector : public ::basegfx::B3DTuple + class BASEGFX_DLLPUBLIC B3DVector : public ::basegfx::B3DTuple { public: /** Create a 3D Vector @@ -305,14 +306,14 @@ namespace basegfx bool if the two values are parallel. Also true if one of the vectors is empty. */ - bool areParallel( const B3DVector& rVecA, const B3DVector& rVecB ); + BASEGFX_DLLPUBLIC bool areParallel( const B3DVector& rVecA, const B3DVector& rVecB ); /** Transform vector by given transformation matrix. Since this is a vector, translational components of the matrix are disregarded. */ - B3DVector operator*( const B3DHomMatrix& rMat, const B3DVector& rVec ); + BASEGFX_DLLPUBLIC B3DVector operator*( const B3DHomMatrix& rMat, const B3DVector& rVec ); /** Calculate the Cross Product of two 3D Vectors diff --git a/basegfx/inc/basegfx/vector/b3ivector.hxx b/basegfx/inc/basegfx/vector/b3ivector.hxx index b4900989cc06..367da44ac3e9 100644 --- a/basegfx/inc/basegfx/vector/b3ivector.hxx +++ b/basegfx/inc/basegfx/vector/b3ivector.hxx @@ -29,6 +29,7 @@ #define _BGFX_VECTOR_B3IVECTOR_HXX #include <basegfx/tuple/b3ituple.hxx> +#include <basegfx/basegfxdllapi.h> namespace basegfx { @@ -43,7 +44,7 @@ namespace basegfx @see B3ITuple */ - class B3IVector : public ::basegfx::B3ITuple + class BASEGFX_DLLPUBLIC B3IVector : public ::basegfx::B3ITuple { public: /** Create a 3D Vector @@ -233,7 +234,7 @@ namespace basegfx Since this is a vector, translational components of the matrix are disregarded. */ - B3IVector operator*( const B3DHomMatrix& rMat, const B3IVector& rVec ); + BASEGFX_DLLPUBLIC B3IVector operator*( const B3DHomMatrix& rMat, const B3IVector& rVec ); /** Calculate the Cross Product of two 3D Vectors |