mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

callcatcher: Remove unused code

Browse Source
This commit is contained in:
August Sodora 2012-01-07 20:41:09 -05:00
parent dd7eeed27d
commit bc2a59e09d
11 changed files with 2 additions and 622 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
basegfx/inc/basegfx/curve/b2dcubicbezier.hxx
View File

@ -55,7 +55,6 @@ namespace basegfx
public:
B2DCubicBezier();
B2DCubicBezier(const B2DCubicBezier& rBezier);
B2DCubicBezier(const B2DPoint& rStart, const B2DPoint& rEnd);
B2DCubicBezier(const B2DPoint& rStart, const B2DPoint& rControlPointA, const B2DPoint& rControlPointB, const B2DPoint& rEnd);
~B2DCubicBezier();

13
basegfx/inc/basegfx/matrix/b2dhommatrix.hxx
View File

@ -56,9 +56,6 @@ namespace basegfx
*/
B2DHomMatrix(double f_0x0, double f_0x1, double f_0x2, double f_1x0, double f_1x1, double f_1x2);
/// unshare this matrix with all internally shared instances
void makeUnique();
double get(sal_uInt16 nRow, sal_uInt16 nColumn) const;
void set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue);
@ -78,15 +75,6 @@ namespace basegfx
bool isInvertible() const;
bool invert();
bool isNormalized() const;
void normalize();
double determinant() const;
double trace() const;
void transpose();
void rotate(double fRadiant);
void translate(double fX, double fY);
@ -97,7 +85,6 @@ namespace basegfx
void shearX(double fSx);
void shearY(double fSy);
B2DHomMatrix& operator+=(const B2DHomMatrix& rMat);
B2DHomMatrix& operator-=(const B2DHomMatrix& rMat);

40
basegfx/inc/basegfx/range/b2dpolyrange.hxx
View File

@ -67,14 +67,9 @@ namespace basegfx
/** Create a multi range with exactly one containing range
*/
explicit B2DPolyRange( const ElementType& rElement );
B2DPolyRange( const B2DRange& rRange, B2VectorOrientation eOrient );
B2DPolyRange( const B2DPolyRange& );
B2DPolyRange& operator=( const B2DPolyRange& );
/// unshare this poly-range with all internally shared instances
void makeUnique();
bool operator==(const B2DPolyRange&) const;
bool operator!=(const B2DPolyRange&) const;
@ -82,44 +77,15 @@ namespace basegfx
sal_uInt32 count() const;
ElementType getElement(sal_uInt32 nIndex) const;
void setElement(sal_uInt32 nIndex, const ElementType& rElement );
void setElement(sal_uInt32 nIndex, const B2DRange& rRange, B2VectorOrientation eOrient );
// insert/append a single range
void insertElement(sal_uInt32 nIndex, const ElementType& rElement, sal_uInt32 nCount = 1);
void insertElement(sal_uInt32 nIndex, const B2DRange& rRange, B2VectorOrientation eOrient, sal_uInt32 nCount = 1);
void appendElement(const ElementType& rElement, sal_uInt32 nCount = 1);
void appendElement(const B2DRange& rRange, B2VectorOrientation eOrient, sal_uInt32 nCount = 1);
// insert/append multiple ranges
void insertPolyRange(sal_uInt32 nIndex, const B2DPolyRange&);
void appendPolyRange(const B2DPolyRange&);
void remove(sal_uInt32 nIndex, sal_uInt32 nCount = 1);
void clear();
// flip range orientations - converts holes to solids, and vice versa
void flip();
/** Get overall range
@return
The union range of all contained ranges
*/
B2DRange getBounds() const;
/** Test whether given tuple is inside one or more of the
included ranges. Does *not* use overall range, but checks
individually.
*/
bool isInside( const B2DTuple& rTuple ) const;
/** Test whether given range is inside one or more of the
included ranges. Does *not* use overall range, but checks
individually.
*/
bool isInside( const B2DRange& rRange ) const;
/** Test whether given range overlaps one or more of the
included ranges. Does *not* use overall range, but checks
individually.
@ -130,12 +96,6 @@ namespace basegfx
*/
B2DPolyPolygon solveCrossovers() const;
// element iterators (same iterator validity conditions as for vector)
const B2DRange* begin() const;
const B2DRange* end() const;
B2DRange* begin();
B2DRange* end();
private:
o3tl::cow_wrapper< ImplB2DPolyRange > mpImpl;
};

17
basegfx/inc/basegfx/tools/b2dclipstate.hxx
View File

@ -69,21 +69,12 @@ namespace basegfx
B2DClipState();
~B2DClipState();
B2DClipState( const B2DClipState& );
explicit B2DClipState( const B2DRange& );
explicit B2DClipState( const B2DPolygon& );
explicit B2DClipState( const B2DPolyPolygon& );
B2DClipState& operator=( const B2DClipState& );
/// unshare this poly-range with all internally shared instances
void makeUnique();
/// Set clip to 'null' - nothing is visible
void makeNull();
/// returns true when clip is 'null' - nothing is visible
bool isNull() const;
/// Set clip 'cleared' - everything is visible
void makeClear();
/// returns true when clip is 'cleared' - everything is visible
bool isCleared() const;
@ -91,24 +82,16 @@ namespace basegfx
bool operator!=(const B2DClipState&) const;
void unionRange(const B2DRange& );
void unionPolygon(const B2DPolygon& );
void unionPolyPolygon(const B2DPolyPolygon& );
void unionClipState(const B2DClipState& );
void intersectRange(const B2DRange& );
void intersectPolygon(const B2DPolygon& );
void intersectPolyPolygon(const B2DPolyPolygon& );
void intersectClipState(const B2DClipState& );
void subtractRange(const B2DRange& );
void subtractPolygon(const B2DPolygon& );
void subtractPolyPolygon(const B2DPolyPolygon& );
void subtractClipState(const B2DClipState& );
void xorRange(const B2DRange& );
void xorPolygon(const B2DPolygon& );
void xorPolyPolygon(const B2DPolyPolygon& );
void xorClipState(const B2DClipState& );
B2DPolyPolygon getClipPoly() const;
};

8
basegfx/source/curve/b2dcubicbezier.cxx
View File

@ -348,14 +348,6 @@ namespace basegfx
{
}
B2DCubicBezier::B2DCubicBezier(const B2DPoint& rStart, const B2DPoint& rEnd)
: maStartPoint(rStart),
maEndPoint(rEnd),
maControlPointA(rStart),
maControlPointB(rEnd)
{
}
B2DCubicBezier::B2DCubicBezier(const B2DPoint& rStart, const B2DPoint& rControlPointA, const B2DPoint& rControlPointB, const B2DPoint& rEnd)
: maStartPoint(rStart),
maEndPoint(rEnd),

34
basegfx/source/matrix/b2dhommatrix.cxx
View File

@ -76,11 +76,6 @@ namespace basegfx
return *this;
}
void B2DHomMatrix::makeUnique()
{
mpImpl.make_unique();
}
double B2DHomMatrix::get(sal_uInt16 nRow, sal_uInt16 nColumn) const
{
return mpImpl->get(nRow, nColumn);
@ -142,32 +137,6 @@ namespace basegfx
return false;
}
bool B2DHomMatrix::isNormalized() const
{
return mpImpl->isNormalized();
}
void B2DHomMatrix::normalize()
{
if(!const_cast<const B2DHomMatrix*>(this)->mpImpl->isNormalized())
mpImpl->doNormalize();
}
double B2DHomMatrix::determinant() const
{
return mpImpl->doDeterminant();
}
double B2DHomMatrix::trace() const
{
return mpImpl->doTrace();
}
void B2DHomMatrix::transpose()
{
mpImpl->doTranspose();
}
B2DHomMatrix& B2DHomMatrix::operator+=(const B2DHomMatrix& rMat)
{
mpImpl->doAddMatrix(*rMat.mpImpl);
@ -449,7 +418,4 @@ namespace basegfx
}
} // end of namespace basegfx
///////////////////////////////////////////////////////////////////////////////
// eof
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

216
basegfx/source/range/b2dpolyrange.cxx
View File

@ -38,13 +38,6 @@
#include <algorithm>
#include <vector>
static basegfx::B2VectorOrientation flipOrientation(
basegfx::B2VectorOrientation eOrient)
{
return eOrient == basegfx::ORIENTATION_POSITIVE ?
basegfx::ORIENTATION_NEGATIVE : basegfx::ORIENTATION_POSITIVE;
}
namespace basegfx
{
class ImplB2DPolyRange
@ -68,12 +61,6 @@ namespace basegfx
maOrient()
{}
explicit ImplB2DPolyRange( const B2DPolyRange::ElementType& rElem ) :
maBounds( boost::get<0>(rElem) ),
maRanges( 1, boost::get<0>(rElem) ),
maOrient( 1, boost::get<1>(rElem) )
{}
explicit ImplB2DPolyRange( const B2DRange& rRange, B2VectorOrientation eOrient ) :
maBounds( rRange ),
maRanges( 1, rRange ),
@ -96,41 +83,6 @@ namespace basegfx
maOrient[nIndex]);
}
void setElement(sal_uInt32 nIndex, const B2DPolyRange::ElementType& rElement )
{
maRanges[nIndex] = boost::get<0>(rElement);
maOrient[nIndex] = boost::get<1>(rElement);
updateBounds();
}
void setElement(sal_uInt32 nIndex, const B2DRange& rRange, B2VectorOrientation eOrient )
{
maRanges[nIndex] = rRange;
maOrient[nIndex] = eOrient;
updateBounds();
}
void insertElement(sal_uInt32 nIndex, const B2DPolyRange::ElementType& rElement, sal_uInt32 nCount)
{
maRanges.insert(maRanges.begin()+nIndex, nCount, boost::get<0>(rElement));
maOrient.insert(maOrient.begin()+nIndex, nCount, boost::get<1>(rElement));
maBounds.expand(boost::get<0>(rElement));
}
void insertElement(sal_uInt32 nIndex, const B2DRange& rRange, B2VectorOrientation eOrient, sal_uInt32 nCount)
{
maRanges.insert(maRanges.begin()+nIndex, nCount, rRange);
maOrient.insert(maOrient.begin()+nIndex, nCount, eOrient);
maBounds.expand(rRange);
}
void appendElement(const B2DPolyRange::ElementType& rElement, sal_uInt32 nCount)
{
maRanges.insert(maRanges.end(), nCount, boost::get<0>(rElement));
maOrient.insert(maOrient.end(), nCount, boost::get<1>(rElement));
maBounds.expand(boost::get<0>(rElement));
}
void appendElement(const B2DRange& rRange, B2VectorOrientation eOrient, sal_uInt32 nCount)
{
maRanges.insert(maRanges.end(), nCount, rRange);
@ -138,13 +90,6 @@ namespace basegfx
maBounds.expand(rRange);
}
void insertPolyRange(sal_uInt32 nIndex, const ImplB2DPolyRange& rPolyRange)
{
maRanges.insert(maRanges.begin()+nIndex, rPolyRange.maRanges.begin(), rPolyRange.maRanges.end());
maOrient.insert(maOrient.begin()+nIndex, rPolyRange.maOrient.begin(), rPolyRange.maOrient.end());
updateBounds();
}
void appendPolyRange(const ImplB2DPolyRange& rPolyRange)
{
maRanges.insert(maRanges.end(),
@ -156,13 +101,6 @@ namespace basegfx
updateBounds();
}
void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
{
maRanges.erase(maRanges.begin()+nIndex,maRanges.begin()+nIndex+nCount);
maOrient.erase(maOrient.begin()+nIndex,maOrient.begin()+nIndex+nCount);
updateBounds();
}
void clear()
{
std::vector<B2DRange> aTmpRanges;
@ -174,37 +112,6 @@ namespace basegfx
maBounds.reset();
}
void flip()
{
std::for_each(maOrient.begin(),
maOrient.end(),
boost::bind(
&flipOrientation,
_1));
}
B2DRange getBounds() const
{
return maBounds;
}
template< typename ValueType > bool isInside( const ValueType& rValue ) const
{
if( !maBounds.isInside( rValue ) )
return false;
// cannot use boost::bind here, since isInside is overloaded.
// It is currently not possible to resolve the overload
// by considering one of the other template arguments.
std::vector<B2DRange>::const_iterator aCurr( maRanges.begin() );
const std::vector<B2DRange>::const_iterator aEnd ( maRanges.end() );
while( aCurr != aEnd )
if( aCurr->isInside( rValue ) )
return true;
return false;
}
bool overlaps( const B2DRange& rRange ) const
{
if( !maBounds.overlaps( rRange ) )
@ -223,38 +130,6 @@ namespace basegfx
return tools::solveCrossovers(maRanges,maOrient);
}
const B2DRange* begin() const
{
if(maRanges.empty())
return 0;
else
return &maRanges.front();
}
const B2DRange* end() const
{
if(maRanges.empty())
return 0;
else
return (&maRanges.back())+1;
}
B2DRange* begin()
{
if(maRanges.empty())
return 0;
else
return &maRanges.front();
}
B2DRange* end()
{
if(maRanges.empty())
return 0;
else
return (&maRanges.back())+1;
}
private:
B2DRange maBounds;
std::vector<B2DRange> maRanges;
@ -268,14 +143,6 @@ namespace basegfx
B2DPolyRange::~B2DPolyRange()
{}
B2DPolyRange::B2DPolyRange( const ElementType& rElem ) :
mpImpl( ImplB2DPolyRange( rElem ) )
{}
B2DPolyRange::B2DPolyRange( const B2DRange& rRange, B2VectorOrientation eOrient ) :
mpImpl( ImplB2DPolyRange( rRange, eOrient ) )
{}
B2DPolyRange::B2DPolyRange( const B2DPolyRange& rRange ) :
mpImpl( rRange.mpImpl )
{}
@ -286,11 +153,6 @@ namespace basegfx
return *this;
}
void B2DPolyRange::makeUnique()
{
mpImpl.make_unique();
}
bool B2DPolyRange::operator==(const B2DPolyRange& rRange) const
{
if(mpImpl.same_object(rRange.mpImpl))
@ -314,76 +176,21 @@ namespace basegfx
return mpImpl->getElement(nIndex);
}
void B2DPolyRange::setElement(sal_uInt32 nIndex, const ElementType& rElement )
{
mpImpl->setElement(nIndex, rElement);
}
void B2DPolyRange::setElement(sal_uInt32 nIndex, const B2DRange& rRange, B2VectorOrientation eOrient )
{
mpImpl->setElement(nIndex, rRange, eOrient );
}
void B2DPolyRange::insertElement(sal_uInt32 nIndex, const ElementType& rElement, sal_uInt32 nCount)
{
mpImpl->insertElement(nIndex, rElement, nCount );
}
void B2DPolyRange::insertElement(sal_uInt32 nIndex, const B2DRange& rRange, B2VectorOrientation eOrient, sal_uInt32 nCount)
{
mpImpl->insertElement(nIndex, rRange, eOrient, nCount );
}
void B2DPolyRange::appendElement(const ElementType& rElement, sal_uInt32 nCount)
{
mpImpl->appendElement(rElement, nCount);
}
void B2DPolyRange::appendElement(const B2DRange& rRange, B2VectorOrientation eOrient, sal_uInt32 nCount)
{
mpImpl->appendElement(rRange, eOrient, nCount );
}
void B2DPolyRange::insertPolyRange(sal_uInt32 nIndex, const B2DPolyRange& rRange)
{
mpImpl->insertPolyRange(nIndex, *rRange.mpImpl);
}
void B2DPolyRange::appendPolyRange(const B2DPolyRange& rRange)
{
mpImpl->appendPolyRange(*rRange.mpImpl);
}
void B2DPolyRange::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
{
mpImpl->remove(nIndex, nCount);
}
void B2DPolyRange::clear()
{
mpImpl->clear();
}
void B2DPolyRange::flip()
{
mpImpl->flip();
}
B2DRange B2DPolyRange::getBounds() const
{
return mpImpl->getBounds();
}
bool B2DPolyRange::isInside( const B2DTuple& rTuple ) const
{
return mpImpl->isInside(rTuple);
}
bool B2DPolyRange::isInside( const B2DRange& rRange ) const
{
return mpImpl->isInside(rRange);
}
bool B2DPolyRange::overlaps( const B2DRange& rRange ) const
{
return mpImpl->overlaps(rRange);
@ -393,29 +200,6 @@ namespace basegfx
{
return mpImpl->solveCrossovers();
}
const B2DRange* B2DPolyRange::begin() const
{
return mpImpl->begin();
}
const B2DRange* B2DPolyRange::end() const
{
return mpImpl->end();
}
B2DRange* B2DPolyRange::begin()
{
return mpImpl->begin();
}
B2DRange* B2DPolyRange::end()
{
return mpImpl->end();
}
} // end of namespace basegfx
// eof
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

146
basegfx/source/tools/b2dclipstate.cxx
View File

@ -53,21 +53,6 @@ namespace tools
mePendingOps(UNION)
{}
explicit ImplB2DClipState( const B2DRange& rRange ) :
maPendingPolygons(),
maPendingRanges(),
maClipPoly(
tools::createPolygonFromRect(rRange)),
mePendingOps(UNION)
{}
explicit ImplB2DClipState( const B2DPolygon& rPoly ) :
maPendingPolygons(),
maPendingRanges(),
maClipPoly(rPoly),
mePendingOps(UNION)
{}
explicit ImplB2DClipState( const B2DPolyPolygon& rPoly ) :
maPendingPolygons(),
maPendingRanges(),
@ -82,14 +67,6 @@ namespace tools
&& !maPendingRanges.count();
}
void makeClear()
{
maPendingPolygons.clear();
maPendingRanges.clear();
maClipPoly.clear();
mePendingOps = UNION;
}
bool isNullClipPoly() const
{
return maClipPoly.count() == 1
@ -183,14 +160,6 @@ namespace tools
addRange(rRange,UNION);
}
void unionPolygon(const B2DPolygon& rPoly)
{
if( isCleared() )
return;
addPolygon(rPoly,UNION);
}
void unionPolyPolygon(const B2DPolyPolygon& rPolyPoly)
{
if( isCleared() )
@ -199,14 +168,6 @@ namespace tools
addPolyPolygon(rPolyPoly,UNION);
}
void unionClipState(const ImplB2DClipState& rOther)
{
if( isCleared() )
return;
addClipState(rOther, UNION);
}
void intersectRange(const B2DRange& rRange)
{
if( isNull() )
@ -215,14 +176,6 @@ namespace tools
addRange(rRange,INTERSECT);
}
void intersectPolygon(const B2DPolygon& rPoly)
{
if( isNull() )
return;
addPolygon(rPoly,INTERSECT);
}
void intersectPolyPolygon(const B2DPolyPolygon& rPolyPoly)
{
if( isNull() )
@ -231,14 +184,6 @@ namespace tools
addPolyPolygon(rPolyPoly,INTERSECT);
}
void intersectClipState(const ImplB2DClipState& rOther)
{
if( isNull() )
return;
addClipState(rOther, INTERSECT);
}
void subtractRange(const B2DRange& rRange )
{
if( isNull() )
@ -247,14 +192,6 @@ namespace tools
addRange(rRange,SUBTRACT);
}
void subtractPolygon(const B2DPolygon& rPoly)
{
if( isNull() )
return;
addPolygon(rPoly,SUBTRACT);
}
void subtractPolyPolygon(const B2DPolyPolygon& rPolyPoly)
{
if( isNull() )
@ -263,34 +200,16 @@ namespace tools
addPolyPolygon(rPolyPoly,SUBTRACT);
}
void subtractClipState(const ImplB2DClipState& rOther)
{
if( isNull() )
return;
addClipState(rOther, SUBTRACT);
}
void xorRange(const B2DRange& rRange)
{
addRange(rRange,XOR);
}
void xorPolygon(const B2DPolygon& rPoly)
{
addPolygon(rPoly,XOR);
}
void xorPolyPolygon(const B2DPolyPolygon& rPolyPoly)
{
addPolyPolygon(rPolyPoly,XOR);
}
void xorClipState(const ImplB2DClipState& rOther)
{
addClipState(rOther, XOR);
}
B2DPolyPolygon getClipPoly() const
{
commitPendingRanges();
@ -511,14 +430,6 @@ namespace tools
mpImpl(rOrig.mpImpl)
{}
B2DClipState::B2DClipState( const B2DRange& rRange ) :
mpImpl( ImplB2DClipState(rRange) )
{}
B2DClipState::B2DClipState( const B2DPolygon& rPoly ) :
mpImpl( ImplB2DClipState(rPoly) )
{}
B2DClipState::B2DClipState( const B2DPolyPolygon& rPolyPoly ) :
mpImpl( ImplB2DClipState(rPolyPoly) )
{}
@ -529,26 +440,11 @@ namespace tools
return *this;
}
void B2DClipState::makeUnique()
{
mpImpl.make_unique();
}
void B2DClipState::makeNull()
{
mpImpl->makeNull();
}
bool B2DClipState::isNull() const
{
return mpImpl->isNull();
}
void B2DClipState::makeClear()
{
mpImpl->makeClear();
}
bool B2DClipState::isCleared() const
{
return mpImpl->isCleared();
@ -572,81 +468,41 @@ namespace tools
mpImpl->unionRange(rRange);
}
void B2DClipState::unionPolygon(const B2DPolygon& rPoly)
{
mpImpl->unionPolygon(rPoly);
}
void B2DClipState::unionPolyPolygon(const B2DPolyPolygon& rPolyPoly)
{
mpImpl->unionPolyPolygon(rPolyPoly);
}
void B2DClipState::unionClipState(const B2DClipState& rState)
{
mpImpl->unionClipState(*rState.mpImpl);
}
void B2DClipState::intersectRange(const B2DRange& rRange)
{
mpImpl->intersectRange(rRange);
}
void B2DClipState::intersectPolygon(const B2DPolygon& rPoly)
{
mpImpl->intersectPolygon(rPoly);
}
void B2DClipState::intersectPolyPolygon(const B2DPolyPolygon& rPolyPoly)
{
mpImpl->intersectPolyPolygon(rPolyPoly);
}
void B2DClipState::intersectClipState(const B2DClipState& rState)
{
mpImpl->intersectClipState(*rState.mpImpl);
}
void B2DClipState::subtractRange(const B2DRange& rRange)
{
mpImpl->subtractRange(rRange);
}
void B2DClipState::subtractPolygon(const B2DPolygon& rPoly)
{
mpImpl->subtractPolygon(rPoly);
}
void B2DClipState::subtractPolyPolygon(const B2DPolyPolygon& rPolyPoly)
{
mpImpl->subtractPolyPolygon(rPolyPoly);
}
void B2DClipState::subtractClipState(const B2DClipState& rState)
{
mpImpl->subtractClipState(*rState.mpImpl);
}
void B2DClipState::xorRange(const B2DRange& rRange)
{
mpImpl->xorRange(rRange);
}
void B2DClipState::xorPolygon(const B2DPolygon& rPoly)
{
mpImpl->xorPolygon(rPoly);
}
void B2DClipState::xorPolyPolygon(const B2DPolyPolygon& rPolyPoly)
{
mpImpl->xorPolyPolygon(rPolyPoly);
}
void B2DClipState::xorClipState(const B2DClipState& rState)
{
mpImpl->xorClipState(*rState.mpImpl);
}
B2DPolyPolygon B2DClipState::getClipPoly() const
{
return mpImpl->getClipPoly();
@ -655,6 +511,4 @@ namespace tools
} // end of namespace tools
} // end of namespace basegfx
// eof
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

88
filter/source/svg/b2dellipse.cxx
View File

@ -26,82 +26,11 @@
*/
#include "b2dellipse.hxx"
#include <osl/diagnose.h>
#include <basegfx/point/b2dpoint.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <rtl/instance.hxx>
#include <boost/scoped_ptr.hpp>
#include <vector>
#include <algorithm>
class ImplB2DEllipse
{
basegfx::B2DPoint maCenter;
basegfx::B2DTuple maRadius;
public:
ImplB2DEllipse()
: maCenter(0.0f, 0.0f),
maRadius(0.0f, 0.0f)
{}
ImplB2DEllipse(const ImplB2DEllipse& rToBeCopied)
: maCenter(rToBeCopied.maCenter),
maRadius(rToBeCopied.maRadius)
{}
ImplB2DEllipse& operator=( const ImplB2DEllipse& rToBeCopied )
{
maCenter = rToBeCopied.maCenter;
maRadius = rToBeCopied.maRadius;
return *this;
}
bool isEqual(const ImplB2DEllipse& rCandidate) const
{
return (maCenter == rCandidate.maCenter)
&& (maRadius == rCandidate.maRadius);
}
basegfx::B2DPoint getCenter() const
{
return maCenter;
}
void setCenter(const basegfx::B2DPoint& rCenter)
{
maCenter = rCenter;
}
basegfx::B2DTuple getRadius() const
{
return maRadius;
}
void setRadius(const basegfx::B2DTuple& rRadius)
{
maRadius = rRadius;
}
void transform(const basegfx::B2DHomMatrix& /* rMatrix */)
{
}
};
//////////////////////////////////////////////////////////////////////////////
namespace basegfx
{
B2DEllipse::B2DEllipse()
{}
B2DEllipse::B2DEllipse(const basegfx::B2DPoint& rCenter, const basegfx::B2DTuple& rRadius)
: maCenter(rCenter), maRadius(rRadius)
{
@ -126,27 +55,10 @@ namespace basegfx
return maCenter;
}
void B2DEllipse::setB2DEllipseCenter(const basegfx::B2DPoint& rCenter)
{
maCenter = rCenter;
}
basegfx::B2DTuple B2DEllipse::getB2DEllipseRadius() const
{
return maRadius;
}
void B2DEllipse::setB2DEllipseRadius(const basegfx::B2DTuple& rRadius)
{
maRadius = rRadius;
}
void B2DEllipse::transform(const basegfx::B2DHomMatrix& /* rMatrix */)
{
}
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
// eof
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

19
filter/source/svg/b2dellipse.hxx
View File

@ -37,10 +37,6 @@
#include <basegfx/vector/b2enums.hxx>
//////////////////////////////////////////////////////////////////////////////
// predeclarations
class ImplB2DEllipse;
namespace basegfx
{
class B2DPoint;
@ -48,18 +44,15 @@ namespace basegfx
class B2DHomMatrix;
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
namespace basegfx
{
class B2DEllipse
{
private:
basegfx::B2DPoint maCenter;
basegfx::B2DTuple maRadius;
const basegfx::B2DPoint maCenter;
const basegfx::B2DTuple maRadius;
public:
B2DEllipse();
B2DEllipse(const B2DEllipse& rEllipse);
B2DEllipse(const basegfx::B2DPoint& rCenter, const basegfx::B2DTuple& rRadius);
~B2DEllipse();
@ -73,18 +66,10 @@ namespace basegfx
// Coordinate interface
basegfx::B2DPoint getB2DEllipseCenter() const;
void setB2DEllipseCenter(const basegfx::B2DPoint& rCenter);
basegfx::B2DTuple getB2DEllipseRadius() const;
void setB2DEllipseRadius(const basegfx::B2DTuple& rRadius);
// apply transformation given in matrix form to the Ellipse
void transform(const basegfx::B2DHomMatrix& rMatrix);
};
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
#endif /* _BASEGFX_B2DELLIPSE_HXX */
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

42
unusedcode.easy
View File

@ -1037,38 +1037,9 @@ avmedia::priv::MediaWindowBaseImpl::setStopTime(double)
basebmp::BitmapDevice::setDamageTracker(boost::shared_ptr<basebmp::IBitmapDeviceDamageTracker> const&)
basebmp::debugDump(boost::shared_ptr<basebmp::BitmapDevice> const&, std::basic_ostream<char, std::char_traits<char> >&)
basegfx::B1DRange::B1DRange(basegfx::B1IRange const&)
basegfx::B2DCubicBezier::B2DCubicBezier(basegfx::B2DPoint const&, basegfx::B2DPoint const&)
basegfx::B2DEllipse::B2DEllipse()
basegfx::B2DEllipse::setB2DEllipseCenter(basegfx::B2DPoint const&)
basegfx::B2DEllipse::setB2DEllipseRadius(basegfx::B2DTuple const&)
basegfx::B2DEllipse::transform(basegfx::B2DHomMatrix const&)
basegfx::B2DHomMatrix::determinant() const
basegfx::B2DHomMatrix::isNormalized() const
basegfx::B2DHomMatrix::makeUnique()
basegfx::B2DHomMatrix::normalize()
basegfx::B2DHomMatrix::trace() const
basegfx::B2DHomMatrix::transpose()
basegfx::B2DHomPoint::getB2DPoint() const
basegfx::B2DHomPoint::setX(double)
basegfx::B2DHomPoint::setY(double)
basegfx::B2DPolyRange::B2DPolyRange(basegfx::B2DRange const&, basegfx::B2VectorOrientation)
basegfx::B2DPolyRange::B2DPolyRange(boost::tuples::tuple<basegfx::B2DRange, basegfx::B2VectorOrientation, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type> const&)
basegfx::B2DPolyRange::appendElement(boost::tuples::tuple<basegfx::B2DRange, basegfx::B2VectorOrientation, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type> const&, unsigned int)
basegfx::B2DPolyRange::begin()
basegfx::B2DPolyRange::begin() const
basegfx::B2DPolyRange::end()
basegfx::B2DPolyRange::end() const
basegfx::B2DPolyRange::flip()
basegfx::B2DPolyRange::getBounds() const
basegfx::B2DPolyRange::insertElement(unsigned int, basegfx::B2DRange const&, basegfx::B2VectorOrientation, unsigned int)
basegfx::B2DPolyRange::insertElement(unsigned int, boost::tuples::tuple<basegfx::B2DRange, basegfx::B2VectorOrientation, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type> const&, unsigned int)
basegfx::B2DPolyRange::insertPolyRange(unsigned int, basegfx::B2DPolyRange const&)
basegfx::B2DPolyRange::isInside(basegfx::B2DRange const&) const
basegfx::B2DPolyRange::isInside(basegfx::B2DTuple const&) const
basegfx::B2DPolyRange::makeUnique()
basegfx::B2DPolyRange::remove(unsigned int, unsigned int)
basegfx::B2DPolyRange::setElement(unsigned int, basegfx::B2DRange const&, basegfx::B2VectorOrientation)
basegfx::B2DPolyRange::setElement(unsigned int, boost::tuples::tuple<basegfx::B2DRange, basegfx::B2VectorOrientation, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type> const&)
basegfx::B2DPolygon::insert(unsigned int, basegfx::B2DPolygon const&, unsigned int, unsigned int)
basegfx::B2DPolygon::isBezierSegment(unsigned int) const
basegfx::B2DPolygon::resetControlPoints(unsigned int)
@ -1110,19 +1081,6 @@ basegfx::maximum(basegfx::B2DHomPoint const&, basegfx::B2DHomPoint const&)
basegfx::maximum(basegfx::B2ITuple const&, basegfx::B2ITuple const&)
basegfx::minimum(basegfx::B2DHomPoint const&, basegfx::B2DHomPoint const&)
basegfx::minimum(basegfx::B2ITuple const&, basegfx::B2ITuple const&)
basegfx::tools::B2DClipState::B2DClipState(basegfx::B2DPolygon const&)
basegfx::tools::B2DClipState::B2DClipState(basegfx::B2DRange const&)
basegfx::tools::B2DClipState::intersectClipState(basegfx::tools::B2DClipState const&)
basegfx::tools::B2DClipState::intersectPolygon(basegfx::B2DPolygon const&)
basegfx::tools::B2DClipState::isNull() const
basegfx::tools::B2DClipState::makeClear()
basegfx::tools::B2DClipState::makeUnique()
basegfx::tools::B2DClipState::subtractClipState(basegfx::tools::B2DClipState const&)
basegfx::tools::B2DClipState::subtractPolygon(basegfx::B2DPolygon const&)
basegfx::tools::B2DClipState::unionClipState(basegfx::tools::B2DClipState const&)
basegfx::tools::B2DClipState::unionPolygon(basegfx::B2DPolygon const&)
basegfx::tools::B2DClipState::xorClipState(basegfx::tools::B2DClipState const&)
basegfx::tools::B2DClipState::xorPolygon(basegfx::B2DPolygon const&)
basegfx::tools::addPointsAtCuts(basegfx::B2DPolyPolygon const&, basegfx::B2DPoint const&, basegfx::B2DPoint const&)
basegfx::tools::addPointsAtCuts(basegfx::B2DPolyPolygon const&, basegfx::B2DPolyPolygon const&)
basegfx::tools::addPointsAtCuts(basegfx::B2DPolyPolygon const&, bool)