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
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: public:
B2DCubicBezier(); B2DCubicBezier();
B2DCubicBezier(const B2DCubicBezier& rBezier); 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(const B2DPoint& rStart, const B2DPoint& rControlPointA, const B2DPoint& rControlPointB, const B2DPoint& rEnd);
~B2DCubicBezier(); ~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); 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; double get(sal_uInt16 nRow, sal_uInt16 nColumn) const;
void set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue); void set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue);
@@ -78,15 +75,6 @@ namespace basegfx
bool isInvertible() const; bool isInvertible() const;
bool invert(); bool invert();
bool isNormalized() const;
void normalize();
double determinant() const;
double trace() const;
void transpose();
void rotate(double fRadiant); void rotate(double fRadiant);
void translate(double fX, double fY); void translate(double fX, double fY);
@@ -97,7 +85,6 @@ namespace basegfx
void shearX(double fSx); void shearX(double fSx);
void shearY(double fSy); void shearY(double fSy);
B2DHomMatrix& operator+=(const B2DHomMatrix& rMat); B2DHomMatrix& operator+=(const B2DHomMatrix& rMat);
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 /** Create a multi range with exactly one containing range
*/ */
explicit B2DPolyRange( const ElementType& rElement );
B2DPolyRange( const B2DRange& rRange, B2VectorOrientation eOrient );
B2DPolyRange( const B2DPolyRange& ); B2DPolyRange( const B2DPolyRange& );
B2DPolyRange& operator=( 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;
bool operator!=(const B2DPolyRange&) const; bool operator!=(const B2DPolyRange&) const;
@@ -82,44 +77,15 @@ namespace basegfx
sal_uInt32 count() const; sal_uInt32 count() const;
ElementType getElement(sal_uInt32 nIndex) 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 // 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); void appendElement(const B2DRange& rRange, B2VectorOrientation eOrient, sal_uInt32 nCount = 1);
// insert/append multiple ranges // insert/append multiple ranges
void insertPolyRange(sal_uInt32 nIndex, const B2DPolyRange&);
void appendPolyRange(const B2DPolyRange&); void appendPolyRange(const B2DPolyRange&);
void remove(sal_uInt32 nIndex, sal_uInt32 nCount = 1);
void clear(); 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 /** Test whether given range overlaps one or more of the
included ranges. Does *not* use overall range, but checks included ranges. Does *not* use overall range, but checks
individually. individually.
@@ -130,12 +96,6 @@ namespace basegfx
*/ */
B2DPolyPolygon solveCrossovers() const; 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: private:
o3tl::cow_wrapper< ImplB2DPolyRange > mpImpl; o3tl::cow_wrapper< ImplB2DPolyRange > mpImpl;
}; };

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

@@ -69,21 +69,12 @@ namespace basegfx
B2DClipState(); B2DClipState();
~B2DClipState(); ~B2DClipState();
B2DClipState( const B2DClipState& ); B2DClipState( const B2DClipState& );
explicit B2DClipState( const B2DRange& );
explicit B2DClipState( const B2DPolygon& );
explicit B2DClipState( const B2DPolyPolygon& ); explicit B2DClipState( const B2DPolyPolygon& );
B2DClipState& operator=( const B2DClipState& ); B2DClipState& operator=( const B2DClipState& );
/// unshare this poly-range with all internally shared instances
void makeUnique();
/// Set clip to 'null' - nothing is visible /// Set clip to 'null' - nothing is visible
void makeNull(); 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 /// returns true when clip is 'cleared' - everything is visible
bool isCleared() const; bool isCleared() const;
@@ -91,24 +82,16 @@ namespace basegfx
bool operator!=(const B2DClipState&) const; bool operator!=(const B2DClipState&) const;
void unionRange(const B2DRange& ); void unionRange(const B2DRange& );
void unionPolygon(const B2DPolygon& );
void unionPolyPolygon(const B2DPolyPolygon& ); void unionPolyPolygon(const B2DPolyPolygon& );
void unionClipState(const B2DClipState& );
void intersectRange(const B2DRange& ); void intersectRange(const B2DRange& );
void intersectPolygon(const B2DPolygon& );
void intersectPolyPolygon(const B2DPolyPolygon& ); void intersectPolyPolygon(const B2DPolyPolygon& );
void intersectClipState(const B2DClipState& );
void subtractRange(const B2DRange& ); void subtractRange(const B2DRange& );
void subtractPolygon(const B2DPolygon& );
void subtractPolyPolygon(const B2DPolyPolygon& ); void subtractPolyPolygon(const B2DPolyPolygon& );
void subtractClipState(const B2DClipState& );
void xorRange(const B2DRange& ); void xorRange(const B2DRange& );
void xorPolygon(const B2DPolygon& );
void xorPolyPolygon(const B2DPolyPolygon& ); void xorPolyPolygon(const B2DPolyPolygon& );
void xorClipState(const B2DClipState& );
B2DPolyPolygon getClipPoly() const; 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) B2DCubicBezier::B2DCubicBezier(const B2DPoint& rStart, const B2DPoint& rControlPointA, const B2DPoint& rControlPointB, const B2DPoint& rEnd)
: maStartPoint(rStart), : maStartPoint(rStart),
maEndPoint(rEnd), maEndPoint(rEnd),

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

@@ -76,11 +76,6 @@ namespace basegfx
return *this; return *this;
} }
void B2DHomMatrix::makeUnique()
{
mpImpl.make_unique();
}
double B2DHomMatrix::get(sal_uInt16 nRow, sal_uInt16 nColumn) const double B2DHomMatrix::get(sal_uInt16 nRow, sal_uInt16 nColumn) const
{ {
return mpImpl->get(nRow, nColumn); return mpImpl->get(nRow, nColumn);
@@ -142,32 +137,6 @@ namespace basegfx
return false; 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) B2DHomMatrix& B2DHomMatrix::operator+=(const B2DHomMatrix& rMat)
{ {
mpImpl->doAddMatrix(*rMat.mpImpl); mpImpl->doAddMatrix(*rMat.mpImpl);
@@ -449,7 +418,4 @@ namespace basegfx
} }
} // end of namespace basegfx } // end of namespace basegfx
///////////////////////////////////////////////////////////////////////////////
// eof
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

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

@@ -38,13 +38,6 @@
#include <algorithm> #include <algorithm>
#include <vector> #include <vector>
static basegfx::B2VectorOrientation flipOrientation(
basegfx::B2VectorOrientation eOrient)
{
return eOrient == basegfx::ORIENTATION_POSITIVE ?
basegfx::ORIENTATION_NEGATIVE : basegfx::ORIENTATION_POSITIVE;
}
namespace basegfx namespace basegfx
{ {
class ImplB2DPolyRange class ImplB2DPolyRange
@@ -68,12 +61,6 @@ namespace basegfx
maOrient() 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 ) : explicit ImplB2DPolyRange( const B2DRange& rRange, B2VectorOrientation eOrient ) :
maBounds( rRange ), maBounds( rRange ),
maRanges( 1, rRange ), maRanges( 1, rRange ),
@@ -96,41 +83,6 @@ namespace basegfx
maOrient[nIndex]); 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) void appendElement(const B2DRange& rRange, B2VectorOrientation eOrient, sal_uInt32 nCount)
{ {
maRanges.insert(maRanges.end(), nCount, rRange); maRanges.insert(maRanges.end(), nCount, rRange);
@@ -138,13 +90,6 @@ namespace basegfx
maBounds.expand(rRange); 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) void appendPolyRange(const ImplB2DPolyRange& rPolyRange)
{ {
maRanges.insert(maRanges.end(), maRanges.insert(maRanges.end(),
@@ -156,13 +101,6 @@ namespace basegfx
updateBounds(); 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() void clear()
{ {
std::vector<B2DRange> aTmpRanges; std::vector<B2DRange> aTmpRanges;
@@ -174,37 +112,6 @@ namespace basegfx
maBounds.reset(); 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 bool overlaps( const B2DRange& rRange ) const
{ {
if( !maBounds.overlaps( rRange ) ) if( !maBounds.overlaps( rRange ) )
@@ -223,38 +130,6 @@ namespace basegfx
return tools::solveCrossovers(maRanges,maOrient); 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: private:
B2DRange maBounds; B2DRange maBounds;
std::vector<B2DRange> maRanges; std::vector<B2DRange> maRanges;
@@ -268,14 +143,6 @@ namespace basegfx
B2DPolyRange::~B2DPolyRange() 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 ) : B2DPolyRange::B2DPolyRange( const B2DPolyRange& rRange ) :
mpImpl( rRange.mpImpl ) mpImpl( rRange.mpImpl )
{} {}
@@ -286,11 +153,6 @@ namespace basegfx
return *this; return *this;
} }
void B2DPolyRange::makeUnique()
{
mpImpl.make_unique();
}
bool B2DPolyRange::operator==(const B2DPolyRange& rRange) const bool B2DPolyRange::operator==(const B2DPolyRange& rRange) const
{ {
if(mpImpl.same_object(rRange.mpImpl)) if(mpImpl.same_object(rRange.mpImpl))
@@ -314,76 +176,21 @@ namespace basegfx
return mpImpl->getElement(nIndex); 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) void B2DPolyRange::appendElement(const B2DRange& rRange, B2VectorOrientation eOrient, sal_uInt32 nCount)
{ {
mpImpl->appendElement(rRange, eOrient, 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) void B2DPolyRange::appendPolyRange(const B2DPolyRange& rRange)
{ {
mpImpl->appendPolyRange(*rRange.mpImpl); mpImpl->appendPolyRange(*rRange.mpImpl);
} }
void B2DPolyRange::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
{
mpImpl->remove(nIndex, nCount);
}
void B2DPolyRange::clear() void B2DPolyRange::clear()
{ {
mpImpl->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 bool B2DPolyRange::overlaps( const B2DRange& rRange ) const
{ {
return mpImpl->overlaps(rRange); return mpImpl->overlaps(rRange);
@@ -393,29 +200,6 @@ namespace basegfx
{ {
return mpImpl->solveCrossovers(); 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 } // end of namespace basegfx
// eof
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

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

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

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

@@ -26,82 +26,11 @@
*/ */
#include "b2dellipse.hxx" #include "b2dellipse.hxx"
#include <osl/diagnose.h>
#include <basegfx/point/b2dpoint.hxx> #include <basegfx/point/b2dpoint.hxx>
#include <basegfx/matrix/b2dhommatrix.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 namespace basegfx
{ {
B2DEllipse::B2DEllipse()
{}
B2DEllipse::B2DEllipse(const basegfx::B2DPoint& rCenter, const basegfx::B2DTuple& rRadius) B2DEllipse::B2DEllipse(const basegfx::B2DPoint& rCenter, const basegfx::B2DTuple& rRadius)
: maCenter(rCenter), maRadius(rRadius) : maCenter(rCenter), maRadius(rRadius)
{ {
@@ -126,27 +55,10 @@ namespace basegfx
return maCenter; return maCenter;
} }
void B2DEllipse::setB2DEllipseCenter(const basegfx::B2DPoint& rCenter)
{
maCenter = rCenter;
}
basegfx::B2DTuple B2DEllipse::getB2DEllipseRadius() const basegfx::B2DTuple B2DEllipse::getB2DEllipseRadius() const
{ {
return maRadius; return maRadius;
} }
void B2DEllipse::setB2DEllipseRadius(const basegfx::B2DTuple& rRadius)
{
maRadius = rRadius;
}
void B2DEllipse::transform(const basegfx::B2DHomMatrix& /* rMatrix */)
{
}
} // end of namespace basegfx } // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
// eof
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

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

@@ -37,10 +37,6 @@
#include <basegfx/vector/b2enums.hxx> #include <basegfx/vector/b2enums.hxx>
//////////////////////////////////////////////////////////////////////////////
// predeclarations
class ImplB2DEllipse;
namespace basegfx namespace basegfx
{ {
class B2DPoint; class B2DPoint;
@@ -48,18 +44,15 @@ namespace basegfx
class B2DHomMatrix; class B2DHomMatrix;
} // end of namespace basegfx } // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
namespace basegfx namespace basegfx
{ {
class B2DEllipse class B2DEllipse
{ {
private: private:
basegfx::B2DPoint maCenter; const basegfx::B2DPoint maCenter;
basegfx::B2DTuple maRadius; const basegfx::B2DTuple maRadius;
public: public:
B2DEllipse();
B2DEllipse(const B2DEllipse& rEllipse); B2DEllipse(const B2DEllipse& rEllipse);
B2DEllipse(const basegfx::B2DPoint& rCenter, const basegfx::B2DTuple& rRadius); B2DEllipse(const basegfx::B2DPoint& rCenter, const basegfx::B2DTuple& rRadius);
~B2DEllipse(); ~B2DEllipse();
@@ -73,18 +66,10 @@ namespace basegfx
// Coordinate interface // Coordinate interface
basegfx::B2DPoint getB2DEllipseCenter() const; basegfx::B2DPoint getB2DEllipseCenter() const;
void setB2DEllipseCenter(const basegfx::B2DPoint& rCenter);
basegfx::B2DTuple getB2DEllipseRadius() const; 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 } // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
#endif /* _BASEGFX_B2DELLIPSE_HXX */ #endif /* _BASEGFX_B2DELLIPSE_HXX */
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ /* 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::BitmapDevice::setDamageTracker(boost::shared_ptr<basebmp::IBitmapDeviceDamageTracker> const&)
basebmp::debugDump(boost::shared_ptr<basebmp::BitmapDevice> const&, std::basic_ostream<char, std::char_traits<char> >&) basebmp::debugDump(boost::shared_ptr<basebmp::BitmapDevice> const&, std::basic_ostream<char, std::char_traits<char> >&)
basegfx::B1DRange::B1DRange(basegfx::B1IRange const&) 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::getB2DPoint() const
basegfx::B2DHomPoint::setX(double) basegfx::B2DHomPoint::setX(double)
basegfx::B2DHomPoint::setY(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::insert(unsigned int, basegfx::B2DPolygon const&, unsigned int, unsigned int)
basegfx::B2DPolygon::isBezierSegment(unsigned int) const basegfx::B2DPolygon::isBezierSegment(unsigned int) const
basegfx::B2DPolygon::resetControlPoints(unsigned int) 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::maximum(basegfx::B2ITuple const&, basegfx::B2ITuple const&)
basegfx::minimum(basegfx::B2DHomPoint const&, basegfx::B2DHomPoint const&) basegfx::minimum(basegfx::B2DHomPoint const&, basegfx::B2DHomPoint const&)
basegfx::minimum(basegfx::B2ITuple const&, basegfx::B2ITuple 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::B2DPoint const&, basegfx::B2DPoint const&)
basegfx::tools::addPointsAtCuts(basegfx::B2DPolyPolygon const&, basegfx::B2DPolyPolygon const&) basegfx::tools::addPointsAtCuts(basegfx::B2DPolyPolygon const&, basegfx::B2DPolyPolygon const&)
basegfx::tools::addPointsAtCuts(basegfx::B2DPolyPolygon const&, bool) basegfx::tools::addPointsAtCuts(basegfx::B2DPolyPolygon const&, bool)