You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdeedu/kig/misc/builtin_stuff.cpp

597 lines
23 KiB

// Copyright (C) 2003 Dominique Devriese <devriese@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.
// 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 "builtin_stuff.h"
#include <config.h>
#include "object_constructor.h"
#include "lists.h"
#include "special_constructors.h"
#include "guiaction.h"
#include "../objects/angle_type.h"
#include "../objects/arc_type.h"
#include "../objects/circle_type.h"
#include "../objects/conic_types.h"
#include "../objects/cubic_type.h"
#include "../objects/intersection_types.h"
#include "../objects/inversion_type.h"
#include "../objects/line_imp.h"
#include "../objects/line_type.h"
#include "../objects/object_imp.h"
#include "../objects/other_imp.h"
#include "../objects/other_type.h"
#include "../objects/point_type.h"
#include "../objects/tests_type.h"
#include "../objects/transform_types.h"
#include "../objects/vector_type.h"
#include "../objects/polygon_type.h"
#include <tdelocale.h>
void setupBuiltinStuff()
{
static bool done = false;
if ( ! done )
{
ObjectConstructorList* ctors = ObjectConstructorList::instance();
GUIActionList* actions = GUIActionList::instance();
ObjectConstructor* c = 0;
// segment...
c = new SimpleObjectTypeConstructor(
SegmentABType::instance(), I18N_NOOP( "Segment" ),
I18N_NOOP( "A segment constructed from its start and end point" ),
"segment" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_segment", TQt::Key_S ) );
// line by two points..
c = new SimpleObjectTypeConstructor(
LineABType::instance(), I18N_NOOP( "Line by Two Points" ),
I18N_NOOP( "A line constructed through two points"), "line" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_linettp", TQt::Key_L ) );
// ray by two points..
c = new SimpleObjectTypeConstructor(
RayABType::instance(), I18N_NOOP( "Half-Line" ),
I18N_NOOP( "A half-line by its start point, and another point somewhere on it." ),
"ray" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_ray", TQt::Key_R ) );
// perpendicular line
c = new SimpleObjectTypeConstructor(
LinePerpendLPType::instance(), I18N_NOOP( "Perpendicular" ),
I18N_NOOP( "A line constructed through a point, perpendicular to another line or segment." ),
"perpendicular" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_lineperpend" ) );
// parallel line
c = new SimpleObjectTypeConstructor(
LineParallelLPType::instance(), I18N_NOOP( "Parallel" ),
I18N_NOOP( "A line constructed through a point, and parallel to another line or segment" ),
"parallel" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_lineparallel" ) );
// circle
c = new SimpleObjectTypeConstructor(
CircleBCPType::instance(), I18N_NOOP( "Circle by Center && Point" ),
I18N_NOOP( "A circle constructed by its center and a point that pertains to it" ),
"circlebcp" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_circlebcp", TQt::Key_C ) );
c = new SimpleObjectTypeConstructor(
CircleBTPType::instance(), I18N_NOOP( "Circle by Three Points" ),
I18N_NOOP( "A circle constructed through three points" ),
"circlebtp" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_circlebtp" ) );
// declare this object static to this function, so it gets deleted
// at the end of the program, without us having to wonder about
// deleting it.. We don't want to register this
// object-constructor, because that way, "construct the bisector"
// would appear twice in the angle popup menu: once as the generic
// construct a property stuff, and once because of this ctor..
// we only register the guiaction, cause it makes sense to have a
// toolbar icon for this..
static PropertyObjectConstructor anglebisectionctor(
AngleImp::stype(),
I18N_NOOP( "Construct Bisector of This Angle" ),
I18N_NOOP( "Select the angle you want to construct the bisector of..." ),
I18N_NOOP( "Angle Bisector" ),
I18N_NOOP( "The bisector of an angle" ),
"angle_bisector",
"angle-bisector" );
actions->add( new ConstructibleAction( &anglebisectionctor, "objects_new_angle_bisector" ) );
// conic stuff
c = new SimpleObjectTypeConstructor(
ConicB5PType::instance(), I18N_NOOP( "Conic by Five Points" ),
I18N_NOOP( "A conic constructed through five points" ),
"conicb5p" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_conicb5p" ) );
c = new SimpleObjectTypeConstructor(
ConicBAAPType::instance(),
I18N_NOOP( "Hyperbola by Asymptotes && Point" ),
I18N_NOOP( "A hyperbola with given asymptotes through a point" ),
"conicbaap" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_conicbaap" ) );
c = new SimpleObjectTypeConstructor(
EllipseBFFPType::instance(),
I18N_NOOP( "Ellipse by Focuses && Point" ), // focuses is used in preference to foci
I18N_NOOP( "An ellipse constructed by its focuses and a point that pertains to it" ),
"ellipsebffp" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_ellipsebffp" ) );
c = new SimpleObjectTypeConstructor(
HyperbolaBFFPType::instance(),
I18N_NOOP( "Hyperbola by Focuses && Point" ), // focuses is used in preference to foci
I18N_NOOP( "A hyperbola constructed by its focuses and a point that pertains to it" ),
"hyperbolabffp" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_hyperbolabffp" ) );
c = new SimpleObjectTypeConstructor(
ConicBDFPType::instance(),
I18N_NOOP( "Conic by Directrix, Focus && Point" ),
I18N_NOOP( "A conic with given directrix and focus, through a point" ),
"conicbdfp" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_conicbdfp" ) );
c = new SimpleObjectTypeConstructor(
ParabolaBTPType::instance(),
I18N_NOOP( "Vertical Parabola by Three Points" ),
I18N_NOOP( "A vertical parabola constructed through three points" ),
"parabolabtp" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_parabolabtp" ) );
c = new SimpleObjectTypeConstructor(
CubicB9PType::instance(),
I18N_NOOP( "Cubic Curve by Nine Points" ),
I18N_NOOP( "A cubic curve constructed through nine points" ),
"cubicb9p" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_cubicb9p" ) );
c = new SimpleObjectTypeConstructor(
ConicPolarPointType::instance(),
I18N_NOOP( "Polar Point of a Line" ),
I18N_NOOP( "The polar point of a line with respect to a conic." ),
"polarpoint" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_pointpolar" ) );
c = new SimpleObjectTypeConstructor(
ConicPolarLineType::instance(),
I18N_NOOP( "Polar Line of a Point" ),
I18N_NOOP( "The polar line of a point with respect to a conic." ),
"polarline" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_linepolar" ) );
c = new SimpleObjectTypeConstructor(
CubicNodeB6PType::instance(),
I18N_NOOP( "Cubic Curve with Node by Six Points" ),
I18N_NOOP( "A cubic curve with a nodal point at the origin through six points" ),
"cubicnodeb6p" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_cubicnodeb6p" ) );
c = new SimpleObjectTypeConstructor(
CubicCuspB4PType::instance(),
I18N_NOOP( "Cubic Curve with Cusp by Four Points" ),
I18N_NOOP( "A cubic curve with a horizontal cusp at the origin through four points" ),
"cubiccuspb4p" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_cubiccuspb4p" ) );
c = new SimpleObjectTypeConstructor(
ConicDirectrixType::instance(),
I18N_NOOP( "Directrix of a Conic" ),
I18N_NOOP( "The directrix line of a conic." ),
"directrix" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_linedirectrix" ) );
c = new SimpleObjectTypeConstructor(
AngleType::instance(),
I18N_NOOP( "Angle by Three Points" ),
I18N_NOOP( "An angle defined by three points" ),
"angle" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_angle", TQt::Key_A ) );
c = new SimpleObjectTypeConstructor(
EquilateralHyperbolaB4PType::instance(),
I18N_NOOP( "Equilateral Hyperbola by Four Points" ),
I18N_NOOP( "An equilateral hyperbola constructed through four points" ),
"equilateralhyperbolab4p" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_equilateralhyperbolab4p" ) );
{
// now for the Mid Point action. It does both the mid point of
// a segment, and the mid point of two points. The midpoint of
// two segments just shows the mid point property, and therefore
// doesn't need to be added to the ctors, because there are
// already facilities to construct an object's properties..
// therefore, we add only an mpotp to the ctors, and add the
// merged constructor only to the actions..
ctors->add( new MidPointOfTwoPointsConstructor() );
ObjectConstructor* mpotp = new MidPointOfTwoPointsConstructor();
ObjectConstructor* mpos = new PropertyObjectConstructor(
SegmentImp::stype(), I18N_NOOP( "Construct the midpoint of this segment" ),
"", "", "", "", "mid-point" );
// make this a static object, so it gets deleted at the end of
// the program.
static MergeObjectConstructor m(
I18N_NOOP( "Mid Point" ),
I18N_NOOP( "The midpoint of a segment or two other points" ),
"bisection" );
m.merge( mpotp );
m.merge( mpos );
actions->add( new ConstructibleAction( &m, "objects_new_midpoint", TQt::Key_M ) );
};
c = new SimpleObjectTypeConstructor(
VectorType::instance(),
I18N_NOOP( "Vector" ),
I18N_NOOP( "Construct a vector from two given points." ),
"vector" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_vector", TQt::Key_V ) );
c = new SimpleObjectTypeConstructor(
VectorSumType::instance(),
I18N_NOOP( "Vector Sum" ),
I18N_NOOP( "Construct the vector sum of two vectors." ),
"vectorsum" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_vectorsum", 0 ) );
c = new SimpleObjectTypeConstructor(
LineByVectorType::instance(),
I18N_NOOP( "Line by Vector" ),
I18N_NOOP( "Construct the line by a given vector though a given point." ),
"linebyvector" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_linebyvector", 0 ) );
c = new SimpleObjectTypeConstructor(
HalflineByVectorType::instance(),
I18N_NOOP( "Half-Line by Vector" ),
I18N_NOOP( "Construct the half-line by a given vector starting at given point." ),
"halflinebyvector" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_halflinebyvector", 0 ) );
c = new SimpleObjectTypeConstructor(
ArcBTPType::instance(),
I18N_NOOP( "Arc by Three Points" ),
I18N_NOOP( "Construct an arc through three points." ),
"arc" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_arcbtp" ) );
c = new SimpleObjectTypeConstructor(
ArcBCPAType::instance(),
I18N_NOOP( "Arc by Center, Angle && Point" ),
I18N_NOOP( "Construct an arc by its center and a given angle, "
"starting at a given point" ),
"arcbcpa" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_arcbcpa" ) );
c = new SimpleObjectTypeConstructor(
ParabolaBDPType::instance(),
I18N_NOOP( "Parabola by Directrix && Focus" ),
I18N_NOOP( "A parabola defined by its directrix and focus" ),
"parabolabdp" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_parabolabdp" ) );
// Transformation stuff..
c = new InversionConstructor();
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_inversion" ) );
c = new SimpleObjectTypeConstructor(
TranslatedType::instance(),
I18N_NOOP( "Translate" ),
I18N_NOOP( "The translation of an object by a vector" ),
"translation" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_translation" ) );
c = new SimpleObjectTypeConstructor(
PointReflectionType::instance(),
I18N_NOOP( "Reflect in Point" ),
I18N_NOOP( "An object reflected in a point" ),
"centralsymmetry" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_pointreflection" ) );
c = new SimpleObjectTypeConstructor(
LineReflectionType::instance(),
I18N_NOOP( "Reflect in Line" ),
I18N_NOOP( "An object reflected in a line" ),
"mirrorpoint" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_linereflection" ) );
c = new SimpleObjectTypeConstructor(
RotationType::instance(),
I18N_NOOP( "Rotate" ),
I18N_NOOP( "An object rotated by an angle around a point" ),
"rotation" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_rotation" ) );
c = new SimpleObjectTypeConstructor(
ScalingOverCenterType::instance(),
I18N_NOOP( "Scale" ),
I18N_NOOP( "Scale an object over a point, by the ratio given by the length of a segment" ),
"scale" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_scalingovercenter" ) );
c = new SimpleObjectTypeConstructor(
ScalingOverLineType::instance(),
I18N_NOOP( "Scale over Line" ),
I18N_NOOP( "An object scaled over a line, by the ratio given by the length of a segment" ),
"stretch" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_scalingoverline" ) );
c = new SimpleObjectTypeConstructor(
ScalingOverCenter2Type::instance(),
I18N_NOOP( "Scale (ratio given by two segments)" ),
I18N_NOOP( "Scale an object over a point, by the ratio given by the length of two segments" ),
"scale" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_scalingovercenter2" ) );
c = new SimpleObjectTypeConstructor(
ScalingOverLine2Type::instance(),
I18N_NOOP( "Scale over Line (ratio given by two segments)" ),
I18N_NOOP( "An object scaled over a line, by the ratio given by the length of two segments" ),
"stretch" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_scalingoverline2" ) );
c = new SimpleObjectTypeConstructor(
SimilitudeType::instance(),
I18N_NOOP( "Apply Similitude" ),
I18N_NOOP( "Apply a similitude to an object ( the sequence of a scaling and rotation around a center )" ),
"similitude" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_similitude" ) );
c = new SimpleObjectTypeConstructor(
HarmonicHomologyType::instance(),
I18N_NOOP( "Harmonic Homology" ),
I18N_NOOP( "The harmonic homology with a given center and a given axis (this is a projective transformation)" ),
"harmonichomology" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_harmonichomology" ) );
c = new GenericAffinityConstructor();
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_genericaffinity" ) );
c = new GenericProjectivityConstructor();
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_genericprojectivity" ) );
c = new SimpleObjectTypeConstructor(
CastShadowType::instance(),
I18N_NOOP( "Draw Projective Shadow" ),
I18N_NOOP( "The shadow of an object with a given light source and projection plane (indicated by a line)" ),
"castshadow" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_castshadow" ) );
// c = new SimpleObjectTypeConstructor(
// ProjectiveRotationType::instance(),
// I18N_NOOP( "Rotate Projectively" ),
// I18N_NOOP( "An object projectively rotated by an angle and a half-line" ),
// "projectiverotation" );
// ctors->add( c );
// actions->add( new ConstructibleAction( c, "objects_new_projectiverotation" ) );
c = new MultiObjectTypeConstructor(
ConicAsymptoteType::instance(),
I18N_NOOP( "Asymptotes of a Hyperbola" ),
I18N_NOOP( "The two asymptotes of a hyperbola." ),
"conicasymptotes", -1, 1 );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_lineconicasymptotes" ) );
c = new ConicRadicalConstructor();
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_lineconicradical") );
/* ----------- start polygons --------- */
c = new SimpleObjectTypeConstructor(
TriangleB3PType::instance(),
I18N_NOOP( "Triangle by Its Vertices" ),
I18N_NOOP( "Construct a triangle given its three vertices." ),
"triangle" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_trianglebtp" ) );
c = new PolygonBNPTypeConstructor();
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_polygonbnp" ));
c = new PolygonBCVConstructor();
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_polygonbcv" ) );
c = new PolygonVertexTypeConstructor();
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_polygonvertices" ));
c = new PolygonSideTypeConstructor();
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_polygonsides" ));
c = new SimpleObjectTypeConstructor(
ConvexHullType::instance(), I18N_NOOP( "Convex Hull" ),
I18N_NOOP( "A polygon that corresponds to the convex hull of another polygon" ),
"convexhull" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_convexhull" ) );
/* ----------- end polygons --------- */
c = new LocusConstructor();
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_locus" ) );
// tests
c = new TestConstructor(
AreParallelType::instance(),
I18N_NOOP( "Parallel Test" ),
I18N_NOOP( "Test whether two given lines are parallel" ),
"testparallel" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_areparallel" ) );
c = new TestConstructor(
AreOrthogonalType::instance(),
I18N_NOOP( "Orthogonal Test" ),
I18N_NOOP( "Test whether two given lines are orthogonal" ),
"testorthogonal" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_areorthogonal" ) );
c = new TestConstructor(
AreCollinearType::instance(),
I18N_NOOP( "Collinear Test" ),
I18N_NOOP( "Test whether three given points are collinear" ),
"testcollinear" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_arecollinear" ) );
c = new TestConstructor(
ContainsTestType::instance(),
I18N_NOOP( "Contains Test" ),
I18N_NOOP( "Test whether a given curve contains a given point" ),
"testcontains" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_containstest" ) );
c = new TestConstructor(
InPolygonTestType::instance(),
I18N_NOOP( "In Polygon Test" ),
I18N_NOOP( "Test whether a given polygon contains a given point" ),
"test" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_inpolygontest" ) );
c = new TestConstructor(
ConvexPolygonTestType::instance(),
I18N_NOOP( "Convex Polygon Test" ),
I18N_NOOP( "Test whether a given polygon is convex" ),
"test" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_convexpolygontest" ) );
c = new TestConstructor(
SameDistanceType::instance(),
I18N_NOOP( "Distance Test" ),
I18N_NOOP( "Test whether a given point have the same distance from a given point "
"and from another given point" ),
"testdistance" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_distancetest" ) );
c = new TestConstructor(
VectorEqualityTestType::instance(),
I18N_NOOP( "Vector Equality Test" ),
I18N_NOOP( "Test whether two vectors are equal" ),
"test" );
// "testequal" );
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_vectorequalitytest" ) );
c = new MeasureTransportConstructor();
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_measuretransport" ));
// c = new SimpleObjectTypeConstructor(
// MeasureTransportType::instance(),
// I18N_NOOP( "Measure Transport" ),
// I18N_NOOP( "Transport the measure of a segment or arc over a line or circle." ),
// "measuretransport" );
// ctors->add( c );
// actions->add( new ConstructibleAction( c, "objects_new_measuretransport" ) );
// the generic intersection constructor..
c = new GenericIntersectionConstructor();
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_intersection", TQt::Key_I ) );
// the generic tangent constructor
c = new TangentConstructor();
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_tangent", TQt::Key_T ) );
// the generic center of curvature constructor
c = new CocConstructor();
ctors->add( c );
actions->add( new ConstructibleAction( c, "objects_new_centerofcurvature" ) );
actions->add( new ConstructPointAction( "objects_new_normalpoint" ) );
actions->add( new ConstructTextLabelAction( "objects_new_textlabel" ) );
actions->add( new AddFixedPointAction( "objects_new_point_xy" ) );
#ifdef KIG_ENABLE_PYTHON_SCRIPTING
#include "../scripting/script-common.h"
actions->add( new NewScriptAction(
I18N_NOOP( "Python Script" ),
I18N_NOOP( "Construct a new Python script." ),
"objects_new_script_python",
ScriptType::Python ) );
#endif
#if 0
actions->add( new TestAction( "test_stuff" ) );
#endif
};
done = true;
}