From ce599e4f9f94b4eb00c1b5edb85bce5431ab3df2 Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdeedu@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- kig/objects/line_type.cc | 334 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 334 insertions(+) create mode 100644 kig/objects/line_type.cc (limited to 'kig/objects/line_type.cc') diff --git a/kig/objects/line_type.cc b/kig/objects/line_type.cc new file mode 100644 index 00000000..a2c0734b --- /dev/null +++ b/kig/objects/line_type.cc @@ -0,0 +1,334 @@ +// Copyright (C) 2002 Dominique Devriese + +// 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. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +// 02110-1301, USA. + +#include "line_type.h" + +#include "bogus_imp.h" +#include "line_imp.h" +#include "object_holder.h" +#include "other_imp.h" +#include "point_imp.h" + +#include "../kig/kig_view.h" +#include "../kig/kig_part.h" +#include "../kig/kig_commands.h" +#include "../misc/common.h" +#include "../misc/calcpaths.h" + +#include + +#include + +static const ArgsParser::spec argsspecSegmentAB[] = +{ + { PointImp::stype(), I18N_NOOP( "Construct a segment starting at this point" ), + I18N_NOOP( "Select the start point of the new segment..." ), true }, + { PointImp::stype(), I18N_NOOP( "Construct a segment ending at this point" ), + I18N_NOOP( "Select the end point of the new segment..." ), true } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( SegmentABType ) + +SegmentABType::SegmentABType() + : ObjectABType( "SegmentAB", argsspecSegmentAB, 2 ) +{ +} + +SegmentABType::~SegmentABType() +{ +} + +const SegmentABType* SegmentABType::instance() +{ + static const SegmentABType s; + return &s; +} + +ObjectImp* SegmentABType::calc( const Coordinate& a, const Coordinate& b ) const +{ + return new SegmentImp( a, b ); +} + +static const char constructlineabstat[] = I18N_NOOP( "Construct a line through this point" ); + +static const ArgsParser::spec argsspecLineAB[] = +{ + { PointImp::stype(), constructlineabstat, + I18N_NOOP( "Select a point for the line to go through..." ), true }, + { PointImp::stype(), constructlineabstat, + I18N_NOOP( "Select another point for the line to go through..." ), true } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( LineABType ) + +LineABType::LineABType() + : ObjectABType( "LineAB", argsspecLineAB, 2 ) +{ +} + +LineABType::~LineABType() +{ +} + +const LineABType* LineABType::instance() +{ + static const LineABType s; + return &s; +} + +ObjectImp* LineABType::calc( const Coordinate& a, const Coordinate& b ) const +{ + return new LineImp( a, b ); +} + +static const char constructhalflinestartingstat[] = I18N_NOOP( "Construct a half-line starting at this point" ); + +static const ArgsParser::spec argsspecRayAB[] = +{ + { PointImp::stype(), constructhalflinestartingstat, + I18N_NOOP( "Select the start point of the new half-line..." ), true }, + { PointImp::stype(), I18N_NOOP( "Construct a half-line through this point" ), + I18N_NOOP( "Select a point for the half-line to go through..." ), true } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( RayABType ) + +RayABType::RayABType() + : ObjectABType( "RayAB", argsspecRayAB, 2 ) +{ +} + +RayABType::~RayABType() +{ +} + +const RayABType* RayABType::instance() +{ + static const RayABType s; + return &s; +} + +ObjectImp* RayABType::calc( const Coordinate& a, const Coordinate& b ) const +{ + return new RayImp( a, b ); +} + +LinePerpendLPType* LinePerpendLPType::instance() +{ + static LinePerpendLPType l; + return &l; +} + +ObjectImp* LinePerpendLPType::calc( + const LineData& a, + const Coordinate& b ) const +{ + Coordinate p = calcPointOnPerpend( a, b ); + return new LineImp( b, p ); +} + +static const ArgsParser::spec argsspecLineParallel[] = +{ + { AbstractLineImp::stype(), I18N_NOOP( "Construct a line parallel to this line" ), + I18N_NOOP( "Select a line parallel to the new line..." ), false }, + { PointImp::stype(), I18N_NOOP( "Construct the parallel line through this point" ), + I18N_NOOP( "Select a point for the new line to go through..." ), true } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( LineParallelLPType ) + +LineParallelLPType::LineParallelLPType() + : ObjectLPType( "LineParallel", argsspecLineParallel, 2 ) +{ +} + +LineParallelLPType::~LineParallelLPType() +{ +} + +LineParallelLPType* LineParallelLPType::instance() +{ + static LineParallelLPType l; + return &l; +} + +ObjectImp* LineParallelLPType::calc( + const LineData& a, + const Coordinate& b ) const +{ + Coordinate r = calcPointOnParallel( a, b ); + return new LineImp( r, b ); +} + +static const ArgsParser::spec argsspecLinePerpend[] = +{ + { AbstractLineImp::stype(), I18N_NOOP( "Construct a line perpendicular to this line" ), + I18N_NOOP( "Select a line perpendicular to the new line..." ), false }, + { PointImp::stype(), I18N_NOOP( "Construct a perpendicular line through this point" ), + I18N_NOOP( "Select a point for the new line to go through..." ), true } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( LinePerpendLPType ) + +LinePerpendLPType::LinePerpendLPType() + : ObjectLPType( "LinePerpend", argsspecLinePerpend, 2 ) +{ +} + +LinePerpendLPType::~LinePerpendLPType() +{ +} + +const ObjectImpType* SegmentABType::resultId() const +{ + return SegmentImp::stype(); +} + +const ObjectImpType* LineABType::resultId() const +{ + return LineImp::stype(); +} + +const ObjectImpType* RayABType::resultId() const +{ + return RayImp::stype(); +} + +const ObjectImpType* LinePerpendLPType::resultId() const +{ + return LineImp::stype(); +} + +const ObjectImpType* LineParallelLPType::resultId() const +{ + return LineImp::stype(); +} + +QStringList SegmentABType::specialActions() const +{ + QStringList ret; + ret << i18n( "Set &Length..." ); + return ret; +} + +void SegmentABType::executeAction( int i, ObjectHolder&, ObjectTypeCalcer& c, + KigPart& d, KigWidget& w, NormalMode& ) const +{ + assert( i == 0 ); + // pretend to use this var.. + (void) i; + + std::vector parents = c.parents(); + assert( margsparser.checkArgs( parents ) ); + + Coordinate a = static_cast( parents[0]->imp() )->coordinate(); + Coordinate b = static_cast( parents[1]->imp() )->coordinate(); + + bool ok = true; + double length = getDoubleFromUser( + i18n( "Set Segment Length" ), i18n( "Choose the new length: " ), + (b-a).length(), &w, &ok, -2147483647, 2147483647, 3 ); + if ( ! ok ) return; + + Coordinate nb = a + ( b - a ).normalize( length ); + + MonitorDataObjects mon( getAllParents( parents ) ); + parents[1]->move( nb, d.document() ); + KigCommand* cd = new KigCommand( d, i18n( "Resize Segment" ) ); + mon.finish( cd ); + d.history()->addCommand( cd ); +} + +static const ArgsParser::spec argsspecLineByVector[] = +{ + { VectorImp::stype(), I18N_NOOP( "Construct a line by this vector" ), + I18N_NOOP( "Select a vector in the direction of the new line..." ), true }, + { PointImp::stype(), constructlineabstat, + I18N_NOOP( "Select a point for the new line to go through..." ), true } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( LineByVectorType ) + +LineByVectorType::LineByVectorType() + : ArgsParserObjectType( "LineByVector", argsspecLineByVector, 2 ) +{ +} + +LineByVectorType::~LineByVectorType() +{ +} + +const LineByVectorType* LineByVectorType::instance() +{ + static const LineByVectorType s; + return &s; +} + +ObjectImp* LineByVectorType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + const VectorImp& a = *static_cast( args[0] ); + const PointImp& b = *static_cast( args[1] ); + + return new LineImp( b.coordinate(), b.coordinate() + a.dir() ); +} + +const ObjectImpType* LineByVectorType::resultId() const +{ + return LineImp::stype(); +} + +static const ArgsParser::spec argsspecHalflineByVector[] = +{ + { VectorImp::stype(), I18N_NOOP( "Construct a half-line by this vector" ), + I18N_NOOP( "Select a vector in the direction of the new half-line..." ), true }, + { PointImp::stype(), constructhalflinestartingstat, + I18N_NOOP( "Select the start point of the new half-line..." ), true } +}; + +KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( HalflineByVectorType ) + +HalflineByVectorType::HalflineByVectorType() + : ArgsParserObjectType( "HalflineByVector", argsspecHalflineByVector, 2 ) +{ +} + +HalflineByVectorType::~HalflineByVectorType() +{ +} + +const HalflineByVectorType* HalflineByVectorType::instance() +{ + static const HalflineByVectorType s; + return &s; +} + +ObjectImp* HalflineByVectorType::calc( const Args& args, const KigDocument& ) const +{ + if ( ! margsparser.checkArgs( args ) ) return new InvalidImp; + + const VectorImp& a = *static_cast( args[0] ); + const PointImp& b = *static_cast( args[1] ); + + return new RayImp( b.coordinate(), b.coordinate() + a.dir() ); +} + +const ObjectImpType* HalflineByVectorType::resultId() const +{ + return RayImp::stype(); +} -- cgit v1.2.1