| /************************************************************** |
| * |
| * 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& rTargetRange, |
| const basegfx::BColor& rStart, |
| const basegfx::BColor& rEnd, |
| sal_uInt32 /* nSteps */, |
| double fBorder) |
| : GeoTexSvx(), |
| maGradientInfo(), |
| maTargetRange(rTargetRange), |
| 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 |
| && maTargetRange == pCompare->maTargetRange |
| && mfBorder == pCompare->mfBorder); |
| } |
| } // end of namespace texture |
| } // end of namespace drawinglayer |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| namespace drawinglayer |
| { |
| namespace texture |
| { |
| GeoTexSvxGradientLinear::GeoTexSvxGradientLinear( |
| const basegfx::B2DRange& rTargetRange, |
| const basegfx::BColor& rStart, |
| const basegfx::BColor& rEnd, |
| sal_uInt32 nSteps, |
| double fBorder, |
| double fAngle) |
| : GeoTexSvxGradient(rTargetRange, rStart, rEnd, nSteps, fBorder) |
| { |
| maGradientInfo = basegfx::tools::createLinearODFGradientInfo( |
| rTargetRange, |
| nSteps, |
| fBorder, |
| fAngle); |
| } |
| |
| GeoTexSvxGradientLinear::~GeoTexSvxGradientLinear() |
| { |
| } |
| |
| void GeoTexSvxGradientLinear::appendTransformationsAndColors( |
| std::vector< B2DHomMatrixAndBColor >& rEntries, |
| basegfx::BColor& rOutmostColor) |
| { |
| rOutmostColor = maStart; |
| |
| 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); |
| // optimized below... |
| // |
| // basegfx::B2DHomMatrix aNew; |
| // aNew.scale(0.5, 0.5); |
| // aNew.translate(0.5, 0.5); |
| // aNew.scale(1.0, (1.0 - fPos)); |
| // aNew.translate(0.0, fPos); |
| // aNew = maGradientInfo.getTextureTransform() * aNew; |
| aB2DHomMatrixAndBColor.maB2DHomMatrix = maGradientInfo.getTextureTransform() * |
| basegfx::tools::createScaleTranslateB2DHomMatrix(0.5, 0.5 * (1.0 - fPos), 0.5, 0.5 * (1.0 + fPos)); |
| 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& rTargetRange, |
| const basegfx::BColor& rStart, |
| const basegfx::BColor& rEnd, |
| sal_uInt32 nSteps, |
| double fBorder, |
| double fAngle) |
| : GeoTexSvxGradient(rTargetRange, rStart, rEnd, nSteps, fBorder) |
| { |
| maGradientInfo = basegfx::tools::createAxialODFGradientInfo( |
| rTargetRange, |
| nSteps, |
| fBorder, |
| fAngle); |
| } |
| |
| GeoTexSvxGradientAxial::~GeoTexSvxGradientAxial() |
| { |
| } |
| |
| void GeoTexSvxGradientAxial::appendTransformationsAndColors( |
| std::vector< B2DHomMatrixAndBColor >& rEntries, |
| basegfx::BColor& rOutmostColor) |
| { |
| rOutmostColor = 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); |
| // optimized below... |
| // |
| // basegfx::B2DHomMatrix aNew; |
| // aNew.scale(0.50, (1.0 - fPos)); |
| // aNew.translate(0.5, 0.0); |
| // aNew = maGradientInfo.getTextureTransform() * aNew; |
| aB2DHomMatrixAndBColor.maB2DHomMatrix = maGradientInfo.getTextureTransform() * |
| basegfx::tools::createScaleTranslateB2DHomMatrix(0.5, 1.0 - (fStripeWidth * a), 0.5, 0.0); |
| 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& rTargetRange, |
| const basegfx::BColor& rStart, |
| const basegfx::BColor& rEnd, |
| sal_uInt32 nSteps, |
| double fBorder, |
| double fOffsetX, |
| double fOffsetY) |
| : GeoTexSvxGradient(rTargetRange, rStart, rEnd, nSteps, fBorder) |
| { |
| maGradientInfo = basegfx::tools::createRadialODFGradientInfo( |
| rTargetRange, |
| basegfx::B2DVector(fOffsetX,fOffsetY), |
| nSteps, |
| fBorder); |
| } |
| |
| GeoTexSvxGradientRadial::~GeoTexSvxGradientRadial() |
| { |
| } |
| |
| void GeoTexSvxGradientRadial::appendTransformationsAndColors( |
| std::vector< B2DHomMatrixAndBColor >& rEntries, |
| basegfx::BColor& rOutmostColor) |
| { |
| rOutmostColor = 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& rTargetRange, |
| const basegfx::BColor& rStart, |
| const basegfx::BColor& rEnd, |
| sal_uInt32 nSteps, |
| double fBorder, |
| double fOffsetX, |
| double fOffsetY, |
| double fAngle) |
| : GeoTexSvxGradient(rTargetRange, rStart, rEnd, nSteps, fBorder) |
| { |
| maGradientInfo = basegfx::tools::createEllipticalODFGradientInfo( |
| rTargetRange, |
| basegfx::B2DVector(fOffsetX,fOffsetY), |
| nSteps, |
| fBorder, |
| fAngle); |
| } |
| |
| GeoTexSvxGradientElliptical::~GeoTexSvxGradientElliptical() |
| { |
| } |
| |
| void GeoTexSvxGradientElliptical::appendTransformationsAndColors( |
| std::vector< B2DHomMatrixAndBColor >& rEntries, |
| basegfx::BColor& rOutmostColor) |
| { |
| rOutmostColor = 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& rTargetRange, |
| const basegfx::BColor& rStart, |
| const basegfx::BColor& rEnd, |
| sal_uInt32 nSteps, |
| double fBorder, |
| double fOffsetX, |
| double fOffsetY, |
| double fAngle) |
| : GeoTexSvxGradient(rTargetRange, rStart, rEnd, nSteps, fBorder) |
| { |
| maGradientInfo = basegfx::tools::createSquareODFGradientInfo( |
| rTargetRange, |
| basegfx::B2DVector(fOffsetX,fOffsetY), |
| nSteps, |
| fBorder, |
| fAngle); |
| } |
| |
| GeoTexSvxGradientSquare::~GeoTexSvxGradientSquare() |
| { |
| } |
| |
| void GeoTexSvxGradientSquare::appendTransformationsAndColors( |
| std::vector< B2DHomMatrixAndBColor >& rEntries, |
| basegfx::BColor& rOutmostColor) |
| { |
| rOutmostColor = 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& rTargetRange, |
| const basegfx::BColor& rStart, |
| const basegfx::BColor& rEnd, |
| sal_uInt32 nSteps, |
| double fBorder, |
| double fOffsetX, |
| double fOffsetY, |
| double fAngle) |
| : GeoTexSvxGradient(rTargetRange, rStart, rEnd, nSteps, fBorder) |
| { |
| maGradientInfo = basegfx::tools::createRectangularODFGradientInfo( |
| rTargetRange, |
| basegfx::B2DVector(fOffsetX,fOffsetY), |
| nSteps, |
| fBorder, |
| fAngle); |
| } |
| |
| GeoTexSvxGradientRect::~GeoTexSvxGradientRect() |
| { |
| } |
| |
| void GeoTexSvxGradientRect::appendTransformationsAndColors( |
| std::vector< B2DHomMatrixAndBColor >& rEntries, |
| basegfx::BColor& rOutmostColor) |
| { |
| rOutmostColor = 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& rTargetRange, |
| double fDistance, |
| double fAngle) |
| : mfDistance(0.1), |
| mfAngle(fAngle), |
| mnSteps(10L) |
| { |
| double fTargetSizeX(rTargetRange.getWidth()); |
| double fTargetSizeY(rTargetRange.getHeight()); |
| double fTargetOffsetX(rTargetRange.getMinX()); |
| double fTargetOffsetY(rTargetRange.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 |
| && maTextureTransform == pCompare->maTextureTransform |
| && mfDistance == pCompare->mfDistance |
| && mfAngle == pCompare->mfAngle |
| && mnSteps == pCompare->mnSteps); |
| } |
| |
| void GeoTexSvxHatch::appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices) |
| { |
| for(sal_uInt32 a(1L); a < mnSteps; a++) |
| { |
| // create matrix |
| const double fOffset(mfDistance * (double)a); |
| basegfx::B2DHomMatrix aNew; |
| aNew.set(1, 2, fOffset); |
| rMatrices.push_back(maTextureTransform * aNew); |
| } |
| } |
| |
| 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 |
