kig/misc/builtin_stuff.cc

   1 // Copyright (C)  2003  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 "builtin_stuff.h"
  19
  20 #include <config.h>
  21
  22 #include "object_constructor.h"
  23 #include "lists.h"
  24 #include "special_constructors.h"
  25 #include "guiaction.h"
  26
  27 #include "../objects/angle_type.h"
  28 #include "../objects/arc_type.h"
  29 #include "../objects/circle_type.h"
  30 #include "../objects/conic_types.h"
  31 #include "../objects/cubic_type.h"
  32 #include "../objects/intersection_types.h"
  33 #include "../objects/inversion_type.h"
  34 #include "../objects/line_imp.h"
  35 #include "../objects/line_type.h"
  36 #include "../objects/object_imp.h"
  37 #include "../objects/other_imp.h"
  38 #include "../objects/other_type.h"
  39 #include "../objects/point_type.h"
  40 #include "../objects/tests_type.h"
  41 #include "../objects/transform_types.h"
  42 #include "../objects/vector_type.h"
  43 #include "../objects/polygon_type.h"
  44
  45 #include <klocale.h>
  46
  47 void setupBuiltinStuff()
  48 {
  49   static bool done = false;
  50   if ( ! done )
  51   {
  52     ObjectConstructorList* ctors = ObjectConstructorList::instance();
  53     GUIActionList* actions = GUIActionList::instance();
  54     ObjectConstructor* c = 0;
  55
  56     // segment...
  57     c = new SimpleObjectTypeConstructor(
  58       SegmentABType::instance(), I18N_NOOP( "Segment" ),
  59       I18N_NOOP( "A segment constructed from its start and end point" ),
  60       "segment" );
  61     ctors->add( c );
  62     actions->add( new ConstructibleAction( c, "objects_new_segment", Qt::Key_S ) );
  63
  64     // line by two points..
  65     c = new SimpleObjectTypeConstructor(
  66       LineABType::instance(), I18N_NOOP( "Line by Two Points" ),
  67       I18N_NOOP( "A line constructed through two points"), "line" );
  68     ctors->add( c );
  69     actions->add( new ConstructibleAction( c, "objects_new_linettp", Qt::Key_L ) );
  70
  71     // ray by two points..
  72     c = new SimpleObjectTypeConstructor(
  73       RayABType::instance(), I18N_NOOP( "Half-Line" ),
  74       I18N_NOOP( "A half-line by its start point, and another point somewhere on it." ),
  75       "ray" );
  76     ctors->add( c );
  77     actions->add( new ConstructibleAction( c, "objects_new_ray", Qt::Key_R ) );
  78
  79     // perpendicular line
  80     c = new SimpleObjectTypeConstructor(
  81       LinePerpendLPType::instance(), I18N_NOOP( "Perpendicular" ),
  82       I18N_NOOP( "A line constructed through a point, perpendicular to another line or segment." ),
  83       "perpendicular" );
  84     ctors->add( c );
  85     actions->add( new ConstructibleAction( c, "objects_new_lineperpend" ) );
  86
  87     // parallel line
  88     c = new SimpleObjectTypeConstructor(
  89       LineParallelLPType::instance(), I18N_NOOP( "Parallel" ),
  90       I18N_NOOP( "A line constructed through a point, and parallel to another line or segment" ),
  91       "parallel" );
  92     ctors->add( c );
  93     actions->add( new ConstructibleAction( c, "objects_new_lineparallel" ) );
  94
  95     // circle
  96     c = new SimpleObjectTypeConstructor(
  97       CircleBCPType::instance(), I18N_NOOP( "Circle by Center && Point" ),
  98       I18N_NOOP( "A circle constructed by its center and a point that pertains to it" ),
  99       "circlebcp" );
 100     ctors->add( c );
 101     actions->add( new ConstructibleAction( c, "objects_new_circlebcp", Qt::Key_C ) );
 102
 103     c = new SimpleObjectTypeConstructor(
 104       CircleBTPType::instance(), I18N_NOOP( "Circle by Three Points" ),
 105       I18N_NOOP( "A circle constructed through three points" ),
 106       "circlebtp" );
 107     ctors->add( c );
 108     actions->add( new ConstructibleAction( c, "objects_new_circlebtp" ) );
 109
 110     // declare this object static to this function, so it gets deleted
 111     // at the end of the program, without us having to wonder about
 112     // deleting it..  We don't want to register this
 113     // object-constructor, because that way, "construct the bisector"
 114     // would appear twice in the angle popup menu: once as the generic
 115     // construct a property stuff, and once because of this ctor..
 116     // we only register the guiaction, cause it makes sense to have a
 117     // toolbar icon for this..
 118     static PropertyObjectConstructor anglebisectionctor(
 119       AngleImp::stype(),
 120       I18N_NOOP( "Construct Bisector of This Angle" ),
 121       I18N_NOOP( "Select the angle you want to construct the bisector of..." ),
 122       I18N_NOOP( "Angle Bisector" ),
 123       I18N_NOOP( "The bisector of an angle" ),
 124       "angle-bisector",
 125       "angle-bisector" );
 126     actions->add( new ConstructibleAction( &anglebisectionctor, "objects_new_angle_bisector" ) );
 127
 128     // conic stuff
 129     c = new SimpleObjectTypeConstructor(
 130       ConicB5PType::instance(), I18N_NOOP( "Conic by Five Points" ),
 131       I18N_NOOP( "A conic constructed through five points" ),
 132       "conicb5p" );
 133     ctors->add( c );
 134     actions->add( new ConstructibleAction( c, "objects_new_conicb5p" ) );
 135
 136     c = new SimpleObjectTypeConstructor(
 137       ConicBAAPType::instance(),
 138       I18N_NOOP( "Hyperbola by Asymptotes && Point" ),
 139       I18N_NOOP( "A hyperbola with given asymptotes through a point" ),
 140       "conicbaap" );
 141     ctors->add( c );
 142     actions->add( new ConstructibleAction( c, "objects_new_conicbaap" ) );
 143
 144     c = new SimpleObjectTypeConstructor(
 145       EllipseBFFPType::instance(),
 146       I18N_NOOP( "Ellipse by Focuses && Point" ), // focuses is used in preference to foci
 147       I18N_NOOP( "An ellipse constructed by its focuses and a point that pertains to it" ),
 148       "ellipsebffp" );
 149     ctors->add( c );
 150     actions->add( new ConstructibleAction( c, "objects_new_ellipsebffp" ) );
 151
 152     c = new SimpleObjectTypeConstructor(
 153       HyperbolaBFFPType::instance(),
 154       I18N_NOOP( "Hyperbola by Focuses && Point" ), // focuses is used in preference to foci
 155       I18N_NOOP( "A hyperbola constructed by its focuses and a point that pertains to it" ),
 156       "hyperbolabffp" );
 157     ctors->add( c );
 158     actions->add( new ConstructibleAction( c, "objects_new_hyperbolabffp" ) );
 159
 160     c = new SimpleObjectTypeConstructor(
 161       ConicBDFPType::instance(),
 162       I18N_NOOP( "Conic by Directrix, Focus && Point" ),
 163       I18N_NOOP( "A conic with given directrix and focus, through a point" ),
 164       "conicbdfp" );
 165     ctors->add( c );
 166     actions->add( new ConstructibleAction( c, "objects_new_conicbdfp" ) );
 167
 168     c = new SimpleObjectTypeConstructor(
 169       ParabolaBTPType::instance(),
 170       I18N_NOOP( "Vertical Parabola by Three Points" ),
 171       I18N_NOOP( "A vertical parabola constructed through three points" ),
 172       "parabolabtp" );
 173     ctors->add( c );
 174     actions->add( new ConstructibleAction( c, "objects_new_parabolabtp" ) );
 175
 176     c = new SimpleObjectTypeConstructor(
 177       CubicB9PType::instance(),
 178       I18N_NOOP( "Cubic Curve by Nine Points" ),
 179       I18N_NOOP( "A cubic curve constructed through nine points" ),
 180       "cubicb9p" );
 181     ctors->add( c );
 182     actions->add( new ConstructibleAction( c, "objects_new_cubicb9p" ) );
 183
 184     c = new SimpleObjectTypeConstructor(
 185       ConicPolarPointType::instance(),
 186       I18N_NOOP( "Polar Point of a Line" ),
 187       I18N_NOOP( "The polar point of a line with respect to a conic." ),
 188       "polarpoint" );
 189     ctors->add( c );
 190     actions->add( new ConstructibleAction( c, "objects_new_pointpolar" ) );
 191
 192     c = new SimpleObjectTypeConstructor(
 193       ConicPolarLineType::instance(),
 194       I18N_NOOP( "Polar Line of a Point" ),
 195       I18N_NOOP( "The polar line of a point with respect to a conic." ),
 196       "polarline" );
 197     ctors->add( c );
 198     actions->add( new ConstructibleAction( c, "objects_new_linepolar" ) );
 199
 200     c = new SimpleObjectTypeConstructor(
 201       CubicNodeB6PType::instance(),
 202       I18N_NOOP( "Cubic Curve with Node by Six Points" ),
 203       I18N_NOOP( "A cubic curve with a nodal point at the origin through six points" ),
 204       "cubicnodeb6p" );
 205     ctors->add( c );
 206     actions->add( new ConstructibleAction( c, "objects_new_cubicnodeb6p" ) );
 207
 208     c = new SimpleObjectTypeConstructor(
 209       CubicCuspB4PType::instance(),
 210       I18N_NOOP( "Cubic Curve with Cusp by Four Points" ),
 211       I18N_NOOP( "A cubic curve with a horizontal cusp at the origin through four points" ),
 212       "cubiccuspb4p" );
 213     ctors->add( c );
 214     actions->add( new ConstructibleAction( c, "objects_new_cubiccuspb4p" ) );
 215
 216     c = new SimpleObjectTypeConstructor(
 217       ConicDirectrixType::instance(),
 218       I18N_NOOP( "Directrix of a Conic" ),
 219       I18N_NOOP( "The directrix line of a conic." ),
 220       "directrix" );
 221     ctors->add( c );
 222     actions->add( new ConstructibleAction( c, "objects_new_linedirectrix" ) );
 223
 224     c = new SimpleObjectTypeConstructor(
 225       AngleType::instance(),
 226       I18N_NOOP( "Angle by Three Points" ),
 227       I18N_NOOP( "An angle defined by three points" ),
 228       "angle" );
 229     ctors->add( c );
 230     actions->add( new ConstructibleAction( c, "objects_new_angle", Qt::Key_A ) );
 231
 232     c = new SimpleObjectTypeConstructor(
 233       EquilateralHyperbolaB4PType::instance(),
 234       I18N_NOOP( "Equilateral Hyperbola by Four Points" ),
 235       I18N_NOOP( "An equilateral hyperbola constructed through four points" ),
 236       "equilateralhyperbolab4p" );
 237     ctors->add( c );
 238     actions->add( new ConstructibleAction( c, "objects_new_equilateralhyperbolab4p" ) );
 239
 240     {
 241       // now for the Mid Point action.  It does both the mid point of
 242       // a segment, and the mid point of two points.  The midpoint of
 243       // two segments just shows the mid point property, and therefore
 244       // doesn't need to be added to the ctors, because there are
 245       // already facilities to construct an object's properties..
 246       // therefore, we add only an mpotp to the ctors, and add the
 247       // merged constructor only to the actions..
 248       ctors->add( new MidPointOfTwoPointsConstructor() );
 249
 250       ObjectConstructor* mpotp = new MidPointOfTwoPointsConstructor();
 251       ObjectConstructor* mpos = new PropertyObjectConstructor(
 252         SegmentImp::stype(), I18N_NOOP( "Construct the midpoint of this segment" ),
 253         "", "", "", "", "mid-point" );
 254
 255       // make this a static object, so it gets deleted at the end of
 256       // the program.
 257       static MergeObjectConstructor m(
 258         I18N_NOOP( "Mid Point" ),
 259         I18N_NOOP( "The midpoint of a segment or two other points" ),
 260         "bisection" );
 261       m.merge( mpotp );
 262       m.merge( mpos );
 263       actions->add( new ConstructibleAction( &m, "objects_new_midpoint", Qt::Key_M ) );
 264     };
 265
 266     c = new SimpleObjectTypeConstructor(
 267       VectorType::instance(),
 268       I18N_NOOP( "Vector" ),
 269       I18N_NOOP( "Construct a vector from two given points." ),
 270       "vector" );
 271     ctors->add( c );
 272     actions->add( new ConstructibleAction( c, "objects_new_vector", Qt::Key_V ) );
 273
 274     c = new SimpleObjectTypeConstructor(
 275       VectorSumType::instance(),
 276       I18N_NOOP( "Vector Sum" ),
 277       I18N_NOOP( "Construct the vector sum of two vectors." ),
 278       "vectorsum" );
 279     ctors->add( c );
 280     actions->add( new ConstructibleAction( c, "objects_new_vectorsum", 0 ) );
 281
 282     c = new SimpleObjectTypeConstructor(
 283       LineByVectorType::instance(),
 284       I18N_NOOP( "Line by Vector" ),
 285       I18N_NOOP( "Construct the line by a given vector though a given point." ),
 286       "linebyvector" );
 287     ctors->add( c );
 288     actions->add( new ConstructibleAction( c, "objects_new_linebyvector", 0 ) );
 289
 290     c = new SimpleObjectTypeConstructor(
 291       HalflineByVectorType::instance(),
 292       I18N_NOOP( "Half-Line by Vector" ),
 293       I18N_NOOP( "Construct the half-line by a given vector starting at given point." ),
 294       "halflinebyvector" );
 295     ctors->add( c );
 296     actions->add( new ConstructibleAction( c, "objects_new_halflinebyvector", 0 ) );
 297
 298     c = new SimpleObjectTypeConstructor(
 299       ArcBTPType::instance(),
 300       I18N_NOOP( "Arc by Three Points" ),
 301       I18N_NOOP( "Construct an arc through three points." ),
 302       "arc" );
 303     ctors->add( c );
 304     actions->add( new ConstructibleAction( c, "objects_new_arcbtp" ) );
 305
 306     c = new SimpleObjectTypeConstructor(
 307       ArcBCPAType::instance(),
 308       I18N_NOOP( "Arc by Center, Angle && Point" ),
 309       I18N_NOOP( "Construct an arc by its center and a given angle, "
 310                  "starting at a given point" ),
 311       "arcbcpa" );
 312     ctors->add( c );
 313     actions->add( new ConstructibleAction( c, "objects_new_arcbcpa" ) );
 314
 315     c = new SimpleObjectTypeConstructor(
 316       ParabolaBDPType::instance(),
 317       I18N_NOOP( "Parabola by Directrix && Focus" ),
 318       I18N_NOOP( "A parabola defined by its directrix and focus" ),
 319       "parabolabdp" );
 320     ctors->add( c );
 321     actions->add( new ConstructibleAction( c, "objects_new_parabolabdp" ) );
 322
 323     // Transformation stuff..
 324     c = new InversionConstructor();
 325     ctors->add( c );
 326     actions->add( new ConstructibleAction( c, "objects_new_inversion" ) );
 327
 328     c = new SimpleObjectTypeConstructor(
 329       TranslatedType::instance(),
 330       I18N_NOOP( "Translate" ),
 331       I18N_NOOP( "The translation of an object by a vector" ),
 332       "translation" );
 333     ctors->add( c );
 334     actions->add( new ConstructibleAction( c, "objects_new_translation" ) );
 335
 336     c = new SimpleObjectTypeConstructor(
 337       PointReflectionType::instance(),
 338       I18N_NOOP( "Reflect in Point" ),
 339       I18N_NOOP( "An object reflected in a point" ),
 340       "centralsymmetry" );
 341     ctors->add( c );
 342     actions->add( new ConstructibleAction( c, "objects_new_pointreflection" ) );
 343
 344     c = new SimpleObjectTypeConstructor(
 345       LineReflectionType::instance(),
 346       I18N_NOOP( "Reflect in Line" ),
 347       I18N_NOOP( "An object reflected in a line" ),
 348       "mirrorpoint" );
 349     ctors->add( c );
 350     actions->add( new ConstructibleAction( c, "objects_new_linereflection" ) );
 351
 352     c = new SimpleObjectTypeConstructor(
 353       RotationType::instance(),
 354       I18N_NOOP( "Rotate" ),
 355       I18N_NOOP( "An object rotated by an angle around a point" ),
 356       "rotation" );
 357     ctors->add( c );
 358     actions->add( new ConstructibleAction( c, "objects_new_rotation" ) );
 359
 360     c = new SimpleObjectTypeConstructor(
 361       ScalingOverCenterType::instance(),
 362       I18N_NOOP( "Scale" ),
 363       I18N_NOOP( "Scale an object over a point, by the ratio given by the length of a segment" ),
 364       "scale" );
 365     ctors->add( c );
 366     actions->add( new ConstructibleAction( c, "objects_new_scalingovercenter" ) );
 367
 368     c = new SimpleObjectTypeConstructor(
 369       ScalingOverLineType::instance(),
 370       I18N_NOOP( "Scale over Line" ),
 371       I18N_NOOP( "An object scaled over a line, by the ratio given by the length of a segment" ),
 372       "stretch" );
 373     ctors->add( c );
 374     actions->add( new ConstructibleAction( c, "objects_new_scalingoverline" ) );
 375
 376     c = new SimpleObjectTypeConstructor(
 377       ScalingOverCenter2Type::instance(),
 378       I18N_NOOP( "Scale (ratio given by two segments)" ),
 379       I18N_NOOP( "Scale an object over a point, by the ratio given by the length of two segments" ),
 380       "scale" );
 381     ctors->add( c );
 382     actions->add( new ConstructibleAction( c, "objects_new_scalingovercenter2" ) );
 383
 384     c = new SimpleObjectTypeConstructor(
 385       ScalingOverLine2Type::instance(),
 386       I18N_NOOP( "Scale over Line (ratio given by two segments)" ),
 387       I18N_NOOP( "An object scaled over a line, by the ratio given by the length of two segments" ),
 388       "stretch" );
 389     ctors->add( c );
 390     actions->add( new ConstructibleAction( c, "objects_new_scalingoverline2" ) );
 391
 392     c = new SimpleObjectTypeConstructor(
 393       SimilitudeType::instance(),
 394       I18N_NOOP( "Apply Similitude" ),
 395       I18N_NOOP( "Apply a similitude to an object ( the sequence of a scaling and rotation around a center )" ),
 396       "similitude" );
 397     ctors->add( c );
 398     actions->add( new ConstructibleAction( c, "objects_new_similitude" ) );
 399
 400     c = new SimpleObjectTypeConstructor(
 401       HarmonicHomologyType::instance(),
 402       I18N_NOOP( "Harmonic Homology" ),
 403       I18N_NOOP( "The harmonic homology with a given center and a given axis (this is a projective transformation)" ),
 404       "harmonichomology" );
 405     ctors->add( c );
 406     actions->add( new ConstructibleAction( c, "objects_new_harmonichomology" ) );
 407
 408     c = new GenericAffinityConstructor();
 409     ctors->add( c );
 410     actions->add( new ConstructibleAction( c, "objects_new_genericaffinity" ) );
 411
 412     c = new GenericProjectivityConstructor();
 413     ctors->add( c );
 414     actions->add( new ConstructibleAction( c, "objects_new_genericprojectivity" ) );
 415
 416     c = new SimpleObjectTypeConstructor(
 417       CastShadowType::instance(),
 418       I18N_NOOP( "Draw Projective Shadow" ),
 419       I18N_NOOP( "The shadow of an object with a given light source and projection plane (indicated by a line)" ),
 420       "castshadow" );
 421     ctors->add( c );
 422     actions->add( new ConstructibleAction( c, "objects_new_castshadow" ) );
 423
 424 //     c = new SimpleObjectTypeConstructor(
 425 //       ProjectiveRotationType::instance(),
 426 //       I18N_NOOP( "Rotate Projectively" ),
 427 //       I18N_NOOP( "An object projectively rotated by an angle and a half-line" ),
 428 //       "projectiverotation" );
 429 //     ctors->add( c );
 430 //     actions->add( new ConstructibleAction( c, "objects_new_projectiverotation" ) );
 431
 432     c = new MultiObjectTypeConstructor(
 433       ConicAsymptoteType::instance(),
 434       I18N_NOOP( "Asymptotes of a Hyperbola" ),
 435       I18N_NOOP( "The two asymptotes of a hyperbola." ),
 436       "conicasymptotes", -1, 1 );
 437     ctors->add( c );
 438     actions->add( new ConstructibleAction( c, "objects_new_lineconicasymptotes" ) );
 439
 440     c = new ConicRadicalConstructor();
 441     ctors->add( c );
 442     actions->add( new ConstructibleAction( c, "objects_new_lineconicradical") );
 443
 444     /* ----------- start polygons --------- */
 445
 446     c = new SimpleObjectTypeConstructor(
 447       TriangleB3PType::instance(),
 448       I18N_NOOP( "Triangle by Its Vertices" ),
 449       I18N_NOOP( "Construct a triangle given its three vertices." ),
 450       "triangle" );
 451     ctors->add( c );
 452     actions->add( new ConstructibleAction( c, "objects_new_trianglebtp" ) );
 453
 454     c = new PolygonBNPTypeConstructor();
 455     ctors->add( c );
 456     actions->add( new ConstructibleAction( c, "objects_new_polygonbnp" ));
 457
 458     c = new PolygonBCVConstructor();
 459     ctors->add( c );
 460     actions->add( new ConstructibleAction( c, "objects_new_polygonbcv" ) );
 461
 462     c = new PolygonVertexTypeConstructor();
 463     ctors->add( c );
 464     actions->add( new ConstructibleAction( c, "objects_new_polygonvertices" ));
 465
 466     c = new PolygonSideTypeConstructor();
 467     ctors->add( c );
 468     actions->add( new ConstructibleAction( c, "objects_new_polygonsides" ));
 469
 470     c = new SimpleObjectTypeConstructor(
 471       ConvexHullType::instance(), I18N_NOOP( "Convex Hull" ),
 472       I18N_NOOP( "A polygon that corresponds to the convex hull of another polygon" ),
 473       "convexhull" );
 474     ctors->add( c );
 475     actions->add( new ConstructibleAction( c, "objects_new_convexhull" ) );
 476
 477     /* ----------- end polygons --------- */
 478
 479     c = new LocusConstructor();
 480     ctors->add( c );
 481     actions->add( new ConstructibleAction( c, "objects_new_locus" ) );
 482
 483     // tests
 484     c = new TestConstructor(
 485       AreParallelType::instance(),
 486       I18N_NOOP( "Parallel Test" ),
 487       I18N_NOOP( "Test whether two given lines are parallel" ),
 488       "testparallel" );
 489     ctors->add( c );
 490     actions->add( new ConstructibleAction( c, "objects_new_areparallel" ) );
 491
 492     c = new TestConstructor(
 493       AreOrthogonalType::instance(),
 494       I18N_NOOP( "Orthogonal Test" ),
 495       I18N_NOOP( "Test whether two given lines are orthogonal" ),
 496       "testorthogonal" );
 497     ctors->add( c );
 498     actions->add( new ConstructibleAction( c, "objects_new_areorthogonal" ) );
 499
 500     c = new TestConstructor(
 501       AreCollinearType::instance(),
 502       I18N_NOOP( "Collinear Test" ),
 503       I18N_NOOP( "Test whether three given points are collinear" ),
 504       "testcollinear" );
 505     ctors->add( c );
 506     actions->add( new ConstructibleAction( c, "objects_new_arecollinear" ) );
 507
 508     c = new TestConstructor(
 509       ContainsTestType::instance(),
 510       I18N_NOOP( "Contains Test" ),
 511       I18N_NOOP( "Test whether a given curve contains a given point" ),
 512       "testcontains" );
 513     ctors->add( c );
 514     actions->add( new ConstructibleAction( c, "objects_new_containstest" ) );
 515
 516     c = new TestConstructor(
 517       InPolygonTestType::instance(),
 518       I18N_NOOP( "In Polygon Test" ),
 519       I18N_NOOP( "Test whether a given polygon contains a given point" ),
 520       "test" );
 521     ctors->add( c );
 522     actions->add( new ConstructibleAction( c, "objects_new_inpolygontest" ) );
 523
 524     c = new TestConstructor(
 525       ConvexPolygonTestType::instance(),
 526       I18N_NOOP( "Convex Polygon Test" ),
 527       I18N_NOOP( "Test whether a given polygon is convex" ),
 528       "test" );
 529     ctors->add( c );
 530     actions->add( new ConstructibleAction( c, "objects_new_convexpolygontest" ) );
 531
 532     c = new TestConstructor(
 533       SameDistanceType::instance(),
 534       I18N_NOOP( "Distance Test" ),
 535       I18N_NOOP( "Test whether a given point have the same distance from a given point "
 536                  "and from another given point" ),
 537       "test" );
 538 //      "testdistance" );
 539     ctors->add( c );
 540     actions->add( new ConstructibleAction( c, "objects_new_distancetest" ) );
 541
 542     c = new TestConstructor(
 543       VectorEqualityTestType::instance(),
 544       I18N_NOOP( "Vector Equality Test" ),
 545       I18N_NOOP( "Test whether two vectors are equal" ),
 546       "test" );
 547 //      "testequal" );
 548     ctors->add( c );
 549     actions->add( new ConstructibleAction( c, "objects_new_vectorequalitytest" ) );
 550
 551     c = new MeasureTransportConstructor();
 552     ctors->add( c );
 553     actions->add( new ConstructibleAction( c, "objects_new_measuretransport" ));
 554
 555 //    c = new SimpleObjectTypeConstructor(
 556 //      MeasureTransportType::instance(),
 557 //      I18N_NOOP( "Measure Transport" ),
 558 //      I18N_NOOP( "Transport the measure of a segment or arc over a line or circle." ),
 559 //      "measuretransport" );
 560 //    ctors->add( c );
 561 //    actions->add( new ConstructibleAction( c, "objects_new_measuretransport" ) );
 562
 563     // the generic intersection constructor..
 564     c = new GenericIntersectionConstructor();
 565     ctors->add( c );
 566     actions->add( new ConstructibleAction( c, "objects_new_intersection", Qt::Key_I ) );
 567
 568     // the generic tangent constructor
 569     c = new TangentConstructor();
 570     ctors->add( c );
 571     actions->add( new ConstructibleAction( c, "objects_new_tangent", Qt::Key_T ) );
 572
 573     // the generic center of curvature constructor
 574     c = new CocConstructor();
 575     ctors->add( c );
 576     actions->add( new ConstructibleAction( c, "objects_new_centerofcurvature" ) );
 577
 578     actions->add( new ConstructPointAction( "objects_new_normalpoint" ) );
 579     actions->add( new ConstructTextLabelAction( "objects_new_textlabel" ) );
 580     actions->add( new AddFixedPointAction( "objects_new_point_xy" ) );
 581
 582 #ifdef KIG_ENABLE_PYTHON_SCRIPTING
 583 #include "../scripting/script-common.h"
 584     actions->add( new NewScriptAction(
 585                         I18N_NOOP( "Python Script" ),
 586                         I18N_NOOP( "Construct a new Python script." ),
 587                         "objects_new_script_python",
 588                         ScriptType::Python ) );
 589 #endif
 590
 591 #if 0
 592     actions->add( new TestAction( "test_stuff" ) );
 593 #endif
 594   };
 595
 596   done = true;
 597 }