diff options
Diffstat (limited to 'kpovmodeler/pmlathe.cpp')
| -rw-r--r-- | kpovmodeler/pmlathe.cpp | 948 |
1 files changed, 948 insertions, 0 deletions
diff --git a/kpovmodeler/pmlathe.cpp b/kpovmodeler/pmlathe.cpp new file mode 100644 index 00000000..f6c3c3c3 --- /dev/null +++ b/kpovmodeler/pmlathe.cpp @@ -0,0 +1,948 @@ +/* +************************************************************************** + description + -------------------- + copyright : (C) 2002 by Andreas Zehender + email : zehender@kde.org +************************************************************************** + +************************************************************************** +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +**************************************************************************/ + + +#include "pmlathe.h" + +#include "pmxmlhelper.h" +#include "pmlatheedit.h" +#include "pmmemento.h" +#include "pmviewstructure.h" +#include "pm2dcontrolpoint.h" +#include "pmsplinememento.h" +#include "pmsplinesegment.h" +#include "pmdefaults.h" +#include "pmenumproperty.h" +#include "pmobjectaction.h" + +#include <klocale.h> + +const int defaultNumberOfPoints = 4; +const PMVector defaultPoint[defaultNumberOfPoints] = +{ + PMVector( 0.0, 1.0 ), + PMVector( 0.5, 0.7 ), + PMVector( 0.5, 0.3 ), + PMVector( 0.0, 0.0 ) +}; + +const bool defaultSturm = false; +const PMLathe::SplineType defaultSplineType = PMLathe::LinearSpline; + +PMDefinePropertyClass( PMLathe, PMLatheProperty ); +PMDefineEnumPropertyClass( PMLathe, PMLathe::SplineType, PMSplineTypeProperty ); + +PMMetaObject* PMLathe::s_pMetaObject = 0; +PMObject* createNewLathe( PMPart* part ) +{ + return new PMLathe( part ); +} + +class PMPointProperty : public PMPropertyBase +{ +public: + PMPointProperty( ) + : PMPropertyBase( "splinePoints", PMVariant::Vector ) + { + m_index = 0; + } + virtual int dimensions( ) const { return 1; } + virtual void setIndex( int /*dimension*/, int index ) + { + m_index = index; + } + virtual int size( PMObject* object, int /*dimension*/ ) const + { + return ( ( PMLathe* ) object )->numberOfPoints( ); + } +protected: + virtual bool setProtected( PMObject* obj, const PMVariant& var ) + { + PMLathe* p = ( PMLathe* ) obj; + QValueList<PMVector> list = p->points( ); + QValueList<PMVector>::Iterator it = list.begin( ); + int i; + PMVector v = var.vectorData( ); + v.resize( 2 ); + + for( i = 0; i < m_index && it != list.end( ); ++i ) + ++it; + // expand the list if necessary + for( ; i < m_index; ++i ) + list.insert( it, v ); + if( it == list.end( ) ) + it = list.insert( it, v ); + else + *it = v; + + p->setPoints( list ); + return true; + } + virtual PMVariant getProtected( const PMObject* obj ) + { + PMLathe* p = ( PMLathe* ) obj; + QValueList<PMVector> list = p->points( ); + QValueList<PMVector>::ConstIterator it = list.at( m_index ); + + if( it == list.end( ) ) + { + kdError( PMArea ) << "Range error in PMLathe::PointProperty::get" << endl; + return PMVariant( ); + } + + return PMVariant( *it ); + } + +private: + int m_index; +}; + + +int PMLathe::s_rSteps = c_defaultLatheRSteps; +int PMLathe::s_sSteps = c_defaultLatheSSteps; +int PMLathe::s_parameterKey = 0; + +PMLathe::PMLathe( PMPart* part ) + : Base( part ) +{ + int i; + + for( i = 0; i < defaultNumberOfPoints; ++i ) + m_points.append( defaultPoint[i] ); + m_splineType = defaultSplineType; + m_sturm = defaultSturm; +} + +PMLathe::PMLathe( const PMLathe& l ) + : Base( l ) +{ + m_points = l.m_points; + m_splineType = l.m_splineType; + m_sturm = l.m_sturm; +} + +PMLathe::~PMLathe( ) +{ +} + +QString PMLathe::description( ) const +{ + return i18n( "lathe" ); +} + +void PMLathe::serialize( QDomElement& e, QDomDocument& doc ) const +{ + QDomElement data = doc.createElement( "extra_data" ); + QDomElement p; + + e.setAttribute( "spline_type", m_splineType ); + e.setAttribute( "sturm", m_sturm ); + + QValueList<PMVector>::ConstIterator it; + for( it = m_points.begin( ); it != m_points.end( ); ++it ) + { + p = doc.createElement( "point" ); + p.setAttribute( "vector", ( *it ).serializeXML( ) ); + data.appendChild( p ); + } + + e.appendChild( data ); + Base::serialize( e, doc ); +} + +void PMLathe::readAttributes( const PMXMLHelper& h ) +{ + m_splineType = ( SplineType ) h.intAttribute( "spline_type", defaultSplineType ); + m_sturm = h.boolAttribute( "sturm", defaultSturm ); + + m_points.clear( ); + PMVector v( 2 ); + + QDomElement e = h.extraData( ); + if( !e.isNull( ) ) + { + QDomNode c = e.firstChild( ); + while( !c.isNull( ) ) + { + if( c.isElement( ) ) + { + QDomElement ce = c.toElement( ); + if( ce.tagName( ) == "point" ) + { + QString str = ce.attribute( "vector" ); + if( !str.isNull( ) ) + { + v.loadXML( str ); + m_points.append( v ); + } + } + } + c = c.nextSibling( ); + } + } + + Base::readAttributes( h ); +} + +PMMetaObject* PMLathe::metaObject( ) const +{ + if( !s_pMetaObject ) + { + s_pMetaObject = new PMMetaObject( "Lathe", Base::metaObject( ), + createNewLathe ); + s_pMetaObject->addProperty( + new PMLatheProperty( "sturm", &PMLathe::setSturm, &PMLathe::sturm ) ); + PMSplineTypeProperty* p = new PMSplineTypeProperty( + "splineType", &PMLathe::setSplineType, &PMLathe::splineType ); + p->addEnumValue( "LinearSpline", LinearSpline ); + p->addEnumValue( "QuadraticSpline", QuadraticSpline ); + p->addEnumValue( "CubicSpline", CubicSpline ); + p->addEnumValue( "BezierSpline", BezierSpline ); + s_pMetaObject->addProperty( p ); + s_pMetaObject->addProperty( new PMPointProperty( ) ); + } + return s_pMetaObject; +} + +void PMLathe::cleanUp( ) const +{ + if( s_pMetaObject ) + { + delete s_pMetaObject; + s_pMetaObject = 0; + } + Base::cleanUp( ); +} + +void PMLathe::setSplineType( PMLathe::SplineType t ) +{ + if( m_splineType != t ) + { + if( m_pMemento ) + m_pMemento->addData( s_pMetaObject, PMSplineTypeID, ( int ) m_splineType ); + setViewStructureChanged( ); + m_splineType = t; + } +} + +void PMLathe::setSturm( bool s ) +{ + if( m_sturm != s ) + { + if( m_pMemento ) + m_pMemento->addData( s_pMetaObject, PMSturmID, m_sturm ); + m_sturm = s; + } +} + +void PMLathe::setPoints( const QValueList<PMVector>& points ) +{ + if( m_points != points ) + { + if( m_pMemento ) + ( ( PMSplineMemento* ) m_pMemento )->setSplinePoints( m_points ); + + setViewStructureChanged( ); + m_points = points; + } +} + +PMDialogEditBase* PMLathe::editWidget( QWidget* parent ) const +{ + return new PMLatheEdit( parent ); +} + +void PMLathe::createMemento( ) +{ + if( m_pMemento ) + delete m_pMemento; + m_pMemento = new PMSplineMemento( this ); +} + +void PMLathe::restoreMemento( PMMemento* s ) +{ + PMSplineMemento* m = ( PMSplineMemento* ) s; + PMMementoDataIterator it( s ); + PMMementoData* data; + + for( ; it.current( ); ++it ) + { + data = it.current( ); + if( data->objectType( ) == s_pMetaObject ) + { + switch( data->valueID( ) ) + { + case PMSplineTypeID: + setSplineType( ( SplineType ) data->intData( ) ); + break; + case PMSturmID: + setSturm( data->boolData( ) ); + break; + default: + kdError( PMArea ) << "Wrong ID in PMLathe::restoreMemento\n"; + break; + } + } + } + if( m->splinePointsSaved( ) ) + setPoints( m->splinePoints( ) ); + + Base::restoreMemento( s ); +} + + +void PMLathe::createViewStructure( ) +{ + if( s_sSteps == 0 ) + s_sSteps = c_defaultLatheSSteps; + if( s_rSteps == 0 ) + s_rSteps = c_defaultLatheRSteps; + + int rSteps = (int)( ( (float)s_rSteps / 2 ) * ( displayDetail( ) + 1 ) ); + int sSteps = (int)( ( (float)s_sSteps / 2 ) * ( displayDetail( ) + 1 ) ); + + int np = m_points.count( ); + int ns = 0; + int i, j, r, si; + + // calculate number of segments + switch( m_splineType ) + { + case LinearSpline: + ns = np - 1; + break; + case QuadraticSpline: + ns = np - 2; + break; + case CubicSpline: + ns = np - 3; + break; + case BezierSpline: + ns = np / 4; + break; + } + + // calculate number of points and lines of the view structure + int vsp = 0; + if( m_splineType != BezierSpline ) + vsp = ns * sSteps + 1; + else + vsp = ns * ( sSteps + 1 ); + + int vsl = 0; + if( m_splineType != BezierSpline ) + vsl = ( 2 * vsp - 1 ) * rSteps; + else + vsl = ns * ( ( 2 * sSteps + 1 ) * rSteps ); + + vsp *= rSteps; + + if( m_pViewStructure ) + { + if( m_pViewStructure->points( ).size( ) != ( unsigned ) vsp ) + m_pViewStructure->points( ).resize( vsp ); + if( m_pViewStructure->lines( ).size( ) != ( unsigned ) vsl ) + m_pViewStructure->lines( ).resize( vsl ); + } + else + m_pViewStructure = new PMViewStructure( vsp, vsl ); + + + // calculate the spline segments + QValueList<PMSplineSegment> segments; + QValueList<PMVector>::Iterator it1, it2, it3, it4; + it1 = m_points.begin( ); + it2 = it1; ++it2; + it3 = it2; ++it3; + it4 = it3; ++it4; + PMSplineSegment s; + + for( i = 0; i < ns; ++i ) + { + switch( m_splineType ) + { + case LinearSpline: + s.calculateLinear( *it1, *it2 ); + ++it1; + ++it2; + break; + case QuadraticSpline: + s.calculateQuadratic( *it1, *it2, *it3 ); + ++it1; + ++it2; + ++it3; + break; + case CubicSpline: + s.calculateCubic( *it1, *it2, *it3, *it4 ); + ++it1; + ++it2; + ++it3; + ++it4; + break; + case BezierSpline: + s.calculateBezier( *it1, *it2, *it3, *it4 ); + for( j = 0; j < 4; ++j ) + { + ++it1; + ++it2; + ++it3; + ++it4; + } + break; + } + segments.append( s ); + } + + // create the line array + if( m_splineType != BezierSpline ) + { + PMLineArray& lines = m_pViewStructure->lines( ); + int vl = ns * sSteps; + int lb = 0; + for( i = 0; i < vl + 1; ++i ) + { + for( j = 0; j < rSteps - 1; ++j ) + lines[lb+j] = PMLine( lb + j, lb + j + 1 ); + lines[lb+rSteps-1] = PMLine( lb, lb + rSteps - 1 ); + lb += rSteps; + } + int pi = 0; + for( i = 0; i < vl; ++i ) + { + for( j = 0; j < rSteps; ++j ) + { + lines[lb] = PMLine( pi, pi + rSteps ); + ++pi; + ++lb; + } + } + } + else + { + PMLineArray& lines = m_pViewStructure->lines( ); + int lb = 0; + int pi = 0; + + for( si = 0; si < ns; ++si ) + { + for( i = 0; i < sSteps + 1; ++i ) + { + for( j = 0; j < rSteps - 1; ++j ) + lines[lb+j] = PMLine( lb + j, lb + j + 1 ); + lines[lb+rSteps-1] = PMLine( lb, lb + rSteps - 1 ); + lb += rSteps; + } + } + for( si = 0; si < ns; ++si ) + { + for( i = 0; i < sSteps; ++i ) + { + for( j = 0; j < rSteps; ++j ) + { + lines[lb] = PMLine( pi, pi + rSteps ); + ++pi; + ++lb; + } + } + pi += rSteps; + } + } + // calculate the points + PMVector point2, point3; + QValueList<PMSplineSegment>::Iterator sit = segments.begin( ); + int pi = 0; + + double poffset = 1.0 / sSteps; + PMMatrix rot = PMMatrix::rotation( 0.0, M_PI * 2.0 / rSteps, 0.0 ); + PMPointArray& points = m_pViewStructure->points( ); + + if( m_splineType != BezierSpline ) + { + for( i = 0; i < ns; ++i, ++sit ) + { + for( j = 0; j < sSteps; ++j ) + { + point2 = ( *sit ).point( poffset * j ); + point3[0] = point2[0]; + point3[1] = point2[1]; + point3[2] = 0.0; + + for( r = 0; r < rSteps; ++r ) + { + points[pi] = PMPoint( point3 ); + if( r != rSteps - 1 ) + point3.transform( rot ); + ++pi; + } + } + if( i == ns - 1 ) + { + point2 = ( *sit ).point( 1.0 ); + point3[0] = point2[0]; + point3[1] = point2[1]; + point3[2] = 0.0; + + for( r = 0; r < rSteps; ++r ) + { + points[pi] = PMPoint( point3 ); + if( r != rSteps - 1 ) + point3.transform( rot ); + ++pi; + } + } + } + } + else + { + for( i = 0; i < ns; ++i, ++sit ) + { + for( j = 0; j < sSteps + 1; ++j ) + { + point2 = ( *sit ).point( poffset * j ); + point3[0] = point2[0]; + point3[1] = point2[1]; + point3[2] = 0.0; + + for( r = 0; r < rSteps; ++r ) + { + points[pi] = PMPoint( point3 ); + if( r != rSteps - 1 ) + point3.transform( rot ); + ++pi; + } + } + } + } +} + +void PMLathe::controlPoints( PMControlPointList& list ) +{ + QValueList<PMVector>::Iterator it; + int i, d; + + PM2DControlPoint* cp = 0; + QPtrList<PM2DControlPoint> tmp[2]; + + for( d = 0; d < 2; ++d ) + { + if( m_splineType != BezierSpline ) + { + PM2DControlPoint* firstPoint = 0; + PM2DControlPoint* lastPoint = 0; + + for( it = m_points.begin( ), i = 0; it != m_points.end( ); ++it, ++i ) + { + lastPoint = cp; + if( d == 0 ) + cp = new PM2DControlPoint( *it, PM2DControlPoint::PM2DXY, i, + i18n( "Point %1 (xy)" ).arg( i + 1 ) ); + else + cp = new PM2DControlPoint( *it, PM2DControlPoint::PM2DZY, i, + i18n( "Point %1 (xy)" ).arg( i + 1 ) ); + + if( i == 0 ) + firstPoint = cp; + if( ( i == 1 ) && ( m_splineType != LinearSpline ) ) + firstPoint->setBasePoint( cp ); + + tmp[d].append( cp ); + } + if( m_splineType == CubicSpline ) + cp->setBasePoint( lastPoint ); + } + else + { + PM2DControlPoint* helpPoint = 0; + + for( it = m_points.begin( ), i = 0; it != m_points.end( ); ++it, ++i ) + { + int imod4 = i % 4; + if( d == 0 ) + cp = new PM2DControlPoint( *it, PM2DControlPoint::PM2DXY, i, + i18n( "Point %1 (xy)" ).arg( i + 1 ) ); + else + cp = new PM2DControlPoint( *it, PM2DControlPoint::PM2DZY, i, + i18n( "Point %1 (xy)" ).arg( i + 1 ) ); + switch( imod4 ) + { + case 0: + helpPoint = cp; + break; + case 1: + cp->setBasePoint( helpPoint ); + break; + case 2: + helpPoint = cp; + break; + case 3: + helpPoint->setBasePoint( cp ); + break; + default: + break; + } + + tmp[d].append( cp ); + } + } + } + + QPtrListIterator<PM2DControlPoint> cit1( tmp[0] ), cit2( tmp[1] ); + + for( ; cit1.current( ) && cit2.current( ); ++cit1, ++cit2 ) + { + ( *cit1 )->setLatheLink( *cit2 ); + ( *cit2 )->setLatheLink( *cit1 ); + } + for( cit1.toFirst( ); cit1.current( ); ++cit1 ) + list.append( *cit1 ); + for( cit2.toFirst( ); cit2.current( ); ++cit2 ) + list.append( *cit2 ); +} + +void PMLathe::controlPointsChanged( PMControlPointList& list ) +{ + PMControlPointListIterator it1( list ), it2( list ); + QValueList<PMVector>::Iterator pit = m_points.begin( ); + PM2DControlPoint* p1; + PM2DControlPoint* p2; + bool firstChange = true; + + for( it2 += list.count( ) / 2; it2.current( ); ++it1, ++it2, ++pit ) + { + p1 = ( PM2DControlPoint* ) it1.current( ); + p2 = ( PM2DControlPoint* ) it2.current( ); + + if( p1->changed( ) ) + { + if( firstChange ) + { + if( m_pMemento ) + { + PMSplineMemento* m = ( PMSplineMemento* ) m_pMemento; + if( !m->splinePointsSaved( ) ) + m->setSplinePoints( m_points ); + } + firstChange = false; + setViewStructureChanged( ); + } + p2->setPoint( p1->point( ) ); + ( *pit ) = p1->point( ); + } + else if( p2->changed( ) ) + { + if( firstChange ) + { + if( m_pMemento ) + { + PMSplineMemento* m = ( PMSplineMemento* ) m_pMemento; + if( !m->splinePointsSaved( ) ) + m->setSplinePoints( m_points ); + } + firstChange = false; + setViewStructureChanged( ); + } + p1->setPoint( p2->point( ) ); + ( *pit ) = p2->point( ); + } + } +} + +void PMLathe::addObjectActions( const PMControlPointList& /*cp*/, + QPtrList<PMObjectAction>& actions ) +{ + PMObjectAction* a; + + a = new PMObjectAction( s_pMetaObject, PMSplitSegmentID, + i18n( "Add Point" ) ); + actions.append( a ); + + a = new PMObjectAction( s_pMetaObject, PMJoinSegmentsID, + i18n( "Remove Point" ) ); + int np = m_points.count( ); + int minp = 3; + switch( m_splineType ) + { + case LinearSpline: + minp = 3; + break; + case QuadraticSpline: + minp = 4; + break; + case CubicSpline: + minp = 5; + break; + case BezierSpline: + minp = 8; + break; + } + + if( np < minp ) + a->setEnabled( false ); + actions.append( a ); +} + +void PMLathe::objectActionCalled( const PMObjectAction* action, + const PMControlPointList& cp, + const QPtrList<PMVector>& cpViewPosition, + const PMVector& clickPosition ) +{ + if( action->objectType( ) == s_pMetaObject ) + { + switch( action->actionID( ) ) + { + case PMSplitSegmentID: + splitSegment( cp, cpViewPosition, clickPosition ); + break; + case PMJoinSegmentsID: + joinSegments( cp, cpViewPosition, clickPosition ); + break; + default: + kdError( PMArea ) << "Wrong ID in PMLathe::objectActionCalled\n"; + break; + } + } + else + Base::objectActionCalled( action, cp, cpViewPosition, clickPosition ); +} + +void PMLathe::splitSegment( const PMControlPointList& /*cp*/, + const QPtrList<PMVector>& cpViewPosition, + const PMVector& clickPosition ) +{ + // find nearest segment + int nump = cpViewPosition.count( ) / 2 - 1; + double abs = 0.0, minabs = 1e10; + int ns = -1; + int i, j; + PMVector mid( 3 ), dist( 2 ); + + QPtrListIterator<PMVector> it1( cpViewPosition ); + QPtrListIterator<PMVector> it2( cpViewPosition ); + ++it2; + + for( j = 0; j < 2; ++j ) + { + for( i = 0; i < nump; ++i ) + { + bool skip = false; + switch( m_splineType ) + { + case LinearSpline: + case BezierSpline: + break; + case QuadraticSpline: + if( i == 0 ) + skip = true; + break; + case CubicSpline: + if( ( i == 0 ) || ( i == ( nump - 1 ) ) ) + skip = true; + break; + } + + if( !skip ) + { + mid = ( **it1 + **it2 ) / 2.0; + dist[0] = mid[0]; + dist[1] = mid[1]; + dist -= clickPosition; + abs = dist.abs( ); + + if( ( minabs > abs ) || ( ns < 0 ) ) + { + minabs = abs; + ns = i; + } + } + ++it1; + ++it2; + } + ++it1; + ++it2; + } + + // add a new segment + QValueList<PMVector> newPoints = m_points; + + if( m_splineType == BezierSpline ) + { + ns /= 4; + ns *= 4; + } + QValueList<PMVector>::Iterator it = newPoints.at( ( unsigned ) ns ); + PMVector p[4]; + QValueList<PMVector>::Iterator hit = it; + + // calculate the spline segment + PMSplineSegment segment; + switch( m_splineType ) + { + case LinearSpline: + for( i = 0; i < 2; ++i, ++hit ) + p[i] = *hit; + segment.calculateLinear( p[0], p[1] ); + break; + case QuadraticSpline: + --hit; + for( i = 0; i < 3; ++i, ++hit ) + p[i] = *hit; + segment.calculateQuadratic( p[0], p[1], p[2] ); + break; + case CubicSpline: + --hit; + for( i = 0; i < 4; ++i, ++hit ) + p[i] = *hit; + segment.calculateCubic( p[0], p[1], p[2], p[3] ); + break; + case BezierSpline: + for( i = 0; i < 4; ++i, ++hit ) + p[i] = *hit; + segment.calculateBezier( p[0], p[1], p[2], p[3] ); + break; + } + + mid = segment.point( 0.5 ); + if( m_splineType != BezierSpline ) + { + ++it; + newPoints.insert( it, mid ); + } + else + { + PMVector end = *it; + ++it; + *it = end + ( *it - end ) / 2.0; + ++it; + + PMVector grad = segment.gradient( 0.5 ) / 4.0; + + newPoints.insert( it, mid - grad ); + newPoints.insert( it, mid ); + newPoints.insert( it, mid ); + newPoints.insert( it, mid + grad ); + + ++it; + end = *it; + --it; + *it = end + ( *it - end ) / 2.0; + } + setPoints( newPoints ); +} + +void PMLathe::joinSegments( const PMControlPointList& /*cp*/, + const QPtrList<PMVector>& cpViewPosition, + const PMVector& clickPosition ) +{ + // find nearest point + int nump = cpViewPosition.count( ) / 2; + int minp = 0; + + switch( m_splineType ) + { + case LinearSpline: + minp = 3; + break; + case QuadraticSpline: + minp = 4; + break; + case CubicSpline: + minp = 5; + break; + case BezierSpline: + minp = 8; + break; + } + + if( nump < minp ) + { + kdError( PMArea ) << "Not enough points in PMLathe::joinSegments\n"; + return; + } + + double abs = 0.0, minabs = 1e10; + int ns = -1; + int i, j; + PMVector* p; + PMVector dist( 2 ); + + QPtrListIterator<PMVector> it1( cpViewPosition ); + + for( j = 0; j < 2; ++j ) + { + for( i = 0; i < nump; ++i ) + { + p = *it1; + dist[0] = (*p)[0]; + dist[1] = (*p)[1]; + dist -= clickPosition; + abs = dist.abs( ); + + if( ( minabs > abs ) || ( ns < 0 ) ) + { + minabs = abs; + ns = i; + } + ++it1; + } + } + + // join two segments + QValueList<PMVector> newPoints = m_points; + QValueList<PMVector>::Iterator it; + + if( m_splineType != BezierSpline ) + { + // never remove the first or last point + if( ns == 0 ) + ++ns; + if( ns == ( nump - 1 ) ) + --ns; + it = newPoints.at( ns ); + newPoints.remove( it ); + } + else + { + ns = ( ns - 2 ) / 4; + if( ns < 0 ) + ns = 0; + if( ns >= ( nump / 4 - 1 ) ) + ns = nump / 4 - 2; + + it = newPoints.at( ns * 4 + 2 ); + for( i = 0; i < 4; ++i ) + it = newPoints.remove( it ); + } + setPoints( newPoints ); +} + +void PMLathe::setRSteps( int r ) +{ + if( r >= 4 ) + s_rSteps = r; + else + kdDebug( PMArea ) << "PMLathe::setRSteps: R must be greater than 3\n"; + ++s_parameterKey; +} + +void PMLathe::setSSteps( int s ) +{ + if( s >= 1 ) + s_sSteps = s; + else + kdDebug( PMArea ) << "PMLathe::setSSteps: S must be greater than 0\n"; + ++s_parameterKey; +} |