| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_drawinglayer.hxx" | |
| #include <drawinglayer/texture/texture.hxx> | |
| #include <basegfx/numeric/ftools.hxx> | |
| #include <basegfx/tools/gradienttools.hxx> | |
| #include <basegfx/matrix/b2dhommatrixtools.hxx> | |
| ////////////////////////////////////////////////////////////////////////////// | |
| namespace drawinglayer | |
| { | |
| namespace texture | |
| { | |
| GeoTexSvx::GeoTexSvx() | |
| { | |
| } | |
| GeoTexSvx::~GeoTexSvx() | |
| { | |
| } | |
| bool GeoTexSvx::operator==(const GeoTexSvx& /*rGeoTexSvx*/) const | |
| { | |
| // default implementation says yes (no data -> no difference) | |
| return true; | |
| } | |
| void GeoTexSvx::modifyBColor(const basegfx::B2DPoint& /*rUV*/, basegfx::BColor& rBColor, double& /*rfOpacity*/) const | |
| { | |
| // base implementation creates random color (for testing only, may also be pure virtual) | |
| rBColor.setRed((rand() & 0x7fff) / 32767.0); | |
| rBColor.setGreen((rand() & 0x7fff) / 32767.0); | |
| rBColor.setBlue((rand() & 0x7fff) / 32767.0); | |
| } | |
| void GeoTexSvx::modifyOpacity(const basegfx::B2DPoint& rUV, double& rfOpacity) const | |
| { | |
| // base implementation uses inverse of luminance of solved color (for testing only, may also be pure virtual) | |
| basegfx::BColor aBaseColor; | |
| modifyBColor(rUV, aBaseColor, rfOpacity); | |
| rfOpacity = 1.0 - aBaseColor.luminance(); | |
| } | |
| } // end of namespace texture | |
| } // end of namespace drawinglayer | |
| ////////////////////////////////////////////////////////////////////////////// | |
| namespace drawinglayer | |
| { | |
| namespace texture | |
| { | |
| GeoTexSvxGradient::GeoTexSvxGradient( | |
| const basegfx::B2DRange& rDefinitionRange, | |
| const basegfx::BColor& rStart, | |
| const basegfx::BColor& rEnd, | |
| sal_uInt32 /* nSteps */, | |
| double fBorder) | |
| : GeoTexSvx(), | |
| maGradientInfo(), | |
| maDefinitionRange(rDefinitionRange), | |
| maStart(rStart), | |
| maEnd(rEnd), | |
| mfBorder(fBorder) | |
| { | |
| } | |
| GeoTexSvxGradient::~GeoTexSvxGradient() | |
| { | |
| } | |
| bool GeoTexSvxGradient::operator==(const GeoTexSvx& rGeoTexSvx) const | |
| { | |
| const GeoTexSvxGradient* pCompare = dynamic_cast< const GeoTexSvxGradient* >(&rGeoTexSvx); | |
| return (pCompare | |
| && maGradientInfo == pCompare->maGradientInfo | |
| && maDefinitionRange == pCompare->maDefinitionRange | |
| && mfBorder == pCompare->mfBorder); | |
| } | |
| } // end of namespace texture | |
| } // end of namespace drawinglayer | |
| ////////////////////////////////////////////////////////////////////////////// | |
| namespace drawinglayer | |
| { | |
| namespace texture | |
| { | |
| GeoTexSvxGradientLinear::GeoTexSvxGradientLinear( | |
| const basegfx::B2DRange& rDefinitionRange, | |
| const basegfx::B2DRange& rOutputRange, | |
| const basegfx::BColor& rStart, | |
| const basegfx::BColor& rEnd, | |
| sal_uInt32 nSteps, | |
| double fBorder, | |
| double fAngle) | |
| : GeoTexSvxGradient(rDefinitionRange, rStart, rEnd, nSteps, fBorder), | |
| mfUnitMinX(0.0), | |
| mfUnitWidth(1.0), | |
| mfUnitMaxY(1.0) | |
| { | |
| maGradientInfo = basegfx::tools::createLinearODFGradientInfo( | |
| rDefinitionRange, | |
| nSteps, | |
| fBorder, | |
| fAngle); | |
| if(rDefinitionRange != rOutputRange) | |
| { | |
| basegfx::B2DRange aInvOutputRange(rOutputRange); | |
| aInvOutputRange.transform(maGradientInfo.getBackTextureTransform()); | |
| mfUnitMinX = aInvOutputRange.getMinX(); | |
| mfUnitWidth = aInvOutputRange.getWidth(); | |
| mfUnitMaxY = aInvOutputRange.getMaxY(); | |
| } | |
| } | |
| GeoTexSvxGradientLinear::~GeoTexSvxGradientLinear() | |
| { | |
| } | |
| void GeoTexSvxGradientLinear::appendTransformationsAndColors( | |
| std::vector< B2DHomMatrixAndBColor >& rEntries, | |
| basegfx::BColor& rOuterColor) | |
| { | |
| rOuterColor = maStart; | |
| if(maGradientInfo.getSteps()) | |
| { | |
| const double fStripeWidth(1.0 / maGradientInfo.getSteps()); | |
| B2DHomMatrixAndBColor aB2DHomMatrixAndBColor; | |
| basegfx::B2DHomMatrix aPattern; | |
| // bring from unit circle [-1, -1, 1, 1] to unit range [0, 0, 1, 1] | |
| aPattern.scale(0.5, 0.5); | |
| aPattern.translate(0.5, 0.5); | |
| // scale and translate in X | |
| aPattern.scale(mfUnitWidth, 1.0); | |
| aPattern.translate(mfUnitMinX, 0.0); | |
| for(sal_uInt32 a(1); a < maGradientInfo.getSteps(); a++) | |
| { | |
| const double fPos(fStripeWidth * a); | |
| basegfx::B2DHomMatrix aNew(aPattern); | |
| // scale and translate in Y | |
| double fHeight(1.0 - fPos); | |
| if(a + 1 == maGradientInfo.getSteps() && mfUnitMaxY > 1.0) | |
| { | |
| fHeight += mfUnitMaxY - 1.0; | |
| } | |
| aNew.scale(1.0, fHeight); | |
| aNew.translate(0.0, fPos); | |
| // set at target | |
| aB2DHomMatrixAndBColor.maB2DHomMatrix = maGradientInfo.getTextureTransform() * aNew; | |
| // interpolate and set color | |
| aB2DHomMatrixAndBColor.maBColor = interpolate(maStart, maEnd, double(a) / double(maGradientInfo.getSteps() - 1)); | |
| rEntries.push_back(aB2DHomMatrixAndBColor); | |
| } | |
| } | |
| } | |
| void GeoTexSvxGradientLinear::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const | |
| { | |
| const double fScaler(basegfx::tools::getLinearGradientAlpha(rUV, maGradientInfo)); | |
| rBColor = basegfx::interpolate(maStart, maEnd, fScaler); | |
| } | |
| } // end of namespace texture | |
| } // end of namespace drawinglayer | |
| ////////////////////////////////////////////////////////////////////////////// | |
| namespace drawinglayer | |
| { | |
| namespace texture | |
| { | |
| GeoTexSvxGradientAxial::GeoTexSvxGradientAxial( | |
| const basegfx::B2DRange& rDefinitionRange, | |
| const basegfx::B2DRange& rOutputRange, | |
| const basegfx::BColor& rStart, | |
| const basegfx::BColor& rEnd, | |
| sal_uInt32 nSteps, | |
| double fBorder, | |
| double fAngle) | |
| : GeoTexSvxGradient(rDefinitionRange, rStart, rEnd, nSteps, fBorder), | |
| mfUnitMinX(0.0), | |
| mfUnitWidth(1.0) | |
| { | |
| maGradientInfo = basegfx::tools::createAxialODFGradientInfo( | |
| rDefinitionRange, | |
| nSteps, | |
| fBorder, | |
| fAngle); | |
| if(rDefinitionRange != rOutputRange) | |
| { | |
| basegfx::B2DRange aInvOutputRange(rOutputRange); | |
| aInvOutputRange.transform(maGradientInfo.getBackTextureTransform()); | |
| mfUnitMinX = aInvOutputRange.getMinX(); | |
| mfUnitWidth = aInvOutputRange.getWidth(); | |
| } | |
| } | |
| GeoTexSvxGradientAxial::~GeoTexSvxGradientAxial() | |
| { | |
| } | |
| void GeoTexSvxGradientAxial::appendTransformationsAndColors( | |
| std::vector< B2DHomMatrixAndBColor >& rEntries, | |
| basegfx::BColor& rOuterColor) | |
| { | |
| rOuterColor = maEnd; | |
| if(maGradientInfo.getSteps()) | |
| { | |
| const double fStripeWidth(1.0 / maGradientInfo.getSteps()); | |
| B2DHomMatrixAndBColor aB2DHomMatrixAndBColor; | |
| for(sal_uInt32 a(1); a < maGradientInfo.getSteps(); a++) | |
| { | |
| const double fPos(fStripeWidth * a); | |
| basegfx::B2DHomMatrix aNew; | |
| // bring in X from unit circle [-1, -1, 1, 1] to unit range [0, 0, 1, 1] | |
| aNew.scale(0.5, 1.0); | |
| aNew.translate(0.5, 0.0); | |
| // scale/translate in X | |
| aNew.scale(mfUnitWidth, 1.0); | |
| aNew.translate(mfUnitMinX, 0.0); | |
| // already centerd in Y on X-Axis, just scale in Y | |
| aNew.scale(1.0, 1.0 - fPos); | |
| // set at target | |
| aB2DHomMatrixAndBColor.maB2DHomMatrix = maGradientInfo.getTextureTransform() * aNew; | |
| // interpolate and set color | |
| aB2DHomMatrixAndBColor.maBColor = interpolate(maEnd, maStart, double(a) / double(maGradientInfo.getSteps() - 1)); | |
| rEntries.push_back(aB2DHomMatrixAndBColor); | |
| } | |
| } | |
| } | |
| void GeoTexSvxGradientAxial::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const | |
| { | |
| const double fScaler(basegfx::tools::getAxialGradientAlpha(rUV, maGradientInfo)); | |
| rBColor = basegfx::interpolate(maStart, maEnd, fScaler); | |
| } | |
| } // end of namespace texture | |
| } // end of namespace drawinglayer | |
| ////////////////////////////////////////////////////////////////////////////// | |
| namespace drawinglayer | |
| { | |
| namespace texture | |
| { | |
| GeoTexSvxGradientRadial::GeoTexSvxGradientRadial( | |
| const basegfx::B2DRange& rDefinitionRange, | |
| const basegfx::BColor& rStart, | |
| const basegfx::BColor& rEnd, | |
| sal_uInt32 nSteps, | |
| double fBorder, | |
| double fOffsetX, | |
| double fOffsetY) | |
| : GeoTexSvxGradient(rDefinitionRange, rStart, rEnd, nSteps, fBorder) | |
| { | |
| maGradientInfo = basegfx::tools::createRadialODFGradientInfo( | |
| rDefinitionRange, | |
| basegfx::B2DVector(fOffsetX,fOffsetY), | |
| nSteps, | |
| fBorder); | |
| } | |
| GeoTexSvxGradientRadial::~GeoTexSvxGradientRadial() | |
| { | |
| } | |
| void GeoTexSvxGradientRadial::appendTransformationsAndColors( | |
| std::vector< B2DHomMatrixAndBColor >& rEntries, | |
| basegfx::BColor& rOuterColor) | |
| { | |
| rOuterColor = maStart; | |
| if(maGradientInfo.getSteps()) | |
| { | |
| const double fStepSize(1.0 / maGradientInfo.getSteps()); | |
| B2DHomMatrixAndBColor aB2DHomMatrixAndBColor; | |
| for(sal_uInt32 a(1); a < maGradientInfo.getSteps(); a++) | |
| { | |
| const double fSize(1.0 - (fStepSize * a)); | |
| aB2DHomMatrixAndBColor.maB2DHomMatrix = maGradientInfo.getTextureTransform() * basegfx::tools::createScaleB2DHomMatrix(fSize, fSize); | |
| aB2DHomMatrixAndBColor.maBColor = interpolate(maStart, maEnd, double(a) / double(maGradientInfo.getSteps() - 1)); | |
| rEntries.push_back(aB2DHomMatrixAndBColor); | |
| } | |
| } | |
| } | |
| void GeoTexSvxGradientRadial::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const | |
| { | |
| const double fScaler(basegfx::tools::getRadialGradientAlpha(rUV, maGradientInfo)); | |
| rBColor = basegfx::interpolate(maStart, maEnd, fScaler); | |
| } | |
| } // end of namespace texture | |
| } // end of namespace drawinglayer | |
| ////////////////////////////////////////////////////////////////////////////// | |
| namespace drawinglayer | |
| { | |
| namespace texture | |
| { | |
| GeoTexSvxGradientElliptical::GeoTexSvxGradientElliptical( | |
| const basegfx::B2DRange& rDefinitionRange, | |
| const basegfx::BColor& rStart, | |
| const basegfx::BColor& rEnd, | |
| sal_uInt32 nSteps, | |
| double fBorder, | |
| double fOffsetX, | |
| double fOffsetY, | |
| double fAngle) | |
| : GeoTexSvxGradient(rDefinitionRange, rStart, rEnd, nSteps, fBorder) | |
| { | |
| maGradientInfo = basegfx::tools::createEllipticalODFGradientInfo( | |
| rDefinitionRange, | |
| basegfx::B2DVector(fOffsetX,fOffsetY), | |
| nSteps, | |
| fBorder, | |
| fAngle); | |
| } | |
| GeoTexSvxGradientElliptical::~GeoTexSvxGradientElliptical() | |
| { | |
| } | |
| void GeoTexSvxGradientElliptical::appendTransformationsAndColors( | |
| std::vector< B2DHomMatrixAndBColor >& rEntries, | |
| basegfx::BColor& rOuterColor) | |
| { | |
| rOuterColor = maStart; | |
| if(maGradientInfo.getSteps()) | |
| { | |
| double fWidth(1.0); | |
| double fHeight(1.0); | |
| double fIncrementX(0.0); | |
| double fIncrementY(0.0); | |
| if(maGradientInfo.getAspectRatio() > 1.0) | |
| { | |
| fIncrementY = fHeight / maGradientInfo.getSteps(); | |
| fIncrementX = fIncrementY / maGradientInfo.getAspectRatio(); | |
| } | |
| else | |
| { | |
| fIncrementX = fWidth / maGradientInfo.getSteps(); | |
| fIncrementY = fIncrementX * maGradientInfo.getAspectRatio(); | |
| } | |
| B2DHomMatrixAndBColor aB2DHomMatrixAndBColor; | |
| for(sal_uInt32 a(1); a < maGradientInfo.getSteps(); a++) | |
| { | |
| // next step | |
| fWidth -= fIncrementX; | |
| fHeight -= fIncrementY; | |
| aB2DHomMatrixAndBColor.maB2DHomMatrix = maGradientInfo.getTextureTransform() * basegfx::tools::createScaleB2DHomMatrix(fWidth, fHeight); | |
| aB2DHomMatrixAndBColor.maBColor = interpolate(maStart, maEnd, double(a) / double(maGradientInfo.getSteps() - 1)); | |
| rEntries.push_back(aB2DHomMatrixAndBColor); | |
| } | |
| } | |
| } | |
| void GeoTexSvxGradientElliptical::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const | |
| { | |
| const double fScaler(basegfx::tools::getEllipticalGradientAlpha(rUV, maGradientInfo)); | |
| rBColor = basegfx::interpolate(maStart, maEnd, fScaler); | |
| } | |
| } // end of namespace texture | |
| } // end of namespace drawinglayer | |
| ////////////////////////////////////////////////////////////////////////////// | |
| namespace drawinglayer | |
| { | |
| namespace texture | |
| { | |
| GeoTexSvxGradientSquare::GeoTexSvxGradientSquare( | |
| const basegfx::B2DRange& rDefinitionRange, | |
| const basegfx::BColor& rStart, | |
| const basegfx::BColor& rEnd, | |
| sal_uInt32 nSteps, | |
| double fBorder, | |
| double fOffsetX, | |
| double fOffsetY, | |
| double fAngle) | |
| : GeoTexSvxGradient(rDefinitionRange, rStart, rEnd, nSteps, fBorder) | |
| { | |
| maGradientInfo = basegfx::tools::createSquareODFGradientInfo( | |
| rDefinitionRange, | |
| basegfx::B2DVector(fOffsetX,fOffsetY), | |
| nSteps, | |
| fBorder, | |
| fAngle); | |
| } | |
| GeoTexSvxGradientSquare::~GeoTexSvxGradientSquare() | |
| { | |
| } | |
| void GeoTexSvxGradientSquare::appendTransformationsAndColors( | |
| std::vector< B2DHomMatrixAndBColor >& rEntries, | |
| basegfx::BColor& rOuterColor) | |
| { | |
| rOuterColor = maStart; | |
| if(maGradientInfo.getSteps()) | |
| { | |
| const double fStepSize(1.0 / maGradientInfo.getSteps()); | |
| B2DHomMatrixAndBColor aB2DHomMatrixAndBColor; | |
| for(sal_uInt32 a(1); a < maGradientInfo.getSteps(); a++) | |
| { | |
| const double fSize(1.0 - (fStepSize * a)); | |
| aB2DHomMatrixAndBColor.maB2DHomMatrix = maGradientInfo.getTextureTransform() * basegfx::tools::createScaleB2DHomMatrix(fSize, fSize); | |
| aB2DHomMatrixAndBColor.maBColor = interpolate(maStart, maEnd, double(a) / double(maGradientInfo.getSteps() - 1)); | |
| rEntries.push_back(aB2DHomMatrixAndBColor); | |
| } | |
| } | |
| } | |
| void GeoTexSvxGradientSquare::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const | |
| { | |
| const double fScaler(basegfx::tools::getSquareGradientAlpha(rUV, maGradientInfo)); | |
| rBColor = basegfx::interpolate(maStart, maEnd, fScaler); | |
| } | |
| } // end of namespace texture | |
| } // end of namespace drawinglayer | |
| ////////////////////////////////////////////////////////////////////////////// | |
| namespace drawinglayer | |
| { | |
| namespace texture | |
| { | |
| GeoTexSvxGradientRect::GeoTexSvxGradientRect( | |
| const basegfx::B2DRange& rDefinitionRange, | |
| const basegfx::BColor& rStart, | |
| const basegfx::BColor& rEnd, | |
| sal_uInt32 nSteps, | |
| double fBorder, | |
| double fOffsetX, | |
| double fOffsetY, | |
| double fAngle) | |
| : GeoTexSvxGradient(rDefinitionRange, rStart, rEnd, nSteps, fBorder) | |
| { | |
| maGradientInfo = basegfx::tools::createRectangularODFGradientInfo( | |
| rDefinitionRange, | |
| basegfx::B2DVector(fOffsetX,fOffsetY), | |
| nSteps, | |
| fBorder, | |
| fAngle); | |
| } | |
| GeoTexSvxGradientRect::~GeoTexSvxGradientRect() | |
| { | |
| } | |
| void GeoTexSvxGradientRect::appendTransformationsAndColors( | |
| std::vector< B2DHomMatrixAndBColor >& rEntries, | |
| basegfx::BColor& rOuterColor) | |
| { | |
| rOuterColor = maStart; | |
| if(maGradientInfo.getSteps()) | |
| { | |
| double fWidth(1.0); | |
| double fHeight(1.0); | |
| double fIncrementX(0.0); | |
| double fIncrementY(0.0); | |
| if(maGradientInfo.getAspectRatio() > 1.0) | |
| { | |
| fIncrementY = fHeight / maGradientInfo.getSteps(); | |
| fIncrementX = fIncrementY / maGradientInfo.getAspectRatio(); | |
| } | |
| else | |
| { | |
| fIncrementX = fWidth / maGradientInfo.getSteps(); | |
| fIncrementY = fIncrementX * maGradientInfo.getAspectRatio(); | |
| } | |
| B2DHomMatrixAndBColor aB2DHomMatrixAndBColor; | |
| for(sal_uInt32 a(1); a < maGradientInfo.getSteps(); a++) | |
| { | |
| // next step | |
| fWidth -= fIncrementX; | |
| fHeight -= fIncrementY; | |
| aB2DHomMatrixAndBColor.maB2DHomMatrix = maGradientInfo.getTextureTransform() * basegfx::tools::createScaleB2DHomMatrix(fWidth, fHeight); | |
| aB2DHomMatrixAndBColor.maBColor = interpolate(maStart, maEnd, double(a) / double(maGradientInfo.getSteps() - 1)); | |
| rEntries.push_back(aB2DHomMatrixAndBColor); | |
| } | |
| } | |
| } | |
| void GeoTexSvxGradientRect::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const | |
| { | |
| const double fScaler(basegfx::tools::getRectangularGradientAlpha(rUV, maGradientInfo)); | |
| rBColor = basegfx::interpolate(maStart, maEnd, fScaler); | |
| } | |
| } // end of namespace texture | |
| } // end of namespace drawinglayer | |
| ////////////////////////////////////////////////////////////////////////////// | |
| namespace drawinglayer | |
| { | |
| namespace texture | |
| { | |
| GeoTexSvxHatch::GeoTexSvxHatch( | |
| const basegfx::B2DRange& rDefinitionRange, | |
| const basegfx::B2DRange& rOutputRange, | |
| double fDistance, | |
| double fAngle) | |
| : maOutputRange(rOutputRange), | |
| maTextureTransform(), | |
| maBackTextureTransform(), | |
| mfDistance(0.1), | |
| mfAngle(fAngle), | |
| mnSteps(10), | |
| mbDefinitionRangeEqualsOutputRange(rDefinitionRange == rOutputRange) | |
| { | |
| double fTargetSizeX(rDefinitionRange.getWidth()); | |
| double fTargetSizeY(rDefinitionRange.getHeight()); | |
| double fTargetOffsetX(rDefinitionRange.getMinX()); | |
| double fTargetOffsetY(rDefinitionRange.getMinY()); | |
| fAngle = -fAngle; | |
| // add object expansion | |
| if(0.0 != fAngle) | |
| { | |
| const double fAbsCos(fabs(cos(fAngle))); | |
| const double fAbsSin(fabs(sin(fAngle))); | |
| const double fNewX(fTargetSizeX * fAbsCos + fTargetSizeY * fAbsSin); | |
| const double fNewY(fTargetSizeY * fAbsCos + fTargetSizeX * fAbsSin); | |
| fTargetOffsetX -= (fNewX - fTargetSizeX) / 2.0; | |
| fTargetOffsetY -= (fNewY - fTargetSizeY) / 2.0; | |
| fTargetSizeX = fNewX; | |
| fTargetSizeY = fNewY; | |
| } | |
| // add object scale before rotate | |
| maTextureTransform.scale(fTargetSizeX, fTargetSizeY); | |
| // add texture rotate after scale to keep perpendicular angles | |
| if(0.0 != fAngle) | |
| { | |
| basegfx::B2DPoint aCenter(0.5, 0.5); | |
| aCenter *= maTextureTransform; | |
| maTextureTransform = basegfx::tools::createRotateAroundPoint(aCenter, fAngle) | |
| * maTextureTransform; | |
| } | |
| // add object translate | |
| maTextureTransform.translate(fTargetOffsetX, fTargetOffsetY); | |
| // prepare height for texture | |
| const double fSteps((0.0 != fDistance) ? fTargetSizeY / fDistance : 10.0); | |
| mnSteps = basegfx::fround(fSteps + 0.5); | |
| mfDistance = 1.0 / fSteps; | |
| } | |
| GeoTexSvxHatch::~GeoTexSvxHatch() | |
| { | |
| } | |
| bool GeoTexSvxHatch::operator==(const GeoTexSvx& rGeoTexSvx) const | |
| { | |
| const GeoTexSvxHatch* pCompare = dynamic_cast< const GeoTexSvxHatch* >(&rGeoTexSvx); | |
| return (pCompare | |
| && maOutputRange == pCompare->maOutputRange | |
| && maTextureTransform == pCompare->maTextureTransform | |
| && mfDistance == pCompare->mfDistance | |
| && mfAngle == pCompare->mfAngle | |
| && mnSteps == pCompare->mnSteps); | |
| } | |
| void GeoTexSvxHatch::appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices) | |
| { | |
| if(mbDefinitionRangeEqualsOutputRange) | |
| { | |
| // simple hatch where the definition area equals the output area | |
| for(sal_uInt32 a(1); a < mnSteps; a++) | |
| { | |
| // create matrix | |
| const double fOffset(mfDistance * (double)a); | |
| basegfx::B2DHomMatrix aNew; | |
| aNew.set(1, 2, fOffset); | |
| rMatrices.push_back(maTextureTransform * aNew); | |
| } | |
| } | |
| else | |
| { | |
| // output area is different from definition area, back-transform to get | |
| // the output area in unit coordinates and fill this with hatch lines | |
| // using the settings derived from the definition area | |
| basegfx::B2DRange aBackUnitRange(maOutputRange); | |
| aBackUnitRange.transform(getBackTextureTransform()); | |
| // calculate vertical start value and a security maximum integer value to avoid death loops | |
| double fStart(basegfx::snapToNearestMultiple(aBackUnitRange.getMinY(), mfDistance)); | |
| const sal_uInt32 nNeededIntegerSteps(basegfx::fround((aBackUnitRange.getHeight() / mfDistance) + 0.5)); | |
| sal_uInt32 nMaxIntegerSteps(::std::min(nNeededIntegerSteps, sal_uInt32(10000))); | |
| while(fStart < aBackUnitRange.getMaxY() && nMaxIntegerSteps) | |
| { | |
| // create new transform for | |
| basegfx::B2DHomMatrix aNew; | |
| // adapt x scale and position | |
| //aNew.scale(aBackUnitRange.getWidth(), 1.0); | |
| //aNew.translate(aBackUnitRange.getMinX(), 0.0); | |
| aNew.set(0, 0, aBackUnitRange.getWidth()); | |
| aNew.set(0, 2, aBackUnitRange.getMinX()); | |
| // adapt y position to current step | |
| aNew.set(1, 2, fStart); | |
| //aNew.translate(0.0, fStart); | |
| // add new transformation | |
| rMatrices.push_back(maTextureTransform * aNew); | |
| // next step | |
| fStart += mfDistance; | |
| nMaxIntegerSteps--; | |
| } | |
| } | |
| } | |
| double GeoTexSvxHatch::getDistanceToHatch(const basegfx::B2DPoint& rUV) const | |
| { | |
| const basegfx::B2DPoint aCoor(getBackTextureTransform() * rUV); | |
| return fmod(aCoor.getY(), mfDistance); | |
| } | |
| const basegfx::B2DHomMatrix& GeoTexSvxHatch::getBackTextureTransform() const | |
| { | |
| if(maBackTextureTransform.isIdentity()) | |
| { | |
| const_cast< GeoTexSvxHatch* >(this)->maBackTextureTransform = maTextureTransform; | |
| const_cast< GeoTexSvxHatch* >(this)->maBackTextureTransform.invert(); | |
| } | |
| return maBackTextureTransform; | |
| } | |
| } // end of namespace texture | |
| } // end of namespace drawinglayer | |
| ////////////////////////////////////////////////////////////////////////////// | |
| namespace drawinglayer | |
| { | |
| namespace texture | |
| { | |
| GeoTexSvxTiled::GeoTexSvxTiled( | |
| const basegfx::B2DRange& rRange, | |
| double fOffsetX, | |
| double fOffsetY) | |
| : maRange(rRange), | |
| mfOffsetX(basegfx::clamp(fOffsetX, 0.0, 1.0)), | |
| mfOffsetY(basegfx::clamp(fOffsetY, 0.0, 1.0)) | |
| { | |
| if(!basegfx::fTools::equalZero(mfOffsetX)) | |
| { | |
| mfOffsetY = 0.0; | |
| } | |
| } | |
| GeoTexSvxTiled::~GeoTexSvxTiled() | |
| { | |
| } | |
| bool GeoTexSvxTiled::operator==(const GeoTexSvx& rGeoTexSvx) const | |
| { | |
| const GeoTexSvxTiled* pCompare = dynamic_cast< const GeoTexSvxTiled* >(&rGeoTexSvx); | |
| return (pCompare | |
| && maRange == pCompare->maRange | |
| && mfOffsetX == pCompare->mfOffsetX | |
| && mfOffsetY == pCompare->mfOffsetY); | |
| } | |
| void GeoTexSvxTiled::appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices) | |
| { | |
| const double fWidth(maRange.getWidth()); | |
| if(!basegfx::fTools::equalZero(fWidth)) | |
| { | |
| const double fHeight(maRange.getHeight()); | |
| if(!basegfx::fTools::equalZero(fHeight)) | |
| { | |
| double fStartX(maRange.getMinX()); | |
| double fStartY(maRange.getMinY()); | |
| sal_Int32 nPosX(0); | |
| sal_Int32 nPosY(0); | |
| if(basegfx::fTools::more(fStartX, 0.0)) | |
| { | |
| const sal_Int32 nDiff(static_cast<sal_Int32>(floor(fStartX / fWidth)) + 1); | |
| nPosX -= nDiff; | |
| fStartX -= nDiff * fWidth; | |
| } | |
| if(basegfx::fTools::less(fStartX + fWidth, 0.0)) | |
| { | |
| const sal_Int32 nDiff(static_cast<sal_Int32>(floor(-fStartX / fWidth))); | |
| nPosX += nDiff; | |
| fStartX += nDiff * fWidth; | |
| } | |
| if(basegfx::fTools::more(fStartY, 0.0)) | |
| { | |
| const sal_Int32 nDiff(static_cast<sal_Int32>(floor(fStartY / fHeight)) + 1); | |
| nPosY -= nDiff; | |
| fStartY -= nDiff * fHeight; | |
| } | |
| if(basegfx::fTools::less(fStartY + fHeight, 0.0)) | |
| { | |
| const sal_Int32 nDiff(static_cast<sal_Int32>(floor(-fStartY / fHeight))); | |
| nPosY += nDiff; | |
| fStartY += nDiff * fHeight; | |
| } | |
| if(!basegfx::fTools::equalZero(mfOffsetY)) | |
| { | |
| for(double fPosX(fStartX); basegfx::fTools::less(fPosX, 1.0); fPosX += fWidth, nPosX++) | |
| { | |
| for(double fPosY(nPosX % 2 ? fStartY - fHeight + (mfOffsetY * fHeight) : fStartY); | |
| basegfx::fTools::less(fPosY, 1.0); fPosY += fHeight) | |
| { | |
| rMatrices.push_back( | |
| basegfx::tools::createScaleTranslateB2DHomMatrix( | |
| fWidth, | |
| fHeight, | |
| fPosX, | |
| fPosY)); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| for(double fPosY(fStartY); basegfx::fTools::less(fPosY, 1.0); fPosY += fHeight, nPosY++) | |
| { | |
| for(double fPosX(nPosY % 2 ? fStartX - fWidth + (mfOffsetX * fWidth) : fStartX); | |
| basegfx::fTools::less(fPosX, 1.0); fPosX += fWidth) | |
| { | |
| rMatrices.push_back( | |
| basegfx::tools::createScaleTranslateB2DHomMatrix( | |
| fWidth, | |
| fHeight, | |
| fPosX, | |
| fPosY)); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } // end of namespace texture | |
| } // end of namespace drawinglayer | |
| ////////////////////////////////////////////////////////////////////////////// | |
| // eof |