• 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
object_calcer.cc
Go to the documentation of this file.
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., 51 Franklin Street, Fifth Floor, Boston, MA
16 // 02110-1301, USA.
17 
18 #include "object_calcer.h"
19 
20 #include "object_holder.h"
21 #include "object_imp.h"
22 #include "bogus_imp.h"
23 #include "object_type.h"
24 #include "../misc/coordinate.h"
25 #include "common.h"
26 
27 #include <algorithm>
28 #include <set>
29 #include <typeinfo>
30 #include <iterator>
31 
32 void ObjectTypeCalcer::calc( const KigDocument& doc )
33 {
34  Args a;
35  a.reserve( mparents.size() );
36  std::transform( mparents.begin(), mparents.end(),
37  std::back_inserter( a ), std::mem_fun( &ObjectCalcer::imp ) );
38  ObjectImp* n = mtype->calc( a, doc );
39  delete mimp;
40  mimp = n;
41 }
42 
43 ObjectTypeCalcer::ObjectTypeCalcer( const ObjectType* type,
44  const std::vector<ObjectCalcer*>& parents, bool sort )
45  : mparents( ( sort )?type->sortArgs( parents ):parents ), mtype( type ), mimp( 0 )
46 {
47  std::for_each( mparents.begin(), mparents.end(),
48  std::bind2nd( std::mem_fun( &ObjectCalcer::addChild ), this ) );
49 }
50 
51 ObjectCalcer::~ObjectCalcer()
52 {
53 }
54 
55 ObjectConstCalcer::ObjectConstCalcer( ObjectImp* imp )
56  : mimp( imp )
57 {
58 }
59 
60 ObjectConstCalcer::~ObjectConstCalcer()
61 {
62  delete mimp;
63 }
64 
65 const ObjectImp* ObjectConstCalcer::imp() const
66 {
67  return mimp;
68 }
69 
70 void ObjectConstCalcer::calc( const KigDocument& )
71 {
72 }
73 
74 std::vector<ObjectCalcer*> ObjectConstCalcer::parents() const
75 {
76  // we have no parents..
77  return std::vector<ObjectCalcer*>();
78 }
79 
80 void ObjectCalcer::ref()
81 {
82  ++refcount;
83 }
84 
85 void ObjectCalcer::deref()
86 {
87  if ( --refcount <= 0 ) delete this;
88 }
89 
90 void intrusive_ptr_add_ref( ObjectCalcer* p )
91 {
92  p->ref();
93 }
94 
95 void intrusive_ptr_release( ObjectCalcer* p )
96 {
97  p->deref();
98 }
99 
100 const ObjectImp* ObjectTypeCalcer::imp() const
101 {
102  return mimp;
103 }
104 
105 std::vector<ObjectCalcer*> ObjectTypeCalcer::parents() const
106 {
107  return mparents;
108 }
109 
110 void ObjectCalcer::addChild( ObjectCalcer* c )
111 {
112  mchildren.push_back( c );
113  ref();
114 }
115 
116 void ObjectCalcer::delChild( ObjectCalcer* c )
117 {
118  std::vector<ObjectCalcer*>::iterator i = std::find( mchildren.begin(), mchildren.end(), c );
119  assert( i != mchildren.end() );
120 
121  mchildren.erase( i );
122  deref();
123 }
124 
125 ObjectTypeCalcer::~ObjectTypeCalcer()
126 {
127  std::for_each( mparents.begin(), mparents.end(),
128  std::bind2nd( std::mem_fun( &ObjectCalcer::delChild ), this ) );
129  delete mimp;
130 }
131 
132 const ObjectType* ObjectTypeCalcer::type() const
133 {
134  return mtype;
135 }
136 
137 ObjectPropertyCalcer::ObjectPropertyCalcer( ObjectCalcer* parent, const char* pname )
138  : mimp( 0 ), mparent( parent ), mparenttype( 0 )
139 {
140  // Some weird C++ thing prevents me from calling protected members
141  // of ObjectCalcer on mparent.. This is an ugly workaround..
142  ( mparent->*&ObjectCalcer::addChild )( this );
143  mpropgid = mparent->imp()->getPropGid( pname );
144  //mparent->addChild( this );
145 }
146 
147 ObjectPropertyCalcer::ObjectPropertyCalcer( ObjectCalcer* parent, int propid, bool islocal )
148  : mimp( 0 ), mparent( parent ), mparenttype( 0 )
149 {
150  // Some weird C++ thing prevents me from calling protected members
151  // of ObjectCalcer on mparent.. This is an ugly workaround..
152  ( mparent->*&ObjectCalcer::addChild )( this );
153  if ( islocal )
154  {
155  mpropgid = parent->imp()->getPropGid( parent->imp()->propertiesInternalNames()[propid] );
156  } else {
157  mpropgid = propid;
158  }
159  //mparent->addChild( this );
160 }
161 
162 ObjectPropertyCalcer::~ObjectPropertyCalcer()
163 {
164  // Some weird C++ thing prevents me from calling protected members
165  // of ObjectCalcer on mparent.. This is an ugly workaround..
166  ( mparent->*&ObjectCalcer::delChild )( this );
167  //mparent->delChild( this );
168  delete mimp;
169 }
170 
171 const ObjectImp* ObjectPropertyCalcer::imp() const
172 {
173  return mimp;
174 }
175 
176 std::vector<ObjectCalcer*> ObjectPropertyCalcer::parents() const
177 {
178  std::vector<ObjectCalcer*> ret;
179  ret.push_back( mparent );
180  return ret;
181 }
182 
183 void ObjectPropertyCalcer::calc( const KigDocument& doc )
184 {
185  //if ( mparenttype != mparent->imp()->type() )
186  if ( mparenttype == 0 || *mparenttype != typeid( *(mparent->imp()) ) )
187  {
188  mpropid = mparent->imp()->getPropLid( mpropgid );
189 // mparenttype = mparent->imp()->type();
190  mparenttype = &typeid( *(mparent->imp()) );
191 // printf ("changing type, new type: %s\n", mparenttype->internalName());
192  }
193  ObjectImp* n;
194  if ( mpropid >= 0 )
195  {
196  n = mparent->imp()->property( mpropid, doc );
197  } else n = new InvalidImp;
198  delete mimp;
199  mimp = n;
200 }
201 
202 ObjectImp* ObjectConstCalcer::switchImp( ObjectImp* newimp )
203 {
204  ObjectImp* ret = mimp;
205  mimp = newimp;
206  return ret;
207 }
208 
209 std::vector<ObjectCalcer*> ObjectCalcer::children() const
210 {
211  return mchildren;
212 }
213 
214 const ObjectImpType* ObjectPropertyCalcer::impRequirement(
215  ObjectCalcer*, const std::vector<ObjectCalcer*>& ) const
216 {
217  int proplid = mparent->imp()->getPropLid( mpropgid );
218  return mparent->imp()->impRequirementForProperty( proplid );
219 }
220 
221 const ObjectImpType* ObjectConstCalcer::impRequirement(
222  ObjectCalcer*, const std::vector<ObjectCalcer*>& ) const
223 {
224  assert( false );
225  return ObjectImp::stype();
226 }
227 
228 const ObjectImpType* ObjectTypeCalcer::impRequirement(
229  ObjectCalcer* o, const std::vector<ObjectCalcer*>& os ) const
230 {
231  Args args;
232  args.reserve( mparents.size() );
233  std::transform(
234  os.begin(), os.end(),
235  std::back_inserter( args ),
236  std::mem_fun( &ObjectCalcer::imp ) );
237  assert( std::find( args.begin(), args.end(), o->imp() ) != args.end() );
238  return mtype->impRequirement( o->imp(), args );
239 }
240 
241 void ObjectConstCalcer::setImp( ObjectImp* newimp )
242 {
243  delete switchImp( newimp );
244 }
245 
246 void ObjectTypeCalcer::setParents( const std::vector<ObjectCalcer*> np )
247 {
248  std::for_each( np.begin(), np.end(),
249  std::bind2nd( std::mem_fun( &ObjectCalcer::addChild ), this ) );
250  std::for_each( mparents.begin(), mparents.end(),
251  std::bind2nd( std::mem_fun( &ObjectCalcer::delChild ), this ) );
252  mparents = np;
253 }
254 
255 void ObjectTypeCalcer::setType( const ObjectType* t )
256 {
257  mtype = t;
258 }
259 
260 bool ObjectCalcer::canMove() const
261 {
262  return false;
263 }
264 
265 bool ObjectCalcer::isFreelyTranslatable() const
266 {
267  return false;
268 }
269 
270 Coordinate ObjectCalcer::moveReferencePoint() const
271 {
272  assert( false );
273  return Coordinate::invalidCoord();
274 }
275 
276 void ObjectCalcer::move( const Coordinate&, const KigDocument& )
277 {
278  assert( false );
279 }
280 
281 bool ObjectTypeCalcer::canMove() const
282 {
283  return mtype->canMove( *this );
284 }
285 
286 bool ObjectTypeCalcer::isFreelyTranslatable() const
287 {
288  return mtype->isFreelyTranslatable( *this );
289 }
290 
291 Coordinate ObjectTypeCalcer::moveReferencePoint() const
292 {
293  return mtype->moveReferencePoint( *this );
294 }
295 
296 void ObjectTypeCalcer::move( const Coordinate& to, const KigDocument& doc )
297 {
298  // we need to check if type can in fact move, because this check is
299  // not done for us in all circumstances ( e.g. LineABType::move uses
300  // move on its parents to move them ), and the ObjectType's depend
301  // on move only being called if canMove() returns true..
302  if ( mtype->canMove( *this ) )
303  mtype->move( *this, to, doc );
304 }
305 
306 ObjectCalcer* ObjectPropertyCalcer::parent() const
307 {
308  return mparent;
309 }
310 
311 ObjectCalcer::ObjectCalcer()
312  : refcount( 0 )
313 {
314 }
315 
316 std::vector<ObjectCalcer*> ObjectCalcer::movableParents() const
317 {
318  return std::vector<ObjectCalcer*>();
319 }
320 
321 std::vector<ObjectCalcer*> ObjectTypeCalcer::movableParents() const
322 {
323  return mtype->movableParents( *this );
324 }
325 
326 bool ObjectConstCalcer::isDefinedOnOrThrough( const ObjectCalcer* ) const
327 {
328  return false;
329 }
330 
331 bool ObjectPropertyCalcer::isDefinedOnOrThrough( const ObjectCalcer* o ) const
332 {
333  return o == mparent &&
334  mparent->imp()->isPropertyDefinedOnOrThroughThisImp(
335  mparent->imp()->getPropLid( mpropgid ) );
336 }
337 
338 bool ObjectTypeCalcer::isDefinedOnOrThrough( const ObjectCalcer* o ) const
339 {
340  Args args;
341  args.reserve( mparents.size() );
342  std::transform(
343  mparents.begin(), mparents.end(),
344  std::back_inserter( args ),
345  std::mem_fun( &ObjectCalcer::imp ) );
346  if ( std::find( args.begin(), args.end(), o->imp() ) == args.end() )
347  return false;
348 
349  return mtype->isDefinedOnOrThrough( o->imp(), args );
350 }
351 
352 int ObjectPropertyCalcer::propLid() const
353 {
354  return mparent->imp()->getPropLid( mpropgid );
355 }
356 
357 int ObjectPropertyCalcer::propGid() const
358 {
359  return mpropgid;
360 }
361 
object_imp.h
ObjectCalcer::isFreelyTranslatable
virtual bool isFreelyTranslatable() const
Returns whether this ObjectCalcer can be translated at any position in the coordinate plane...
Definition: object_calcer.cc:265
ObjectConstCalcer::switchImp
ObjectImp * switchImp(ObjectImp *newimp)
Set the ObjectImp of this ObjectConstCalcer to the given newimp.
Definition: object_calcer.cc:202
ObjectTypeCalcer::move
void move(const Coordinate &to, const KigDocument &doc)
This is the method that does the real moving work.
Definition: object_calcer.cc:296
ObjectImpType
Instances of this class represent a certain ObjectImp type.
Definition: object_imp.h:95
ObjectConstCalcer::imp
const ObjectImp * imp() const
Returns the ObjectImp of this ObjectCalcer.
Definition: object_calcer.cc:65
ObjectConstCalcer::setImp
void setImp(ObjectImp *newimp)
Set the ObjectImp of this ObjectConstCalcer to the given newimp.
Definition: object_calcer.cc:241
ObjectCalcer::moveReferencePoint
virtual Coordinate moveReferencePoint() const
In order to support simultaneously moving objects that are in different locations, we need for each object a location that it is assumed to be at, at the moment the moving starts.
Definition: object_calcer.cc:270
ObjectCalcer::move
virtual void move(const Coordinate &to, const KigDocument &doc)
This is the method that does the real moving work.
Definition: object_calcer.cc:276
ObjectTypeCalcer::setParents
void setParents(const std::vector< ObjectCalcer * > np)
Set the parents of this ObjectTypeCalcer to np.
Definition: object_calcer.cc:246
ObjectType::isDefinedOnOrThrough
virtual bool isDefinedOnOrThrough(const ObjectImp *o, const Args &parents) const =0
Supposing that parents would be given as parents to this type's calc function, this function returns ...
ObjectImp::impRequirementForProperty
virtual const ObjectImpType * impRequirementForProperty(int which) const
Definition: object_imp.cc:76
ObjectImp::property
virtual ObjectImp * property(int which, const KigDocument &d) const
Definition: object_imp.cc:70
ObjectImp::getPropLid
int getPropLid(int propgid) const
mp: The following three methods (getPropLid, getPropGid, getPropName) deal with the properties of Obj...
Definition: object_imp.cc:347
ObjectTypeCalcer::setType
void setType(const ObjectType *t)
Definition: object_calcer.cc:255
ObjectPropertyCalcer::parents
std::vector< ObjectCalcer * > parents() const
Returns the parent ObjectCalcer's of this ObjectCalcer.
Definition: object_calcer.cc:176
ObjectCalcer::movableParents
virtual std::vector< ObjectCalcer * > movableParents() const
Moving an object most of the time signifies invoking changes in some of its parents.
Definition: object_calcer.cc:316
ObjectTypeCalcer::moveReferencePoint
Coordinate moveReferencePoint() const
In order to support simultaneously moving objects that are in different locations, we need for each object a location that it is assumed to be at, at the moment the moving starts.
Definition: object_calcer.cc:291
ObjectConstCalcer::calc
void calc(const KigDocument &doc)
Makes the ObjectCalcer recalculate its ObjectImp from its parents.
Definition: object_calcer.cc:70
ObjectPropertyCalcer::ObjectPropertyCalcer
ObjectPropertyCalcer(ObjectCalcer *parent, int propid, bool islocal)
Construct a new ObjectPropertyCalcer, that will get the property from parent with number propid...
Definition: object_calcer.cc:147
ObjectImp::propertiesInternalNames
virtual const QByteArrayList propertiesInternalNames() const
Definition: object_imp.cc:63
ObjectImp::stype
static const ObjectImpType * stype()
The ObjectImpType representing the base ObjectImp class.
Definition: object_imp.cc:284
ObjectPropertyCalcer::isDefinedOnOrThrough
bool isDefinedOnOrThrough(const ObjectCalcer *o) const
If this ObjectCalcer represents a curve, return true if the given point is by construction on this cu...
Definition: object_calcer.cc:331
ObjectType::calc
virtual ObjectImp * calc(const Args &parents, const KigDocument &d) const =0
ObjectType::movableParents
virtual std::vector< ObjectCalcer * > movableParents(const ObjectTypeCalcer &ourobj) const
Definition: object_type.cc:118
Coordinate
The Coordinate class is the basic class representing a 2D location by its x and y components...
Definition: coordinate.h:33
object_type.h
ObjectPropertyCalcer::calc
void calc(const KigDocument &doc)
Makes the ObjectCalcer recalculate its ObjectImp from its parents.
Definition: object_calcer.cc:183
ObjectTypeCalcer::movableParents
std::vector< ObjectCalcer * > movableParents() const
Moving an object most of the time signifies invoking changes in some of its parents.
Definition: object_calcer.cc:321
common.h
ObjectCalcer::~ObjectCalcer
virtual ~ObjectCalcer()
Definition: object_calcer.cc:51
ObjectTypeCalcer::canMove
bool canMove() const
Returns whether this ObjectCalcer supports moving.
Definition: object_calcer.cc:281
ObjectTypeCalcer::impRequirement
const ObjectImpType * impRequirement(ObjectCalcer *o, const std::vector< ObjectCalcer * > &os) const
An ObjectCalcer expects its parents to have an ObjectImp of a certain type.
Definition: object_calcer.cc:228
ObjectTypeCalcer::imp
const ObjectImp * imp() const
Returns the ObjectImp of this ObjectCalcer.
Definition: object_calcer.cc:100
bogus_imp.h
ObjectCalcer
An ObjectCalcer is an object that represents an algorithm for calculating an ObjectImp from other Obj...
Definition: object_calcer.h:66
Args
std::vector< const ObjectImp * > Args
Definition: objects/common.h:47
ObjectPropertyCalcer::propLid
int propLid() const
Definition: object_calcer.cc:352
ObjectConstCalcer::parents
std::vector< ObjectCalcer * > parents() const
Returns the parent ObjectCalcer's of this ObjectCalcer.
Definition: object_calcer.cc:74
ObjectTypeCalcer::ObjectTypeCalcer
ObjectTypeCalcer(const ObjectType *type, const std::vector< ObjectCalcer * > &parents, bool sort=true)
Construct a new ObjectTypeCalcer with a given type and parents.
Definition: object_calcer.cc:43
ObjectCalcer::refcount
int refcount
Definition: object_calcer.h:77
ObjectImp::isPropertyDefinedOnOrThroughThisImp
virtual bool isPropertyDefinedOnOrThroughThisImp(int which) const
Definition: object_imp.cc:326
object_calcer.h
ObjectType::canMove
virtual bool canMove(const ObjectTypeCalcer &ourobj) const
Definition: object_type.cc:46
ObjectType
The ObjectType class is a thing that represents the "behaviour" for a certain type.
Definition: object_type.h:32
ObjectTypeCalcer::type
const ObjectType * type() const
Definition: object_calcer.cc:132
ObjectType::moveReferencePoint
virtual const Coordinate moveReferencePoint(const ObjectTypeCalcer &ourobj) const
Definition: object_type.cc:102
ObjectConstCalcer::ObjectConstCalcer
ObjectConstCalcer(ObjectImp *imp)
Construct a new ObjectConstCalcer with the given imp as the stored ObjectImp.
Definition: object_calcer.cc:55
Coordinate::invalidCoord
static Coordinate invalidCoord()
Create an invalid Coordinate.
Definition: coordinate.cpp:171
ObjectCalcer::ref
void ref()
Definition: object_calcer.cc:80
ObjectPropertyCalcer::imp
const ObjectImp * imp() const
Returns the ObjectImp of this ObjectCalcer.
Definition: object_calcer.cc:171
ObjectType::move
virtual void move(ObjectTypeCalcer &ourobj, const Coordinate &to, const KigDocument &d) const
Definition: object_type.cc:56
ObjectCalcer::canMove
virtual bool canMove() const
Returns whether this ObjectCalcer supports moving.
Definition: object_calcer.cc:260
ObjectPropertyCalcer::propGid
int propGid() const
Definition: object_calcer.cc:357
ObjectCalcer::mchildren
std::vector< ObjectCalcer * > mchildren
Definition: object_calcer.h:84
ObjectTypeCalcer::isDefinedOnOrThrough
bool isDefinedOnOrThrough(const ObjectCalcer *o) const
If this ObjectCalcer represents a curve, return true if the given point is by construction on this cu...
Definition: object_calcer.cc:338
ObjectType::impRequirement
virtual const ObjectImpType * impRequirement(const ObjectImp *o, const Args &parents) const =0
Supposing that parents would be given as parents to this type's calc function, this function returns ...
intrusive_ptr_release
void intrusive_ptr_release(ObjectCalcer *p)
Definition: object_calcer.cc:95
KigDocument
KigDocument is the class holding the real data in a Kig document.
Definition: kig_document.h:36
ObjectTypeCalcer::isFreelyTranslatable
bool isFreelyTranslatable() const
Returns whether this ObjectCalcer can be translated at any position in the coordinate plane...
Definition: object_calcer.cc:286
ObjectCalcer::imp
virtual const ObjectImp * imp() const =0
Returns the ObjectImp of this ObjectCalcer.
ObjectTypeCalcer::parents
std::vector< ObjectCalcer * > parents() const
Returns the parent ObjectCalcer's of this ObjectCalcer.
Definition: object_calcer.cc:105
ObjectTypeCalcer::~ObjectTypeCalcer
~ObjectTypeCalcer()
Definition: object_calcer.cc:125
ObjectCalcer::children
std::vector< ObjectCalcer * > children() const
Returns the child ObjectCalcer's of this ObjectCalcer.
Definition: object_calcer.cc:209
ObjectConstCalcer::isDefinedOnOrThrough
bool isDefinedOnOrThrough(const ObjectCalcer *o) const
If this ObjectCalcer represents a curve, return true if the given point is by construction on this cu...
Definition: object_calcer.cc:326
ObjectTypeCalcer::calc
void calc(const KigDocument &doc)
Makes the ObjectCalcer recalculate its ObjectImp from its parents.
Definition: object_calcer.cc:32
ObjectConstCalcer::~ObjectConstCalcer
~ObjectConstCalcer()
Definition: object_calcer.cc:60
ObjectCalcer::addChild
void addChild(ObjectCalcer *c)
a calcer should call this to register itself as a child of this calcer.
Definition: object_calcer.cc:110
ObjectImp
The ObjectImp class represents the behaviour of an object after it is calculated. ...
Definition: object_imp.h:226
object_holder.h
ObjectCalcer::delChild
void delChild(ObjectCalcer *c)
a calcer should call this in its destructor, to inform its parent that it is no longer a child of thi...
Definition: object_calcer.cc:116
ObjectConstCalcer::impRequirement
const ObjectImpType * impRequirement(ObjectCalcer *o, const std::vector< ObjectCalcer * > &os) const
An ObjectCalcer expects its parents to have an ObjectImp of a certain type.
Definition: object_calcer.cc:221
ObjectCalcer::ObjectCalcer
ObjectCalcer()
Definition: object_calcer.cc:311
ObjectCalcer::deref
void deref()
Definition: object_calcer.cc:85
ObjectPropertyCalcer::parent
ObjectCalcer * parent() const
Definition: object_calcer.cc:306
ObjectImp::getPropGid
int getPropGid(const char *pname) const
Definition: object_imp.cc:333
ObjectPropertyCalcer::impRequirement
const ObjectImpType * impRequirement(ObjectCalcer *o, const std::vector< ObjectCalcer * > &os) const
An ObjectCalcer expects its parents to have an ObjectImp of a certain type.
Definition: object_calcer.cc:214
InvalidImp
This ObjectImp represents an invalid object.
Definition: bogus_imp.h:61
ObjectPropertyCalcer::~ObjectPropertyCalcer
~ObjectPropertyCalcer()
Definition: object_calcer.cc:162
ObjectType::isFreelyTranslatable
virtual bool isFreelyTranslatable(const ObjectTypeCalcer &ourobj) const
Definition: object_type.cc:51
intrusive_ptr_add_ref
void intrusive_ptr_add_ref(ObjectCalcer *p)
Definition: object_calcer.cc:90
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