kig/objects/line_type.cc

   1 // Copyright (C)  2002  Dominique Devriese <devriese@kde.org>
   2
   3 // This program is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU General Public License
   5 // as published by the Free Software Foundation; either version 2
   6 // of the License, or (at your option) any later version.
   7
   8 // This program is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 // GNU General Public License for more details.
  12
  13 // You should have received a copy of the GNU General Public License
  14 // along with this program; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  16 // 02111-1307, USA.
  17
  18 #include "line_type.h"
  19
  20 #include "bogus_imp.h"
  21 #include "line_imp.h"
  22 #include "object_holder.h"
  23 #include "other_imp.h"
  24 #include "point_imp.h"
  25
  26 #include "../kig/kig_view.h"
  27 #include "../kig/kig_part.h"
  28 #include "../kig/kig_commands.h"
  29 #include "../misc/common.h"
  30 #include "../misc/calcpaths.h"
  31
  32 #include <qstringlist.h>
  33
  34 #include <klocale.h>
  35
  36 static const ArgsParser::spec argsspecSegmentAB[] =
  37 {
  38   { PointImp::stype(), I18N_NOOP( "Construct a segment starting at this point" ),
  39     I18N_NOOP( "Select the start point of the new segment..." ), true },
  40   { PointImp::stype(), I18N_NOOP( "Construct a segment ending at this point" ),
  41     I18N_NOOP( "Select the end point of the new segment..." ), true }
  42 };
  43
  44 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( SegmentABType )
  45
  46 SegmentABType::SegmentABType()
  47   : ObjectABType( "SegmentAB", argsspecSegmentAB, 2 )
  48 {
  49 }
  50
  51 SegmentABType::~SegmentABType()
  52 {
  53 }
  54
  55 const SegmentABType* SegmentABType::instance()
  56 {
  57   static const SegmentABType s;
  58   return &s;
  59 }
  60
  61 ObjectImp* SegmentABType::calc( const Coordinate& a, const Coordinate& b ) const
  62 {
  63   return new SegmentImp( a, b );
  64 }
  65
  66 static const char constructlineabstat[] = I18N_NOOP( "Construct a line through this point" );
  67
  68 static const ArgsParser::spec argsspecLineAB[] =
  69 {
  70   { PointImp::stype(), constructlineabstat,
  71     I18N_NOOP( "Select a point for the line to go through..." ), true },
  72   { PointImp::stype(), constructlineabstat,
  73     I18N_NOOP( "Select another point for the line to go through..." ), true }
  74 };
  75
  76 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( LineABType )
  77
  78 LineABType::LineABType()
  79   : ObjectABType( "LineAB", argsspecLineAB, 2 )
  80 {
  81 }
  82
  83 LineABType::~LineABType()
  84 {
  85 }
  86
  87 const LineABType* LineABType::instance()
  88 {
  89   static const LineABType s;
  90   return &s;
  91 }
  92
  93 ObjectImp* LineABType::calc( const Coordinate& a, const Coordinate& b ) const
  94 {
  95   return new LineImp( a, b );
  96 }
  97
  98 static const char constructhalflinestartingstat[] = I18N_NOOP( "Construct a half-line starting at this point" );
  99
 100 static const ArgsParser::spec argsspecRayAB[] =
 101 {
 102   { PointImp::stype(), constructhalflinestartingstat,
 103     I18N_NOOP( "Select the start point of the new half-line..." ), true },
 104   { PointImp::stype(), I18N_NOOP( "Construct a half-line through this point" ),
 105     I18N_NOOP( "Select a point for the half-line to go through..." ), true }
 106 };
 107
 108 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( RayABType )
 109
 110 RayABType::RayABType()
 111   : ObjectABType( "RayAB", argsspecRayAB, 2 )
 112 {
 113 }
 114
 115 RayABType::~RayABType()
 116 {
 117 }
 118
 119 const RayABType* RayABType::instance()
 120 {
 121   static const RayABType s;
 122   return &s;
 123 }
 124
 125 ObjectImp* RayABType::calc( const Coordinate& a, const Coordinate& b ) const
 126 {
 127   return new RayImp( a, b );
 128 }
 129
 130 LinePerpendLPType* LinePerpendLPType::instance()
 131 {
 132   static LinePerpendLPType l;
 133   return &l;
 134 }
 135
 136 ObjectImp* LinePerpendLPType::calc(
 137   const LineData& a,
 138   const Coordinate& b ) const
 139 {
 140   Coordinate p = calcPointOnPerpend( a, b );
 141   return new LineImp( b, p );
 142 }
 143
 144 static const ArgsParser::spec argsspecLineParallel[] =
 145 {
 146   { AbstractLineImp::stype(), I18N_NOOP( "Construct a line parallel to this line" ),
 147     I18N_NOOP( "Select a line parallel to the new line..." ), false },
 148   { PointImp::stype(), I18N_NOOP( "Construct the parallel line through this point" ),
 149     I18N_NOOP( "Select a point for the new line to go through..." ), true }
 150 };
 151
 152 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( LineParallelLPType )
 153
 154 LineParallelLPType::LineParallelLPType()
 155   : ObjectLPType( "LineParallel", argsspecLineParallel, 2 )
 156 {
 157 }
 158
 159 LineParallelLPType::~LineParallelLPType()
 160 {
 161 }
 162
 163 LineParallelLPType* LineParallelLPType::instance()
 164 {
 165   static LineParallelLPType l;
 166   return &l;
 167 }
 168
 169 ObjectImp* LineParallelLPType::calc(
 170   const LineData& a,
 171   const Coordinate& b ) const
 172 {
 173   Coordinate r = calcPointOnParallel( a, b );
 174   return new LineImp( r, b );
 175 }
 176
 177 static const ArgsParser::spec argsspecLinePerpend[] =
 178 {
 179   { AbstractLineImp::stype(), I18N_NOOP( "Construct a line perpendicular to this line" ),
 180     I18N_NOOP( "Select a line perpendicular to the new line..." ), false },
 181   { PointImp::stype(), I18N_NOOP( "Construct a perpendicular line through this point" ),
 182     I18N_NOOP( "Select a point for the new line to go through..." ), true }
 183 };
 184
 185 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( LinePerpendLPType )
 186
 187 LinePerpendLPType::LinePerpendLPType()
 188   : ObjectLPType( "LinePerpend", argsspecLinePerpend, 2 )
 189 {
 190 }
 191
 192 LinePerpendLPType::~LinePerpendLPType()
 193 {
 194 }
 195
 196 const ObjectImpType* SegmentABType::resultId() const
 197 {
 198   return SegmentImp::stype();
 199 }
 200
 201 const ObjectImpType* LineABType::resultId() const
 202 {
 203   return LineImp::stype();
 204 }
 205
 206 const ObjectImpType* RayABType::resultId() const
 207 {
 208   return RayImp::stype();
 209 }
 210
 211 const ObjectImpType* LinePerpendLPType::resultId() const
 212 {
 213   return LineImp::stype();
 214 }
 215
 216 const ObjectImpType* LineParallelLPType::resultId() const
 217 {
 218   return LineImp::stype();
 219 }
 220
 221 QStringList SegmentABType::specialActions() const
 222 {
 223   QStringList ret;
 224   ret << i18n( "Set &Length..." );
 225   return ret;
 226 }
 227
 228 void SegmentABType::executeAction( int i, ObjectHolder&, ObjectTypeCalcer& c,
 229                                    KigPart& d, KigWidget& w, NormalMode& ) const
 230 {
 231   assert( i == 0 );
 232   // pretend to use this var..
 233   (void) i;
 234
 235   std::vector<ObjectCalcer*> parents = c.parents();
 236   assert( margsparser.checkArgs( parents ) );
 237
 238   Coordinate a = static_cast<const PointImp*>( parents[0]->imp() )->coordinate();
 239   Coordinate b = static_cast<const PointImp*>( parents[1]->imp() )->coordinate();
 240
 241   bool ok = true;
 242   double length = getDoubleFromUser(
 243     i18n( "Set Segment Length" ), i18n( "Choose the new length: " ),
 244     (b-a).length(), &w, &ok, -2147483647, 2147483647, 3 );
 245   if ( ! ok ) return;
 246
 247   Coordinate nb = a + ( b - a ).normalize( length );
 248
 249   MonitorDataObjects mon( getAllParents( parents ) );
 250   parents[1]->move( nb, d.document() );
 251   KigCommand* cd = new KigCommand( d, i18n( "Resize Segment" ) );
 252   mon.finish( cd );
 253   d.history()->addCommand( cd );
 254 }
 255
 256 static const ArgsParser::spec argsspecLineByVector[] =
 257 {
 258   { VectorImp::stype(), I18N_NOOP( "Construct a line by this vector" ),
 259     I18N_NOOP( "Select a vector in the direction of the new line..." ), true },
 260   { PointImp::stype(), constructlineabstat,
 261     I18N_NOOP( "Select a point for the new line to go through..." ), true }
 262 };
 263
 264 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( LineByVectorType )
 265
 266 LineByVectorType::LineByVectorType()
 267   : ArgsParserObjectType( "LineByVector", argsspecLineByVector, 2 )
 268 {
 269 }
 270
 271 LineByVectorType::~LineByVectorType()
 272 {
 273 }
 274
 275 const LineByVectorType* LineByVectorType::instance()
 276 {
 277   static const LineByVectorType s;
 278   return &s;
 279 }
 280
 281 ObjectImp* LineByVectorType::calc( const Args& args, const KigDocument& ) const
 282 {
 283   if ( ! margsparser.checkArgs( args ) ) return new InvalidImp;
 284
 285   const VectorImp& a = *static_cast<const VectorImp*>( args[0] );
 286   const PointImp& b = *static_cast<const PointImp*>( args[1] );
 287
 288   return new LineImp(  b.coordinate(), b.coordinate() + a.dir() );
 289 }
 290
 291 const ObjectImpType* LineByVectorType::resultId() const
 292 {
 293   return LineImp::stype();
 294 }
 295
 296 static const ArgsParser::spec argsspecHalflineByVector[] =
 297 {
 298   { VectorImp::stype(), I18N_NOOP( "Construct a half-line by this vector" ),
 299     I18N_NOOP( "Select a vector in the direction of the new half-line..." ), true },
 300   { PointImp::stype(), constructhalflinestartingstat,
 301     I18N_NOOP( "Select the start point of the new half-line..." ), true }
 302 };
 303
 304 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( HalflineByVectorType )
 305
 306 HalflineByVectorType::HalflineByVectorType()
 307   : ArgsParserObjectType( "HalflineByVector", argsspecHalflineByVector, 2 )
 308 {
 309 }
 310
 311 HalflineByVectorType::~HalflineByVectorType()
 312 {
 313 }
 314
 315 const HalflineByVectorType* HalflineByVectorType::instance()
 316 {
 317   static const HalflineByVectorType s;
 318   return &s;
 319 }
 320
 321 ObjectImp* HalflineByVectorType::calc( const Args& args, const KigDocument& ) const
 322 {
 323   if ( ! margsparser.checkArgs( args ) ) return new InvalidImp;
 324
 325   const VectorImp& a = *static_cast<const VectorImp*>( args[0] );
 326   const PointImp& b = *static_cast<const PointImp*>( args[1] );
 327
 328   return new RayImp(  b.coordinate(), b.coordinate() + a.dir() );
 329 }
 330
 331 const ObjectImpType* HalflineByVectorType::resultId() const
 332 {
 333   return RayImp::stype();
 334 }