callcatcher: remove unused methods

6 files changed, 0 insertions, 307 deletions

diff --git a/basic/source/classes/disas.cxx b/basic/source/classes/disas.cxx
index 8dce7afc4b..936410d4bf 100644
--- a/basic/source/classes/disas.cxx
+++ b/basic/source/classes/disas.cxx
@@ -327,17 +327,6 @@ sal_Bool SbiDisas::Fetch()
         return sal_False;
 }
 
-void SbiDisas::Disas( SvStream& r )
-{
-    String aText;
-    nOff = 0;
-    while( DisasLine( aText ) )
-    {
-        ByteString aByteText( aText, gsl_getSystemTextEncoding() );
-        r.WriteLine( aByteText );
-    }
-}
-
 void SbiDisas::Disas( String& r )
 {
     r.Erase();
@@ -523,14 +512,6 @@ void SbiDisas::ResumeOp( String& rText )
     }
 }
 
-// print Prompt
-// sal_False/TRUE
-void SbiDisas::PromptOp( String& rText )
-{
-    if( nOp1 )
-        rText.AppendAscii( "\"? \"" );
-}
-
 // 0 or 1
 void SbiDisas::CloseOp( String& rText )
 {
diff --git a/basic/source/inc/disas.hxx b/basic/source/inc/disas.hxx
index 7d7a54f55f..5a90ebdf85 100644
--- a/basic/source/inc/disas.hxx
+++ b/basic/source/inc/disas.hxx
@@ -48,7 +48,6 @@ class SbiDisas {
     sal_Bool	 Fetch();				// naechster Opcode
 public:
     SbiDisas( SbModule*, const SbiImage* );
-    void Disas( SvStream& );
     void Disas( String& );
                                     // NICHT AUFRUFEN
     void	 StrOp( String& );
@@ -58,7 +57,6 @@ public:
     void	 LblOp( String& );
     void	 ReturnOp( String& );
     void	 ResumeOp( String& );
-    void	 PromptOp( String& );
     void	 CloseOp( String& );
     void	 CharOp( String& );
     void	 VarOp( String& );
diff --git a/svx/inc/svx/svdoedge.hxx b/svx/inc/svx/svdoedge.hxx
index abc369004b..20b90a66a4 100644
--- a/svx/inc/svx/svdoedge.hxx
+++ b/svx/inc/svx/svdoedge.hxx
@@ -211,7 +211,6 @@ protected:
         sal_uIntPtr* pnQuality, SdrEdgeInfoRec* pInfo) const;
     static bool ImpFindConnector(const Point& rPt, const SdrPageView& rPV, SdrObjConnection& rCon, const SdrEdgeObj* pThis, OutputDevice* pOut=NULL);
     sal_uInt16 ImpCalcEscAngle(SdrObject* pObj, const Point& aPt2) const;
-    bool ImpStripPolyPoints(XPolygon& rXP) const; // entfernen ueberfluessiger Punkte
     void ImpSetTailPoint(bool bTail1, const Point& rPt);
     void ImpUndirtyEdgeTrack();  // eventuelle Neuberechnung des Verbindungsverlaufs
     void ImpDirtyEdgeTrack();	// invalidate connector path, so it will be recalculated next time
diff --git a/svx/inc/svx/xpoly.hxx b/svx/inc/svx/xpoly.hxx
index 42c783a79b..9397123972 100644
--- a/svx/inc/svx/xpoly.hxx
+++ b/svx/inc/svx/xpoly.hxx
@@ -93,15 +93,11 @@ public:
 
     ~XPolygon();
 
-    void        SetSize( sal_uInt16 nSize );
-    sal_uInt16      GetSize() const;
-
     void        SetPointCount( sal_uInt16 nPoints );
     sal_uInt16      GetPointCount() const;
 
     void        Insert( sal_uInt16 nPos, const Point& rPt, XPolyFlags eFlags );
     void        Insert( sal_uInt16 nPos, const XPolygon& rXPoly );
-    void        Insert( sal_uInt16 nPos, const Polygon& rPoly );
     void        Remove( sal_uInt16 nPos, sal_uInt16 nCount );
     void        Move( long nHorzMove, long nVertMove );
     Rectangle   GetBoundRect() const;
@@ -128,7 +124,6 @@ public:
     // Transformationen
     void Translate(const Point& rTrans);
     void Rotate(const Point& rCenter, double fSin, double fCos);
-    void Rotate(const Point& rCenter, sal_uInt16 nAngle);
     void Scale(double fSx, double fSy);
     void SlantX(long nYRef, double fSin, double fCos);
     void SlantY(long nXRef, double fSin, double fCos);
@@ -162,9 +157,7 @@ protected:
 
 public:
                     XPolyPolygon( sal_uInt16 nInitSize = 16, sal_uInt16 nResize = 16 );
-                    XPolyPolygon( const XPolygon& rXPoly );
                     XPolyPolygon( const XPolyPolygon& rXPolyPoly );
-                    XPolyPolygon( const PolyPolygon& rPolyPoly);
 
                     ~XPolyPolygon();
 
@@ -173,13 +166,11 @@ public:
     void            Insert( const XPolyPolygon& rXPoly,
                             sal_uInt16 nPos=XPOLYPOLY_APPEND );
     XPolygon        Remove( sal_uInt16 nPos );
-    XPolygon        Replace( const XPolygon& rXPoly, sal_uInt16 nPos );
     const XPolygon& GetObject( sal_uInt16 nPos ) const;
 
     void            Clear();
     sal_uInt16          Count() const;
 
-    void            Move( long nHorzMove, long nVertMove );
     Rectangle       GetBoundRect() const;
 
     const XPolygon& operator[]( sal_uInt16 nPos ) const
@@ -191,14 +182,8 @@ public:
     sal_Bool            operator!=( const XPolyPolygon& rXPolyPoly ) const;
 
     // Transformationen
-    void Translate(const Point& rTrans);
     void Rotate(const Point& rCenter, double fSin, double fCos);
-    void Rotate(const Point& rCenter, sal_uInt16 nAngle);
-    void Scale(double fSx, double fSy);
-    void SlantX(long nYRef, double fSin, double fCos);
-    void SlantY(long nXRef, double fSin, double fCos);
     void Distort(const Rectangle& rRefRect, const XPolygon& rDistortedRect);
-    void Rotate20 ();
 
     // #116512# convert to basegfx::B2DPolyPolygon and return
     basegfx::B2DPolyPolygon getB2DPolyPolygon() const;
diff --git a/svx/source/svdraw/svdoedge.cxx b/svx/source/svdraw/svdoedge.cxx
index 0835f6ec58..24a033929a 100644
--- a/svx/source/svdraw/svdoedge.cxx
+++ b/svx/source/svdraw/svdoedge.cxx
@@ -629,12 +629,6 @@ sal_uInt16 SdrEdgeObj::ImpCalcEscAngle(SdrObject* pObj, const Point& rPt) const
     }
 }
 
-bool SdrEdgeObj::ImpStripPolyPoints(XPolygon& /*rXP*/) const
-{
-    // fehlende Implementation !!!
-    return sal_False;
-}
-
 XPolygon SdrEdgeObj::ImpCalcObjToCenter(const Point& rStPt, long nEscAngle, const Rectangle& rRect, const Point& rMeeting) const
 {
     XPolygon aXP;
diff --git a/svx/source/xoutdev/_xpoly.cxx b/svx/source/xoutdev/_xpoly.cxx
index 309bac901e..c001f41ead 100644
--- a/svx/source/xoutdev/_xpoly.cxx
+++ b/svx/source/xoutdev/_xpoly.cxx
@@ -446,30 +446,6 @@ void XPolygon::CheckReference()
 
 /*************************************************************************
 |*
-|*    XPolygon::SetSize()
-|*
-*************************************************************************/
-
-void XPolygon::SetSize( sal_uInt16 nNewSize )
-{
-    CheckReference();
-    pImpXPolygon->Resize( nNewSize );
-}
-
-/*************************************************************************
-|*
-|*    XPolygon::GetSize()
-|*
-*************************************************************************/
-
-sal_uInt16 XPolygon::GetSize() const
-{
-    pImpXPolygon->CheckPointDelete();
-    return pImpXPolygon->nSize;
-}
-
-/*************************************************************************
-|*
 |*    XPolygon::SetPointCount()
 |*
 *************************************************************************/
@@ -543,28 +519,6 @@ void XPolygon::Insert( sal_uInt16 nPos, const XPolygon& rXPoly )
 
 /*************************************************************************
 |*
-|*    XPolygon::Insert()
-|*
-*************************************************************************/
-
-void XPolygon::Insert( sal_uInt16 nPos, const Polygon& rPoly )
-{
-    CheckReference();
-    if (nPos>pImpXPolygon->nPoints) nPos=pImpXPolygon->nPoints;
-
-    sal_uInt16 nPoints = rPoly.GetSize();
-
-    pImpXPolygon->InsertSpace( nPos, nPoints );
-
-    sal_uInt16 i;
-    for( i=0; i < nPoints; i++ )
-        pImpXPolygon->pPointAry[i] = rPoly[i];
-
-    // Die Flags sind durch das InsertSpace bereits auf 0 gesetzt
-}
-
-/*************************************************************************
-|*
 |*    XPolygon::Remove()
 |*
 *************************************************************************/
@@ -1073,25 +1027,6 @@ void XPolygon::PointsToBezier(sal_uInt16 nFirst)
 
 /*************************************************************************
 |*
-|*    XPolygon::Translate()
-|*
-|*    Polygon auf den uebergebenen Punkt verschieben
-|*
-*************************************************************************/
-
-void XPolygon::Translate(const Point& rTrans)
-{
-    pImpXPolygon->CheckPointDelete();
-    CheckReference();
-
-    sal_uInt16 nPntCnt = pImpXPolygon->nPoints;
-
-    for (sal_uInt16 i = 0; i < nPntCnt; i++)
-        pImpXPolygon->pPointAry[i] += rTrans;
-}
-
-/*************************************************************************
-|*
 |*    XPolygon::Rotate()
 |*
 |*    Alle Punkte um den Punkt rCenter drehen, Sinus und Cosinus
@@ -1141,28 +1076,6 @@ void XPolygon::Rotate(const Point& rCenter, double fSin, double fCos)
 
 /*************************************************************************
 |*
-|*    XPolygon::Rotate()
-|*
-|*    Alle Punkte um den Punkt rCenter mit dem Winkel nAngle drehen
-|*    Winkel in 10tel Grad, Wertebereich 0 - 3600
-|*
-*************************************************************************/
-
-void XPolygon::Rotate(const Point& rCenter, sal_uInt16 nAngle)
-{
-    nAngle %= 3600;
-
-    if ( nAngle != 0 )
-    {
-        double fAngle = F_PI * nAngle / 1800;
-        double fSin = sin(fAngle);
-        double fCos = cos(fAngle);
-        Rotate(rCenter, fSin, fCos);
-    }
-}
-
-/*************************************************************************
-|*
 |*    XPolygon::Scale()
 |*
 |*    XPolygon in X- und/oder Y-Richtung skalieren
@@ -1437,20 +1350,6 @@ XPolyPolygon::XPolyPolygon( sal_uInt16 /*nInitSize*/, sal_uInt16 /*nResize*/ )
     pImpXPolyPolygon = new ImpXPolyPolygon();
 }
 
-
-/*************************************************************************
-|*
-|*    XPolyPolygon::XPolyPolygon()
-|*
-*************************************************************************/
-
-XPolyPolygon::XPolyPolygon( const XPolygon& rXPoly )
-{
-    DBG_CTOR(XPolyPolygon,NULL);
-    pImpXPolyPolygon = new ImpXPolyPolygon();
-    pImpXPolyPolygon->aXPolyList.push_back( new XPolygon( rXPoly ) );
-}
-
 /*************************************************************************
 |*
 |*    XPolyPolygon::XPolyPolygon()
@@ -1466,24 +1365,6 @@ XPolyPolygon::XPolyPolygon( const XPolyPolygon& rXPolyPoly )
 
 /*************************************************************************
 |*
-|*    XPolyPolygon::XPolyPolygon()
-|*
-|*    XPolyPolygon aus einen Standard-PolyPolygon erzeugen
-|*
-*************************************************************************/
-
-XPolyPolygon::XPolyPolygon( const PolyPolygon& rPolyPoly )
-{
-    DBG_CTOR(XPolyPolygon,NULL);
-    pImpXPolyPolygon = new ImpXPolyPolygon;
-
-    for (sal_uInt16 i = 0; i < rPolyPoly.Count(); i++)
-        pImpXPolyPolygon->aXPolyList.push_back(
-                                    new XPolygon(rPolyPoly.GetObject(i)) );
-}
-
-/*************************************************************************
-|*
 |*    XPolyPolygon::~XPolyPolygon()
 |*
 *************************************************************************/
@@ -1583,24 +1464,6 @@ XPolygon XPolyPolygon::Remove( sal_uInt16 nPos )
 
 /*************************************************************************
 |*
-|*    XPolyPolygon::Replace()
-|*
-*************************************************************************/
-
-XPolygon XPolyPolygon::Replace( const XPolygon& rXPoly, sal_uInt16 nPos )
-{
-    CheckReference();
-    XPolygon* pXPoly = new XPolygon( rXPoly );
-    XPolygon* pTmpXPoly = pImpXPolyPolygon->aXPolyList[ nPos ];
-    pImpXPolyPolygon->aXPolyList[ nPos ] = pXPoly;
-    XPolygon  aXPoly( *pTmpXPoly );
-    delete pTmpXPoly;
-    return aXPoly;
-}
-
-
-/*************************************************************************
-|*
 |*    XPolyPolygon::GetObject()
 |*
 *************************************************************************/
@@ -1644,30 +1507,6 @@ sal_uInt16 XPolyPolygon::Count() const
     return (sal_uInt16)(pImpXPolyPolygon->aXPolyList.size());
 }
 
-
-/*************************************************************************
-|*
-|*    XPolyPolygon::Move()
-|*
-*************************************************************************/
-
-void XPolyPolygon::Move( long nHorzMove, long nVertMove )
-{
-    // Diese Abfrage sollte man fuer die DrawEngine durchfuehren
-    if ( !nHorzMove && !nVertMove )
-        return;
-
-    // Referenzcounter beruecksichtigen
-    CheckReference();
-
-    // Punkte verschieben
-    for ( size_t i = 0, n = pImpXPolyPolygon->aXPolyList.size(); i < n; ++i )
-    {
-        XPolygon* pXPoly = pImpXPolyPolygon->aXPolyList[ i ];
-        pXPoly->Move( nHorzMove, nVertMove );
-    }
-}
-
 /*************************************************************************
 |*
 |*    XPolyPolygon::GetBoundRect()
@@ -1748,22 +1587,6 @@ sal_Bool XPolyPolygon::operator!=( const XPolyPolygon& rXPolyPoly ) const
 
 /*************************************************************************
 |*
-|*    XPolyPolygon::Translate()
-|*
-|*    Alle Polygone auf den uebergebenen Punkt verschieben
-|*
-*************************************************************************/
-
-void XPolyPolygon::Translate(const Point& rTrans)
-{
-    CheckReference();
-
-    for (size_t i = 0; i < Count(); i++)
-        pImpXPolyPolygon->aXPolyList[ i ]->Translate(rTrans);
-}
-
-/*************************************************************************
-|*
 |*    XPolyPolygon::Rotate()
 |*
 |*    Alle Polygone um den Punkt rCenter drehen, Sinus und Cosinus
@@ -1781,93 +1604,6 @@ void XPolyPolygon::Rotate(const Point& rCenter, double fSin, double fCos)
 
 /*************************************************************************
 |*
-|* Bestimme den linken, unteren Punkt des Polygons und richte das
-|* Polygon so aus, dass dieser Punkt auf dem Index 0 liegt
-|*
-\************************************************************************/
-
-void XPolyPolygon::Rotate20()
-{
-    CheckReference();
-
-    for (size_t i = 0; i < Count(); i++)
-        pImpXPolyPolygon->aXPolyList[ i ]->Rotate20();
-}
-
-/*************************************************************************
-|*
-|*    XPolyPolygon::Rotate()
-|*
-|*    Alle Poylgone um den Punkt rCenter mit dem Winkel nAngle drehen
-|*    Winkel in 10tel Grad, Wertebereich 0 - 3600
-|*
-*************************************************************************/
-
-void XPolyPolygon::Rotate(const Point& rCenter, sal_uInt16 nAngle)
-{
-    nAngle %= 3600;
-
-    if ( nAngle != 0 )
-    {
-        double fAngle = F_PI * nAngle / 1800;
-        double fSin = sin(fAngle);
-        double fCos = cos(fAngle);
-        Rotate(rCenter, fSin, fCos);
-    }
-}
-
-/*************************************************************************
-|*
-|*    XPolyPolygon::Scale()
-|*
-|*    Alle Polygone in X- und/oder Y-Richtung skalieren
-|*
-*************************************************************************/
-
-void XPolyPolygon::Scale(double fSx, double fSy)
-{
-    CheckReference();
-
-    for (size_t i = 0; i < Count(); i++)
-        pImpXPolyPolygon->aXPolyList[ i ]->Scale(fSx, fSy);
-}
-
-/*************************************************************************
-|*
-|*    XPolyPolygon::SlantX()
-|*
-|*    Alle Polygone in X-Richtung um einen beliebigen Winkel kippen,
-|*    bezogen auf eine Referenz-Y-Koordinate
-|*
-*************************************************************************/
-
-void XPolyPolygon::SlantX(long nYRef, double fSin, double fCos)
-{
-    CheckReference();
-
-    for (size_t i = 0; i < Count(); i++)
-        pImpXPolyPolygon->aXPolyList[ i ]->SlantX(nYRef, fSin, fCos);
-}
-
-/*************************************************************************
-|*
-|*    XPolyPolygon::SlantY()
-|*
-|*    Alle Polygone in Y-Richtung um einen beliebigen Winkel kippen,
-|*    bezogen auf eine Referenz-X-Koordinate
-|*
-*************************************************************************/
-
-void XPolyPolygon::SlantY(long nXRef, double fSin, double fCos)
-{
-    CheckReference();
-
-    for (size_t i = 0; i < Count(); i++)
-        pImpXPolyPolygon->aXPolyList[ i ]->SlantY(nXRef, fSin, fCos);
-}
-
-/*************************************************************************
-|*
 |*    XPolygon::Distort()
 |*
 |*    XPolygon verzerren, indem die Koordinaten relativ zu einem