• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • kdeedu API Reference
  • KDE Home
  • Contact Us
 

kig

  • sources
  • kde-4.14
  • kdeedu
  • kig
  • objects
tests_type.cc
Go to the documentation of this file.
1 // Copyright (C) 2004 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., 51 Franklin Street, Fifth Floor, Boston, MA
16 // 02110-1301, USA.
17 
18 #include "tests_type.h"
19 
20 #include <math.h>
21 
22 #include "line_imp.h"
23 #include "polygon_imp.h"
24 #include "point_imp.h"
25 #include "bogus_imp.h"
26 #include "other_imp.h"
27 
28 #include <cmath>
29 
30 static const ArgsParser::spec argsspecAreParallel[] =
31 {
32  { AbstractLineImp::stype(), I18N_NOOP( "Is this line parallel?" ),
33  I18N_NOOP( "Select the first of the two possibly parallel lines..." ), false },
34  { AbstractLineImp::stype(), I18N_NOOP( "Parallel to this line?" ),
35  I18N_NOOP( "Select the other of the two possibly parallel lines..." ), false }
36 };
37 
38 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( AreParallelType )
39 
40 AreParallelType::AreParallelType()
41  : ArgsParserObjectType( "AreParallel",
42  argsspecAreParallel, 2 )
43 {
44 }
45 
46 AreParallelType::~AreParallelType()
47 {
48 }
49 
50 const AreParallelType* AreParallelType::instance()
51 {
52  static const AreParallelType t;
53  return &t;
54 }
55 
56 ObjectImp* AreParallelType::calc( const Args& parents, const KigDocument& ) const
57 {
58  if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
59  const LineData& l1 = static_cast<const AbstractLineImp*>( parents[0] )->data();
60  const LineData& l2 = static_cast<const AbstractLineImp*>( parents[1] )->data();
61 
62  if ( l1.isParallelTo( l2 ) )
63  return new TestResultImp( true, i18n( "These lines are parallel." ) );
64  else
65  return new TestResultImp( false, i18n( "These lines are not parallel." ) );
66 
67 }
68 
69 const ObjectImpType* AreParallelType::resultId() const
70 {
71  return TestResultImp::stype();
72 }
73 
74 static const ArgsParser::spec argsspecAreOrthogonal[] =
75 {
76  { AbstractLineImp::stype(), I18N_NOOP( "Is this line orthogonal?" ),
77  I18N_NOOP( "Select the first of the two possibly orthogonal lines..." ), false },
78  { AbstractLineImp::stype(), I18N_NOOP( "Orthogonal to this line?" ),
79  I18N_NOOP( "Select the other of the two possibly orthogonal lines..." ), false }
80 };
81 
82 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( AreOrthogonalType )
83 
84 AreOrthogonalType::AreOrthogonalType()
85  : ArgsParserObjectType( "AreOrthogonal",
86  argsspecAreOrthogonal, 2 )
87 {
88 }
89 
90 AreOrthogonalType::~AreOrthogonalType()
91 {
92 }
93 
94 const AreOrthogonalType* AreOrthogonalType::instance()
95 {
96  static const AreOrthogonalType t;
97  return &t;
98 }
99 
100 ObjectImp* AreOrthogonalType::calc( const Args& parents, const KigDocument& ) const
101 {
102  if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
103  const LineData& l1 = static_cast<const AbstractLineImp*>( parents[0] )->data();
104  const LineData& l2 = static_cast<const AbstractLineImp*>( parents[1] )->data();
105 
106  if ( l1.isOrthogonalTo( l2 ) )
107  return new TestResultImp( true, i18n( "These lines are orthogonal." ) );
108  else
109  return new TestResultImp( false, i18n( "These lines are not orthogonal." ) );
110 
111 }
112 
113 const ObjectImpType* AreOrthogonalType::resultId() const
114 {
115  return TestResultImp::stype();
116 }
117 
118 static const ArgsParser::spec argsspecAreCollinear[] =
119 {
120  { PointImp::stype(), I18N_NOOP( "Check collinearity of this point" ),
121  I18N_NOOP( "Select the first of the three possibly collinear points..." ), false },
122  { PointImp::stype(), I18N_NOOP( "and this second point" ),
123  I18N_NOOP( "Select the second of the three possibly collinear points..." ), false },
124  { PointImp::stype(), I18N_NOOP( "with this third point" ),
125  I18N_NOOP( "Select the last of the three possibly collinear points..." ), false }
126 };
127 
128 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( AreCollinearType )
129 
130 AreCollinearType::AreCollinearType()
131  : ArgsParserObjectType( "AreCollinear",
132  argsspecAreCollinear, 3 )
133 {
134 }
135 
136 AreCollinearType::~AreCollinearType()
137 {
138 }
139 
140 const AreCollinearType* AreCollinearType::instance()
141 {
142  static const AreCollinearType t;
143  return &t;
144 }
145 
146 ObjectImp* AreCollinearType::calc( const Args& parents, const KigDocument& ) const
147 {
148  if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
149  const Coordinate& p1 = static_cast<const PointImp*>( parents[0] )->coordinate();
150  const Coordinate& p2 = static_cast<const PointImp*>( parents[1] )->coordinate();
151  const Coordinate& p3 = static_cast<const PointImp*>( parents[2] )->coordinate();
152 
153  if ( areCollinear( p1, p2, p3 ) )
154  return new TestResultImp( true, i18n( "These points are collinear." ) );
155  else
156  return new TestResultImp( false, i18n( "These points are not collinear." ) );
157 }
158 
159 const ObjectImpType* AreCollinearType::resultId() const
160 {
161  return TestResultImp::stype();
162 }
163 
164 static const ArgsParser::spec containsTestArgsSpec[] =
165 {
166  { PointImp::stype(), I18N_NOOP( "Check whether this point is on a curve" ),
167  I18N_NOOP( "Select the point you want to test..." ), false },
168  { CurveImp::stype(), I18N_NOOP( "Check whether the point is on this curve" ),
169  I18N_NOOP( "Select the curve that the point might be on..." ), false }
170 };
171 
172 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ContainsTestType )
173 
174 ContainsTestType::ContainsTestType()
175  : ArgsParserObjectType( "ContainsTest", containsTestArgsSpec, 2 )
176 {
177 }
178 
179 ContainsTestType::~ContainsTestType()
180 {
181 }
182 
183 const ContainsTestType* ContainsTestType::instance()
184 {
185  static const ContainsTestType t;
186  return &t;
187 }
188 
189 ObjectImp* ContainsTestType::calc( const Args& parents, const KigDocument& doc ) const
190 {
191  if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
192  const Coordinate& p = static_cast<const PointImp*>( parents[0] )->coordinate();
193  const CurveImp* c = static_cast<const CurveImp*>( parents[1] );
194 
195  if ( c->containsPoint( p, doc ) )
196  return new TestResultImp( true, i18n( "This curve contains the point." ) );
197  else
198  return new TestResultImp( false, i18n( "This curve does not contain the point." ) );
199 }
200 
201 const ObjectImpType* ContainsTestType::resultId() const
202 {
203  return TestResultImp::stype();
204 }
205 
206 /*
207  * containment test of a point in a polygon
208  */
209 
210 static const ArgsParser::spec InPolygonTestArgsSpec[] =
211 {
212  { PointImp::stype(), I18N_NOOP( "Check whether this point is in a polygon" ),
213  I18N_NOOP( "Select the point you want to test..." ), false },
214  { FilledPolygonImp::stype(), I18N_NOOP( "Check whether the point is in this polygon" ),
215  I18N_NOOP( "Select the polygon that the point might be in..." ), false }
216 };
217 
218 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( InPolygonTestType )
219 
220 InPolygonTestType::InPolygonTestType()
221  : ArgsParserObjectType( "InPolygonTest", InPolygonTestArgsSpec, 2 )
222 {
223 }
224 
225 InPolygonTestType::~InPolygonTestType()
226 {
227 }
228 
229 const InPolygonTestType* InPolygonTestType::instance()
230 {
231  static const InPolygonTestType t;
232  return &t;
233 }
234 
235 ObjectImp* InPolygonTestType::calc( const Args& parents, const KigDocument& ) const
236 {
237  if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
238  const Coordinate& p = static_cast<const PointImp*>( parents[0] )->coordinate();
239  const FilledPolygonImp* pol = static_cast<const FilledPolygonImp*>( parents[1] );
240 
241  if ( pol->isInPolygon( p ) )
242  return new TestResultImp( true, i18n( "This polygon contains the point." ) );
243  else
244  return new TestResultImp( false, i18n( "This polygon does not contain the point." ) );
245 }
246 
247 const ObjectImpType* InPolygonTestType::resultId() const
248 {
249  return TestResultImp::stype();
250 }
251 
252 /*
253  * test if a polygon is convex
254  */
255 
256 static const ArgsParser::spec ConvexPolygonTestArgsSpec[] =
257 {
258  { FilledPolygonImp::stype(), I18N_NOOP( "Check whether this polygon is convex" ),
259  I18N_NOOP( "Select the polygon you want to test for convexity..." ), false }
260 };
261 
262 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ConvexPolygonTestType )
263 
264 ConvexPolygonTestType::ConvexPolygonTestType()
265  : ArgsParserObjectType( "ConvexPolygonTest", ConvexPolygonTestArgsSpec, 1 )
266 {
267 }
268 
269 ConvexPolygonTestType::~ConvexPolygonTestType()
270 {
271 }
272 
273 const ConvexPolygonTestType* ConvexPolygonTestType::instance()
274 {
275  static const ConvexPolygonTestType t;
276  return &t;
277 }
278 
279 ObjectImp* ConvexPolygonTestType::calc( const Args& parents, const KigDocument& ) const
280 {
281  if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
282  const FilledPolygonImp* pol = static_cast<const FilledPolygonImp*>( parents[0] );
283 
284  if ( pol->isConvex() )
285  return new TestResultImp( true, i18n( "This polygon is convex." ) );
286  else
287  return new TestResultImp( false, i18n( "This polygon is not convex." ) );
288 }
289 
290 const ObjectImpType* ConvexPolygonTestType::resultId() const
291 {
292  return TestResultImp::stype();
293 }
294 
295 /*
296  * same distance test
297  */
298 
299 static const ArgsParser::spec argsspecSameDistanceType[] =
300 {
301  { PointImp::stype(), I18N_NOOP( "Check if this point has the same distance" ),
302  I18N_NOOP( "Select the point which might have the same distance from two other points..." ), false },
303  { PointImp::stype(), I18N_NOOP( "from this point" ),
304  I18N_NOOP( "Select the first of the two other points..." ), false },
305  { PointImp::stype(), I18N_NOOP( "and from this second point" ),
306  I18N_NOOP( "Select the other of the two other points..." ), false }
307 };
308 
309 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( SameDistanceType )
310 
311 SameDistanceType::SameDistanceType()
312  : ArgsParserObjectType( "SameDistanceType", argsspecSameDistanceType, 3 )
313 {
314 }
315 
316 SameDistanceType::~SameDistanceType()
317 {
318 }
319 
320 const SameDistanceType* SameDistanceType::instance()
321 {
322  static const SameDistanceType t;
323  return &t;
324 }
325 
326 ObjectImp* SameDistanceType::calc( const Args& parents, const KigDocument& ) const
327 {
328  if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
329  const Coordinate& p1 = static_cast<const PointImp*>( parents[0] )->coordinate();
330  const Coordinate& p2 = static_cast<const PointImp*>( parents[1] )->coordinate();
331  const Coordinate& p3 = static_cast<const PointImp*>( parents[2] )->coordinate();
332 
333  if ( fabs( ( p1 - p2 ).length() - ( p1 - p3 ).length() ) < 10e-5 )
334  return new TestResultImp( true, i18n( "The two distances are the same." ) );
335  else
336  return new TestResultImp( false, i18n( "The two distances are not the same." ) );
337 }
338 
339 const ObjectImpType* SameDistanceType::resultId() const
340 {
341  return TestResultImp::stype();
342 }
343 
344 static const ArgsParser::spec vectorEqualityArgsSpec[] =
345 {
346  { VectorImp::stype(), I18N_NOOP( "Check whether this vector is equal to another vector" ),
347  I18N_NOOP( "Select the first of the two possibly equal vectors..." ), false },
348  { VectorImp::stype(), I18N_NOOP( "Check whether this vector is equal to the other vector" ),
349  I18N_NOOP( "Select the other of the two possibly equal vectors..." ), false }
350 };
351 
352 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( VectorEqualityTestType )
353 
354 VectorEqualityTestType::VectorEqualityTestType()
355  : ArgsParserObjectType( "VectorEquality", vectorEqualityArgsSpec, 2 )
356 {
357 }
358 
359 VectorEqualityTestType::~VectorEqualityTestType()
360 {
361 }
362 
363 const VectorEqualityTestType* VectorEqualityTestType::instance()
364 {
365  static const VectorEqualityTestType t;
366  return &t;
367 }
368 
369 ObjectImp* VectorEqualityTestType::calc( const Args& parents, const KigDocument& ) const
370 {
371  if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
372  const Coordinate& v1 = static_cast<const VectorImp*>( parents[0] )->dir();
373  const Coordinate& v2 = static_cast<const VectorImp*>( parents[1] )->dir();
374 
375  if ( ( v1 - v2 ).length() < 10e-5 )
376  return new TestResultImp( true, i18n( "The two vectors are the same." ) );
377  else
378  return new TestResultImp( false, i18n( "The two vectors are not the same." ) );
379 }
380 
381 const ObjectImpType* VectorEqualityTestType::resultId() const
382 {
383  return TestResultImp::stype();
384 }
385 
386 static const ArgsParser::spec existenceArgsSpec[] =
387 {
388  { ObjectImp::stype(), I18N_NOOP( "Check whether this object exists" ),
389  I18N_NOOP( "Select the object for the existence check..." ), false }
390 };
391 
392 KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE( ExistenceTestType )
393 
394 ExistenceTestType::ExistenceTestType()
395  : ArgsParserObjectType( "Existence", existenceArgsSpec, 1 )
396 {
397 }
398 
399 ExistenceTestType::~ExistenceTestType()
400 {
401 }
402 
403 const ExistenceTestType* ExistenceTestType::instance()
404 {
405  static const ExistenceTestType t;
406  return &t;
407 }
408 
409 ObjectImp* ExistenceTestType::calc( const Args& parents, const KigDocument& ) const
410 {
411  //if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
412  if ( static_cast<const ObjectImp*>( parents[0] )->valid() )
413  return new TestResultImp( true, i18n( "The object exists." ) );
414  else
415  return new TestResultImp( false, i18n( "The object does not exist." ) );
416 }
417 
418 const ObjectImpType* ExistenceTestType::resultId() const
419 {
420  return TestResultImp::stype();
421 }
InPolygonTestType::instance
static const InPolygonTestType * instance()
Definition: tests_type.cc:229
ObjectImpType
Instances of this class represent a certain ObjectImp type.
Definition: object_imp.h:95
ExistenceTestType::instance
static const ExistenceTestType * instance()
Definition: tests_type.cc:403
KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE
KIG_INSTANTIATE_OBJECT_TYPE_INSTANCE(SegmentAxisType)
point_imp.h
ArgsParserObjectType
This is a convenience subclass of ObjectType that a type should inherit from if its parents can be sp...
Definition: object_type.h:113
AreCollinearType::instance
static const AreCollinearType * instance()
Definition: tests_type.cc:140
LineData::isOrthogonalTo
bool isOrthogonalTo(const LineData &l) const
Return true if this line is orthogonal to l.
Definition: common.cpp:474
AbstractLineImp
An ObjectImp class that is the base of the line-like ObjectImp's: SegmentImp, LineImp and RayImp...
Definition: line_imp.h:31
LineData
Simple class representing a line.
Definition: misc/common.h:49
argsspecSameDistanceType
static const ArgsParser::spec argsspecSameDistanceType[]
Definition: tests_type.cc:299
InPolygonTestArgsSpec
static const ArgsParser::spec InPolygonTestArgsSpec[]
Definition: tests_type.cc:210
AreOrthogonalType::instance
static const AreOrthogonalType * instance()
Definition: tests_type.cc:94
polygon_imp.h
ConvexPolygonTestType::instance
static const ConvexPolygonTestType * instance()
Definition: tests_type.cc:273
ConvexPolygonTestType
Definition: tests_type.h:78
AbstractPolygonImp::isInPolygon
bool isInPolygon(const Coordinate &p) const
Definition: polygon_imp.cc:137
argsspecAreOrthogonal
static const ArgsParser::spec argsspecAreOrthogonal[]
Definition: tests_type.cc:74
tests_type.h
VectorImp::stype
static const ObjectImpType * stype()
Returns the ObjectImpType representing the VectorImp type.
Definition: other_imp.cc:613
areCollinear
bool areCollinear(const Coordinate &p1, const Coordinate &p2, const Coordinate &p3)
test collinearity of three points
Definition: common.cpp:489
AreCollinearType
Definition: tests_type.h:45
ContainsTestType::instance
static const ContainsTestType * instance()
Definition: tests_type.cc:183
ConvexPolygonTestType::calc
ObjectImp * calc(const Args &parents, const KigDocument &) const
Definition: tests_type.cc:279
ObjectImp::stype
static const ObjectImpType * stype()
The ObjectImpType representing the base ObjectImp class.
Definition: object_imp.cc:284
Coordinate
The Coordinate class is the basic class representing a 2D location by its x and y components...
Definition: coordinate.h:33
VectorEqualityTestType::instance
static const VectorEqualityTestType * instance()
Definition: tests_type.cc:363
VectorImp
An ObjectImp representing a vector.
Definition: other_imp.h:99
ArgsParserObjectType::margsparser
const ArgsParser margsparser
Definition: object_type.h:117
AreParallelType::resultId
const ObjectImpType * resultId() const
returns the ObjectImp id of the ObjectImp's produced by this ObjectType.
Definition: tests_type.cc:69
vectorEqualityArgsSpec
static const ArgsParser::spec vectorEqualityArgsSpec[]
Definition: tests_type.cc:344
AbstractPolygonImp::isConvex
bool isConvex() const
Definition: polygon_imp.cc:922
AreParallelType::calc
ObjectImp * calc(const Args &parents, const KigDocument &) const
Definition: tests_type.cc:56
bogus_imp.h
TestResultImp::stype
static const ObjectImpType * stype()
Definition: bogus_imp.cc:294
PointImp
An ObjectImp representing a point.
Definition: point_imp.h:27
Args
std::vector< const ObjectImp * > Args
Definition: objects/common.h:47
AreOrthogonalType
Definition: tests_type.h:34
AreOrthogonalType::resultId
const ObjectImpType * resultId() const
returns the ObjectImp id of the ObjectImp's produced by this ObjectType.
Definition: tests_type.cc:113
ContainsTestType::resultId
const ObjectImpType * resultId() const
returns the ObjectImp id of the ObjectImp's produced by this ObjectType.
Definition: tests_type.cc:201
ArgsParser::checkArgs
bool checkArgs(const std::vector< ObjectCalcer * > &os) const
Definition: argsparser.cpp:222
FilledPolygonImp::stype
static const ObjectImpType * stype()
Definition: polygon_imp.cc:660
ExistenceTestType::resultId
const ObjectImpType * resultId() const
returns the ObjectImp id of the ObjectImp's produced by this ObjectType.
Definition: tests_type.cc:418
ArgsParser::spec
Definition: argsparser.h:113
InPolygonTestType
Definition: tests_type.h:67
VectorEqualityTestType::resultId
const ObjectImpType * resultId() const
returns the ObjectImp id of the ObjectImp's produced by this ObjectType.
Definition: tests_type.cc:381
containsTestArgsSpec
static const ArgsParser::spec containsTestArgsSpec[]
Definition: tests_type.cc:164
AreParallelType
Definition: tests_type.h:23
AreCollinearType::calc
ObjectImp * calc(const Args &parents, const KigDocument &) const
Definition: tests_type.cc:146
ExistenceTestType
Definition: tests_type.h:111
LineData::isParallelTo
bool isParallelTo(const LineData &l) const
Return true if this line is parallel to l.
Definition: common.cpp:459
SameDistanceType::resultId
const ObjectImpType * resultId() const
returns the ObjectImp id of the ObjectImp's produced by this ObjectType.
Definition: tests_type.cc:339
SameDistanceType::instance
static const SameDistanceType * instance()
Definition: tests_type.cc:320
ConvexPolygonTestArgsSpec
static const ArgsParser::spec ConvexPolygonTestArgsSpec[]
Definition: tests_type.cc:256
ContainsTestType
Definition: tests_type.h:56
PointImp::stype
static const ObjectImpType * stype()
Returns the ObjectImpType representing PointImp's.
Definition: point_imp.cc:159
line_imp.h
SameDistanceType
Definition: tests_type.h:89
argsspecAreCollinear
static const ArgsParser::spec argsspecAreCollinear[]
Definition: tests_type.cc:118
AreOrthogonalType::calc
ObjectImp * calc(const Args &parents, const KigDocument &) const
Definition: tests_type.cc:100
InPolygonTestType::calc
ObjectImp * calc(const Args &parents, const KigDocument &) const
Definition: tests_type.cc:235
CurveImp::containsPoint
virtual bool containsPoint(const Coordinate &p, const KigDocument &) const =0
Return whether this Curve contains the given point.
CurveImp::stype
static const ObjectImpType * stype()
Returns the ObjectImpType representing the CurveImp type.
Definition: curve_imp.cc:27
KigDocument
KigDocument is the class holding the real data in a Kig document.
Definition: kig_document.h:36
AbstractLineImp::stype
static const ObjectImpType * stype()
Returns the ObjectImpType representing the AbstractLineImp type.
Definition: line_imp.cc:520
VectorEqualityTestType::calc
ObjectImp * calc(const Args &parents, const KigDocument &) const
Definition: tests_type.cc:369
SameDistanceType::calc
ObjectImp * calc(const Args &parents, const KigDocument &) const
Definition: tests_type.cc:326
ObjectImp
The ObjectImp class represents the behaviour of an object after it is calculated. ...
Definition: object_imp.h:226
ContainsTestType::calc
ObjectImp * calc(const Args &parents, const KigDocument &) const
Definition: tests_type.cc:189
existenceArgsSpec
static const ArgsParser::spec existenceArgsSpec[]
Definition: tests_type.cc:386
FilledPolygonImp
An ObjectImp representing a filled polygon.
Definition: polygon_imp.h:101
ConvexPolygonTestType::resultId
const ObjectImpType * resultId() const
returns the ObjectImp id of the ObjectImp's produced by this ObjectType.
Definition: tests_type.cc:290
ExistenceTestType::calc
ObjectImp * calc(const Args &parents, const KigDocument &) const
Definition: tests_type.cc:409
AreCollinearType::resultId
const ObjectImpType * resultId() const
returns the ObjectImp id of the ObjectImp's produced by this ObjectType.
Definition: tests_type.cc:159
TestResultImp
Definition: bogus_imp.h:253
AreParallelType::instance
static const AreParallelType * instance()
Definition: tests_type.cc:50
argsspecAreParallel
static const ArgsParser::spec argsspecAreParallel[]
Definition: tests_type.cc:30
InvalidImp
This ObjectImp represents an invalid object.
Definition: bogus_imp.h:61
other_imp.h
CurveImp
This class represents a curve: something which is composed of points, like a line, a circle, a locus.
Definition: curve_imp.h:27
InPolygonTestType::resultId
const ObjectImpType * resultId() const
returns the ObjectImp id of the ObjectImp's produced by this ObjectType.
Definition: tests_type.cc:247
VectorEqualityTestType
Definition: tests_type.h:100
This file is part of the KDE documentation.
Documentation copyright © 1996-2020 The KDE developers.
Generated on Mon Jun 22 2020 13:12:05 by doxygen 1.8.7 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

kig

Skip menu "kig"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members

kdeedu API Reference

Skip menu "kdeedu API Reference"
  • Analitza
  •     lib
  • kalgebra
  • kalzium
  •   libscience
  • kanagram
  • kig
  •   lib
  • klettres
  • marble
  • parley
  • rocs
  •   App
  •   RocsCore
  •   VisualEditor
  •   stepcore

Search



Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal