/************************************************************** * * 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 #include #include #include ////////////////////////////////////////////////////////////////////////////// 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(floor(fStartX / fWidth)) + 1); nPosX -= nDiff; fStartX -= nDiff * fWidth; } if(basegfx::fTools::less(fStartX + fWidth, 0.0)) { const sal_Int32 nDiff(static_cast(floor(-fStartX / fWidth))); nPosX += nDiff; fStartX += nDiff * fWidth; } if(basegfx::fTools::more(fStartY, 0.0)) { const sal_Int32 nDiff(static_cast(floor(fStartY / fHeight)) + 1); nPosY -= nDiff; fStartY -= nDiff * fHeight; } if(basegfx::fTools::less(fStartY + fHeight, 0.0)) { const sal_Int32 nDiff(static_cast(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