KoShape.h 47 KB
Newer Older
Thomas Zander's avatar
Thomas Zander committed
1
/* This file is part of the KDE project
2
   Copyright (C) 2006-2008 Thorsten Zachmann <zachmann@kde.org>
C. Boemann's avatar
C. Boemann committed
3
   Copyright (C) 2006, 2008 C. Boemann <cbo@boemann.dk>
4
   Copyright (C) 2006-2010 Thomas Zander <zander@kde.org>
5
   Copyright (C) 2007-2009,2011 Jan Hambrecht <jaham@gmx.net>
Thomas Zander's avatar
Thomas Zander committed
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/

Thomas Zander's avatar
Thomas Zander committed
23 24
#ifndef KOSHAPE_H
#define KOSHAPE_H
Thomas Zander's avatar
Thomas Zander committed
25

26
#include "KoFlake.h"
27
#include "KoFlakeTypes.h"
28
#include "KoConnectionPoint.h"
29

30
#include <QSharedPointer>
31
#include <QSet>
32
#include <QMetaType>
Thomas Zander's avatar
Thomas Zander committed
33

34 35
#include <KoXmlReaderForward.h>

36
#include "kritaflake_export.h"
37

Thomas Zander's avatar
Thomas Zander committed
38 39 40
class QPainter;
class QRectF;
class QPainterPath;
41
class QTransform;
Thomas Zander's avatar
Thomas Zander committed
42 43

class KoShapeContainer;
44
class KoShapeStrokeModel;
45
class KoShapeUserData;
46
class KoViewConverter;
47
class KoShapeApplicationData;
48
class KoShapeSavingContext;
49
class KoShapeLoadingContext;
50
class KoGenStyle;
51
class KoShapeShadow;
52
class KoShapePrivate;
53
class KoFilterEffectStack;
54
class KoSnapData;
55
class KoClipPath;
56
class KoClipMask;
57
class KoShapePaintingContext;
58
class KoShapeAnchor;
59
class KoBorder;
60
struct KoInsets;
61
class KoShapeBackground;
62
class KisHandlePainterHelper;
Thomas Zander's avatar
Thomas Zander committed
63

64

Thomas Zander's avatar
Thomas Zander committed
65
/**
66
 *
67
 * Base class for all flake shapes. Shapes extend this class
Thomas Zander's avatar
Thomas Zander committed
68 69 70
 * to allow themselves to be manipulated. This class just represents
 * a graphical shape in the document and can be manipulated by some default
 * tools in this library.
71
 *
72
 * Due to the limited responsibility of this class, the extending object
Thomas Zander's avatar
Thomas Zander committed
73
 * can have any data backend and is responsible for painting itself.
74
 *
75
 * We strongly suggest that any extending class will use a Model View
Thomas Zander's avatar
Thomas Zander committed
76
 * Controller (MVC) design where the View part is all in this class, as well
77
 * as the one that inherits from this one.  This allows the data that rests
Thomas Zander's avatar
Thomas Zander committed
78
 * in the model to be reused in different parts of the document. For example
79
 * by having two flake objects that show that same data. Or each showing a section of it.
80
 *
81 82 83 84 85
 * The KoShape data is completely in postscript-points (pt) (see KoUnit
 * for conversion methods to and from points).
 * This image will explain the real-world use of the shape and its options.
 * <img src="../flake_shape_coords.png" align=center><br>
 *  The Rotation center can be returned with absolutePosition()
86
 *
87
 * <p>Flake objects can be created in three ways:
88 89 90 91 92
 * <ul>
 *   <li>a simple new KoDerivedFlake(),
 *   <li>through an associated tool,
 *   <li>through a factory
 * </ul>
93
 *
Thomas Zander's avatar
Thomas Zander committed
94 95 96 97 98 99 100 101 102 103 104 105 106
 * <h1>Shape interaction notifications</h1>
 * We had several notification methods that allow your shape to be notified of changes in other
 * shapes positions or rotation etc.
 * <ol><li>The most general is KoShape::shapeChanged().<br>
 * a virtual method that you can use to check various changed to your shape made by tools or otherwise.</li>
 * <li>for shape hierarchies the parent may receive a notification when a child was modified.
 *  This is done though KoShapeContainerModel::childChanged()</li>
 * <li>any shape that is at a similar position as another shape there is collision detection.
 * You can register your shape to be sensitive to any changes like moving or whatever to
 * <b>other</b> shapes that intersect yours.
 * Such changes will then be notified to your shape using the method from (1) You should call
 * KoShape::setCollisionDetection(bool) to enable this.
 * </ol>
Thomas Zander's avatar
Thomas Zander committed
107
 */
108
class KRITAFLAKE_EXPORT KoShape
Thomas Zander's avatar
Thomas Zander committed
109 110
{
public:
111 112 113
    /// Used by shapeChanged() to select which change was made
    enum ChangeType {
        PositionChanged, ///< used after a setPosition()
114
        RotationChanged, ///< used after a setRotation()
Thomas Zander's avatar
Thomas Zander committed
115
        ScaleChanged,   ///< used after a scale()
Thomas Zander's avatar
Thomas Zander committed
116
        ShearChanged,   ///< used after a shear()
117
        SizeChanged,    ///< used after a setSize()
118
        GenericMatrixChange,    ///< used after the matrix was changed without knowing which property explicitly changed
119
        KeepAspectRatioChange, ///< used after setKeepAspectRatio()
120
        ParentChanged,   ///< used after a setParent()
121
        CollisionDetected, ///< used when another shape moved in our boundingrect
122
        Deleted, ///< the shape was deleted
123
        StrokeChanged, ///< the shapes stroke has changed
124
        BackgroundChanged, ///< the shapes background has changed
125
        ShadowChanged, ///< the shapes shadow has changed
126
        BorderChanged, ///< the shapes border has changed
127 128
        ParameterChanged, ///< the shapes parameter has changed (KoParameterShape only)
        ContentChanged, ///< the content of the shape changed e.g. a new image inside a pixmap/text change inside a textshape
129
        TextRunAroundChanged, ///< used after a setTextRunAroundSide()
Jan Hambrecht's avatar
Jan Hambrecht committed
130
        ChildChanged, ///< a child of a container was changed/removed. This is propagated to all parents
131
        ConnectionPointChanged, ///< a connection point has changed
132 133
        ClipPathChanged, ///< the shapes clip path has changed
        TransparencyChanged ///< the shapetransparency value has changed
134 135
    };

136 137 138 139 140
    /// The behavior text should do when intersecting this shape.
    enum TextRunAroundSide {
        BiggestRunAroundSide,   ///< Run other text around the side that has the most space
        LeftRunAroundSide,      ///< Run other text around the left side of the frame
        RightRunAroundSide,     ///< Run other text around the right side of the frame
141
        EnoughRunAroundSide,      ///< Run other text dynamically around both sides of the shape, provided there is sufficient space left
142 143 144 145 146
        BothRunAroundSide,      ///< Run other text around both sides of the shape
        NoRunAround,            ///< The text will be completely avoiding the frame by keeping the horizontal space that this frame occupies blank.
        RunThrough              ///< The text will completely ignore the frame and layout as if it was not there
    };

147 148 149 150 151 152 153
    /// The behavior text should do when intersecting this shape.
    enum TextRunAroundContour {
        ContourBox,     /// Run other text around a bounding rect of the outline
        ContourFull,   ///< Run other text around also on the inside
        ContourOutside   ///< Run other text around only on the outside
    };

154 155 156
    /**
     * TODO
     */
157
    enum RunThroughLevel {
158 159 160 161
        Background,
        Foreground
    };

Thomas Zander's avatar
Thomas Zander committed
162 163 164 165 166 167 168 169 170 171
    /**
     * @brief Constructor
     */
    KoShape();

    /**
     * @brief Destructor
     */
    virtual ~KoShape();

172 173 174 175 176 177
    /**
     * @brief creates a deep copy of thie shape or shapes subtree
     * @return a cloned shape
     */
    virtual KoShape* cloneShape() const;

Thomas Zander's avatar
Thomas Zander committed
178 179 180 181
    /**
     * @brief Paint the shape
     * The class extending this one is responsible for painting itself.  Since we do not
     * assume the shape is square the paint must also clear its background if it will draw
182
     * something transparent on top.
Thomas Zander's avatar
Thomas Zander committed
183 184 185 186
     * This can be done with a method like:
     * <code>
       painter.fillRect(converter.normalToView(QRectF(QPointF(0.0,0.0), size())), background());</code>
     * Or equavalent for non-square objects.
187 188
     * Do note that a shape's top-left is always at coordinate 0,0. Even if the shape itself is rotated
     * or translated.
Thomas Zander's avatar
Thomas Zander committed
189 190 191
     * @param painter used for painting the shape
     * @param converter to convert between internal and view coordinates.
     * @see applyConversion()
192
     * @param paintcontext the painting context.
Thomas Zander's avatar
Thomas Zander committed
193
     */
194
    virtual void paint(QPainter &painter, const KoViewConverter &converter, KoShapePaintingContext &paintcontext) = 0;
Thomas Zander's avatar
Thomas Zander committed
195

196 197 198 199 200 201 202 203 204
    /**
     * @brief Paint the shape's border
     * This is a helper function that could be called from the paint() method of all shapes. 
     * @param painter used for painting the shape
     * @param converter to convert between internal and view coordinates.
     * @see applyConversion()
     */
    virtual void paintBorder(QPainter &painter, const KoViewConverter &converter);

205 206 207 208 209 210
    /**
     * Load a shape from odf
     *
     * @param context the KoShapeLoadingContext used for loading
     * @param element element which represents the shape in odf
     *
211
     * @return false if loading failed
212
     */
213
    virtual bool loadOdf(const KoXmlElement &element, KoShapeLoadingContext &context) = 0;
214

215
    /**
216
     * @brief store the shape data as ODF XML.
Thomas Zander's avatar
fix dox  
Thomas Zander committed
217
     * This is the method that will be called when saving a shape as a described in
218
     * OpenDocument 9.2 Drawing Shapes.
Thorsten Zachmann's avatar
Thorsten Zachmann committed
219
     * @see saveOdfAttributes
220
     */
221
    virtual void saveOdf(KoShapeSavingContext &context) const = 0;
222 223

    /**
224 225 226 227 228 229
     * This method can be used while saving the shape as ODF to add the data
     * stored on this shape to the current element.
     *
     * @param context the context for the current save.
     * @param attributes a number of OdfAttribute items to state which attributes to save.
     * @see saveOdf
230
     */
231
    void saveOdfAttributes(KoShapeSavingContext &context, int attributes) const;
232

Thorsten Zachmann's avatar
Thorsten Zachmann committed
233 234 235 236
    /**
     * This method can be used while saving the shape as Odf to add common child elements
     *
     * The office:event-listeners and draw:glue-point are saved.
237
     * @param context the context for the current save.
Thorsten Zachmann's avatar
Thorsten Zachmann committed
238
     */
239
    void saveOdfCommonChildElements(KoShapeSavingContext &context) const;
Thorsten Zachmann's avatar
Thorsten Zachmann committed
240

241 242 243 244 245 246 247 248 249
    /**
     * This method can be used to save contour data from the clipPath()
     *
     * The draw:contour-polygon or draw:contour-path elements are saved.
     * @param context the context for the current save.
     * @param originalSize the original size of the unscaled image.
     */
    void saveOdfClipContour(KoShapeSavingContext &context, const QSizeF &originalSize) const;

Thomas Zander's avatar
Thomas Zander committed
250 251 252 253 254 255 256
    /**
     * @brief Scale the shape using the zero-point which is the top-left corner.
     * @see position()
     *
     * @param sx scale in x direction
     * @param sy scale in y direction
     */
Thomas Zander's avatar
Thomas Zander committed
257
    void scale(qreal sx, qreal sy);
Thomas Zander's avatar
Thomas Zander committed
258 259

    /**
260
     * @brief Rotate the shape (relative)
Thomas Zander's avatar
Thomas Zander committed
261
     *
262
     * The shape will be rotated from the current rotation using the center of the shape using the size()
Thomas Zander's avatar
Thomas Zander committed
263
     *
264
     * @param angle change the angle of rotation increasing it with 'angle' degrees
Thomas Zander's avatar
Thomas Zander committed
265
     */
266
    void rotate(qreal angle);
Thomas Zander's avatar
Thomas Zander committed
267 268 269

    /**
     * Return the current rotation in degrees.
270
     * It returns NaN if the shape has a shearing or scaling transformation applied.
Thomas Zander's avatar
Thomas Zander committed
271
     */
272
    qreal rotation() const;
Thomas Zander's avatar
Thomas Zander committed
273 274 275 276 277 278 279 280 281

    /**
     * @brief Shear the shape
     * The shape will be sheared using the zero-point which is the top-left corner.
     * @see position()
     *
     * @param sx shear in x direction
     * @param sy shear in y direction
     */
Thomas Zander's avatar
Thomas Zander committed
282
    void shear(qreal sx, qreal sy);
Thomas Zander's avatar
Thomas Zander committed
283 284 285 286

    /**
     * @brief Resize the shape
     *
287
     * @param size the new size of the shape.  This is different from scaling as
Jan Hambrecht's avatar
Jan Hambrecht committed
288
     * scaling is a so called secondary operation which is comparable to zooming in
Thomas Zander's avatar
Thomas Zander committed
289 290
     * instead of changing the size of the basic shape.
     * Easiest example of this difference is that using this method will not distort the
291
     * size of pattern-fills and strokes.
Thomas Zander's avatar
Thomas Zander committed
292
     */
293
    virtual void setSize(const QSizeF &size);
Thomas Zander's avatar
Thomas Zander committed
294 295 296 297

    /**
     * @brief Get the size of the shape in pt.
     *
Thorsten Zachmann's avatar
Thorsten Zachmann committed
298 299
     * The size is in shape coordinates.
     *
Inge Wallin's avatar
Inge Wallin committed
300
     * @return the size of the shape as set by setSize()
Thomas Zander's avatar
Thomas Zander committed
301
     */
Thomas Zander's avatar
Thomas Zander committed
302
    virtual QSizeF size() const;
Thomas Zander's avatar
Thomas Zander committed
303 304 305 306 307 308

    /**
     * @brief Set the position of the shape in pt
     *
     * @param position the new position of the shape
     */
309
    virtual void setPosition(const QPointF &position);
Thomas Zander's avatar
Thomas Zander committed
310 311 312 313 314 315

    /**
     * @brief Get the position of the shape in pt
     *
     * @return the position of the shape
     */
316
    QPointF position() const;
Thomas Zander's avatar
Thomas Zander committed
317 318 319 320 321 322

    /**
     * @brief Check if the shape is hit on position
     * @param position the position where the user clicked.
     * @return true when it hits.
     */
323
    virtual bool hitTest(const QPointF &position) const;
Thomas Zander's avatar
Thomas Zander committed
324 325 326 327

    /**
     * @brief Get the bounding box of the shape
     *
328
     * This includes the line width and the shadow of the shape
Thomas Zander's avatar
Thomas Zander committed
329 330 331
     *
     * @return the bounding box of the shape
     */
332
    virtual QRectF boundingRect() const;
Thomas Zander's avatar
Thomas Zander committed
333

334 335 336 337 338 339
    /**
     * Get the united bounding box of a group of shapes. This is a utility
     * function used in many places in Krita.
     */
    static QRectF boundingRect(const QList<KoShape*> &shapes);

340 341 342 343 344 345 346 347 348 349 350 351 352 353
    /**
     * @return the bounding rect of the outline of the shape measured
     *         in absolute coordinate system. Please note that in contrast to
     *         boundingRect() this rect doesn't include the stroke and other
     *         insets.
     */
    QRectF absoluteOutlineRect(KoViewConverter *converter = 0) const;

    /**
     * Same as a member function, but applies to a list of shapes and returns a
     * united rect.
     */
    static QRectF absoluteOutlineRect(const QList<KoShape*> &shapes, KoViewConverter *converter = 0);

Thomas Zander's avatar
Thomas Zander committed
354 355
    /**
     * @brief Add a connector point to the shape
356
     *
Thomas Zander's avatar
Thomas Zander committed
357 358 359
     * A connector is a place on the shape that allows a graphical connection to be made
     * using a line, for example.
     *
360
     * @param point the connection point to add
361
     * @return the id of the new connection point
Thomas Zander's avatar
Thomas Zander committed
362
     */
363
    int addConnectionPoint(const KoConnectionPoint &point);
364

365
    /**
366
     * Sets data of connection point with specified id.
367 368
     *
     * The position of the connector is restricted to the bounding rectangle of the shape.
369 370 371 372
     * When setting a default connection point, the new position is ignored, as these
     * are fixed at their default position.
     * The function will insert a new connection point if the specified id was not used
     * before.
373
     *
374 375 376
     * @param connectionPointId the id of the connection point to set
     * @param point the connection point data
     * @return false if specified connection point id is invalid, else true
377
     */
378
    bool setConnectionPoint(int connectionPointId, const KoConnectionPoint &point);
379

380 381 382 383
    /// Checks if a connection point with the specified id exists
    bool hasConnectionPoint(int connectionPointId) const;

    /// Returns connection point with specified connection point id
384
    KoConnectionPoint connectionPoint(int connectionPointId) const;
Thomas Zander's avatar
Thomas Zander committed
385

386 387
    /**
     * Return a list of the connection points that have been added to this shape.
Thomas Zander's avatar
Thomas Zander committed
388
     * All the points are relative to the shape position, see absolutePosition().
389 390
     * @return a list of the connectors that have been added to this shape.
     */
391
    KoConnectionPoints connectionPoints() const;
Thomas Zander's avatar
Thomas Zander committed
392

393 394 395 396 397 398
    /// Removes connection point with specified id
    void removeConnectionPoint(int connectionPointId);

    /// Removes all connection points
    void clearConnectionPoints();

399
    /**
Sebastian Sauer's avatar
dox++  
Sebastian Sauer committed
400 401
     * Return the side text should flow around this shape. This implements the ODF style:wrap
     * attribute that specifies how text is displayed around a frame or graphic object.
402 403 404 405 406 407
     */
    TextRunAroundSide textRunAroundSide() const;

    /**
     * Set the side text should flow around this shape.
     * @param side the requested side
Sebastian Sauer's avatar
dox++  
Sebastian Sauer committed
408
     * @param runThrought run through the foreground or background or...
409
     */
410
    void setTextRunAroundSide(TextRunAroundSide side, RunThroughLevel runThrough = Background);
411 412

    /**
413
     * The space between this shape's left edge and text that runs around this shape.
414 415
     * @return the space around this shape to keep free from text
     */
416
    qreal textRunAroundDistanceLeft() const;
417 418

    /**
419
     * Set the space between this shape's left edge and the text that run around this shape.
420 421
     * @param distance the space around this shape to keep free from text
     */
422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458
    void setTextRunAroundDistanceLeft(qreal distance);

    /**
     * The space between this shape's top edge and text that runs around this shape.
     * @return the space around this shape to keep free from text
     */
    qreal textRunAroundDistanceTop() const;

    /**
     * Set the space between this shape's top edge and the text that run around this shape.
     * @param distance the space around this shape to keep free from text
     */
    void setTextRunAroundDistanceTop(qreal distance);

    /**
     * The space between this shape's right edge and text that runs around this shape.
     * @return the space around this shape to keep free from text
     */
    qreal textRunAroundDistanceRight() const;

    /**
     * Set the space between this shape's right edge and the text that run around this shape.
     * @param distance the space around this shape to keep free from text
     */
    void setTextRunAroundDistanceRight(qreal distance);

    /**
     * The space between this shape's bottom edge and text that runs around this shape.
     * @return the space around this shape to keep free from text
     */
    qreal textRunAroundDistanceBottom() const;

    /**
     * Set the space between this shape's bottom edge and the text that run around this shape.
     * @param distance the space around this shape to keep free from text
     */
    void setTextRunAroundDistanceBottom(qreal distance);
459

460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
    /**
     * Return the threshold above which text should flow around this shape.
     * The text will not flow around the shape on a side unless the space available on that side
     * is above this threshold. Only used when the text run around side is EnoughRunAroundSide.
     * @return threshold the threshold
     */
    qreal textRunAroundThreshold() const;

    /**
     * Set the threshold above which text should flow around this shape.
     * The text will not flow around the shape on a side unless the space available on that side
     * is above this threshold. Only used when the text run around side is EnoughRunAroundSide.
     * @param threshold the new threshold
     */
    void setTextRunAroundThreshold(qreal threshold);

476 477 478 479 480 481 482 483 484 485 486 487
    /**
     * Return the how tight text run around is done around this shape.
     * @return the contour
     */
    TextRunAroundContour textRunAroundContour() const;

    /**
     * Set how tight text run around is done around this shape.
     * @param contour the new contour
     */
    void setTextRunAroundContour(TextRunAroundContour contour);

488 489 490 491 492 493 494 495 496 497
    /**
     * Set the KoShapeAnchor
     */
    void setAnchor(KoShapeAnchor *anchor);

    /**
     * Return the KoShapeAnchor, or 0
     */
    KoShapeAnchor *anchor() const;

498 499 500 501 502 503 504 505 506 507 508 509 510 511
    /**
     * Set the minimum height of the shape.
     * Currently it's not respected but only for informational purpose
     * @param minimumShapeHeight the minimum height of the frame.
     */
    void setMinimumHeight(qreal height);

    /**
     * Return the minimum height of the shape.
     * @return the minimum height of the shape. Default is 0.0.
     */
    qreal minimumHeight() const;


Thomas Zander's avatar
Thomas Zander committed
512 513
    /**
     * Set the background of the shape.
514
     * A shape background can be a plain color, a gradient, a pattern, be fully transparent
Jan Hambrecht's avatar
Jan Hambrecht committed
515
     * or have a complex fill.
516
     * Setting such a background will allow the shape to be filled and will be able to tell
Jan Hambrecht's avatar
Jan Hambrecht committed
517 518
     * if it is transparent or not.
     * @param background the new shape background.
Thomas Zander's avatar
Thomas Zander committed
519
     */
520
    void setBackground(QSharedPointer<KoShapeBackground> background);
521

Thomas Zander's avatar
Thomas Zander committed
522 523
    /**
     * return the brush used to paint te background of this shape with.
524
     * A QBrush can have a plain color, be fully transparent or have a complex fill.
Thomas Zander's avatar
Thomas Zander committed
525
     * setting such a brush will allow the shape to fill itself using that brush and
526
     * will be able to tell if its transparent or not.
Thomas Zander's avatar
Thomas Zander committed
527 528
     * @return the background-brush
     */
529
    QSharedPointer<KoShapeBackground> background() const;
Thomas Zander's avatar
Thomas Zander committed
530 531

    /**
532 533
     * Returns true if there is some transparency, false if the shape is fully opaque.
     * The default implementation will just return if the background has some transparency,
Thomas Zander's avatar
Thomas Zander committed
534
     * you should override it and always return true if your shape is not square.
535
     * @return if the shape is (partly) transparent.
Thomas Zander's avatar
Thomas Zander committed
536
     */
Thomas Zander's avatar
Thomas Zander committed
537
    virtual bool hasTransparency() const;
Thomas Zander's avatar
Thomas Zander committed
538

539 540 541 542 543
    /**
     * Sets shape level transparency.
     * @param transparency the new shape level transparency
     */
    void setTransparency(qreal transparency);
544

545 546 547 548 549
    /**
     * Returns the shape level transparency.
     * @param recursive when true takes the parents transparency into account
     */
    qreal transparency(bool recursive=false) const;
550

Thomas Zander's avatar
Thomas Zander committed
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566
    /**
     * Retrieve the z-coordinate of this shape.
     * The zIndex property is used to determine which shape lies on top of other objects.
     * An shape with a higher z-order is on top, and can obscure another shape.
     * @return the z-index of this shape.
     * @see setZIndex()
     */
    int zIndex() const;

    /**
     * Set the z-coordinate of this shape.
     * The zIndex property is used to determine which shape lies on top of other objects.
     * An shape with a higher z-order is on top, and can obscure, another shape.
     * <p>Just like two objects having the same x or y coordinate will make them 'touch',
     * so will two objects with the same z-index touch on the z plane.  In layering the
     * shape this, however, can cause a little confusion as one always has to be on top.
567
     * The layering if two overlapping objects have the same index is implementation dependent
Thomas Zander's avatar
Thomas Zander committed
568 569 570
     * and probably depends on the order in which they are added to the shape manager.
     * @param zIndex the new z-index;
     */
Thomas Zander's avatar
Thomas Zander committed
571
    void setZIndex(int zIndex);
Thomas Zander's avatar
Thomas Zander committed
572

573 574 575 576 577 578 579 580 581 582 583 584
    /**
     * Retrieve the run through property of this shape.
     * The run through property is used to determine if the shape is behind, inside or before text.
     * @return the run through of this shape.
     */
    int runThrough();

    /**
     * Set the run through property of this shape.
     * The run through property is used to determine if the shape is behind, inside or before text.
     * @param runThrough the new run through;
     */
Thorsten Zachmann's avatar
Thorsten Zachmann committed
585
    virtual void setRunThrough(short int runThrough);
586

Thomas Zander's avatar
Thomas Zander committed
587 588
    /**
     * Changes the Shape to be visible or invisible.
589
     * Being visible means being painted, as well as being used for
Thomas Zander's avatar
Thomas Zander committed
590 591
     *   things like guidelines or searches.
     * @param on when true; set the shape to be visible.
592
     * @see setGeometryProtected(), setContentProtected(), setSelectable()
Thomas Zander's avatar
Thomas Zander committed
593
     */
Thomas Zander's avatar
Thomas Zander committed
594
    void setVisible(bool on);
Thomas Zander's avatar
Thomas Zander committed
595 596
    /**
     * Returns current visibility state of this shape.
597
     * Being visible means being painted, as well as being used for
Thomas Zander's avatar
Thomas Zander committed
598
     *   things like guidelines or searches.
599
     * @param recursive when true, checks visibility recursively
Thomas Zander's avatar
Thomas Zander committed
600
     * @return current visibility state of this shape.
601
     * @see isGeometryProtected(), isContentProtected(), isSelectable()
Thomas Zander's avatar
Thomas Zander committed
602
     */
603
    bool isVisible(bool recursive = false) const;
Thomas Zander's avatar
Thomas Zander committed
604

605 606 607 608 609
    /**
     * Changes the shape to be printable or not. The default is true.
     *
     * If a Shape's print flag is true, the shape will be printed. If
     * false, the shape will not be printed. If a shape is not visible (@see isVisible),
610
     * it isPrinted will return false, too.
611 612 613 614 615 616 617 618 619 620 621 622
     */
    void setPrintable(bool on);

    /**
     * Returns the current printable state of this shape.
     *
     * A shape can be visible but not printable, not printable and not visible
     * or visible and printable, but not invisible and still printable.
     *
     * @return current printable state of this shape.
     */
    bool isPrintable() const;
623

624 625 626
    /**
     * Makes it possible for the user to select this shape.
     * This parameter defaults to true.
Thomas Zander's avatar
Thomas Zander committed
627
     * @param selectable when true; set the shape to be selectable by the user.
628
     * @see setGeometryProtected(), setContentProtected(), setVisible()
629
     */
Thomas Zander's avatar
Thomas Zander committed
630
    void setSelectable(bool selectable);
631

632
    /**
Thomas Zander's avatar
Thomas Zander committed
633
     * Returns if this shape can be selected by the user.
634
     * @return true only when the object is selectable.
635
     * @see isGeometryProtected(), isContentProtected(), isVisible()
636
     */
Thomas Zander's avatar
Thomas Zander committed
637
    bool isSelectable() const;
638

Thomas Zander's avatar
Thomas Zander committed
639
    /**
640 641 642 643
     * Tells the shape to have its position/rotation and size protected from user-changes.
     * The geometry being protected means the user can not change shape or position of the
     * shape. This includes any matrix operation such as rotation.
     * @param on when true; set the shape to have its geometry protected.
644
     * @see setContentProtected(), setSelectable(), setVisible()
Thomas Zander's avatar
Thomas Zander committed
645
     */
646
    void setGeometryProtected(bool on);
647

Thomas Zander's avatar
Thomas Zander committed
648
    /**
649 650 651 652
     * Returns current geometry protection state of this shape.
     * The geometry being protected means the user can not change shape or position of the
     * shape. This includes any matrix operation such as rotation.
     * @return current geometry protection state of this shape.
653
     * @see isContentProtected(), isSelectable(), isVisible()
Thomas Zander's avatar
Thomas Zander committed
654
     */
655
    bool isGeometryProtected() const;
Thomas Zander's avatar
Thomas Zander committed
656

657 658 659 660
    /**
     * Marks the shape to have its content protected against editing.
     * Content protection is a hint for tools to disallow the user editing the content.
     * @param protect when true set the shapes content to be protected from user modification.
661
     * @see setGeometryProtected(), setSelectable(), setVisible()
662 663
     */
    void setContentProtected(bool protect);
664

665 666 667 668
    /**
     * Returns current content protection state of this shape.
     * Content protection is a hint for tools to disallow the user editing the content.
     * @return current content protection state of this shape.
669
     * @see isGeometryProtected(), isSelectable(), isVisible()
670 671 672
     */
    bool isContentProtected() const;

Thomas Zander's avatar
Thomas Zander committed
673 674 675 676
    /**
     * Returns the parent, or 0 if there is no parent.
     * @return the parent, or 0 if there is no parent.
     */
Thomas Zander's avatar
Thomas Zander committed
677
    KoShapeContainer *parent() const;
Thomas Zander's avatar
Thomas Zander committed
678 679 680 681 682 683 684

    /**
     * Set the parent of this shape.
     * @param parent the new parent of this shape. Can be 0 if the shape has no parent anymore.
     */
    void setParent(KoShapeContainer *parent);

685 686 687 688 689 690 691 692 693

    /**
     * @brief inheritsTransformFromAny checks if the shape inherits transformation from
     *        any of the shapes listed in \p ancestorsInQuestion. The inheritance is checked
     *        in recursive way.
     * @return true if there is a (transitive) transformation-wise parent found in \p ancestorsInQuestion
     */
    bool inheritsTransformFromAny(const QList<KoShape*> ancestorsInQuestion) const;

Thomas Zander's avatar
Thomas Zander committed
694 695 696 697 698 699 700
    /**
     * Request a repaint to be queued.
     * The repaint will be of the entire Shape, including its selection handles should this
     * shape be selected.
     * <p>This method will return immediately and only request a repaint. Successive calls
     * will be merged into an appropriate repaint action.
     */
701
    virtual void update() const;
Thomas Zander's avatar
Thomas Zander committed
702 703 704 705 706 707 708 709

    /**
     * Request a repaint to be queued.
     * The repaint will be restricted to the parameters rectangle, which is expected to be
     * in points (the internal coordinates system of KoShape) and it is expected to be
     * normalized.
     * <p>This method will return immediately and only request a repaint. Successive calls
     * will be merged into an appropriate repaint action.
Boudewijn Rempt's avatar
Boudewijn Rempt committed
710
     * @param rect the rectangle (in pt) to queue for repaint.
Thomas Zander's avatar
Thomas Zander committed
711
     */
Boudewijn Rempt's avatar
Boudewijn Rempt committed
712
    virtual void update(const QRectF &rect) const;
Thomas Zander's avatar
Thomas Zander committed
713

714 715 716 717 718 719 720
    /// Used by compareShapeZIndex() to order shapes
    enum ChildZOrderPolicy {
        ChildZDefault,
        ChildZParentChild = ChildZDefault, ///< normal parent/child ordering
        ChildZPassThrough ///< children are considered equal to this shape
    };

721
   /**
722 723 724 725 726 727 728 729
    * Returns if during compareShapeZIndex() how this shape portrays the values
    * of its children. The default behaviour is to let this shape's z values take
    * the place of its childrens values, so you get a parent/child relationship.
    * The children are naturally still ordered relatively to their z values
    *
    * But for special cases (like Calligra's TextShape) it can be overloaded to return
    * ChildZPassThrough which means the children keep their own z values
    * @returns the z order policy of this shape
730
    */
731
    virtual ChildZOrderPolicy childZOrderPolicy();
732

Thomas Zander's avatar
Thomas Zander committed
733 734
    /**
     * This is a method used to sort a list using the STL sorting methods.
735 736
     * @param s1 the first shape
     * @param s2 the second shape
Thomas Zander's avatar
Thomas Zander committed
737
     */
738
    static bool compareShapeZIndex(KoShape *s1, KoShape *s2);
Thomas Zander's avatar
Thomas Zander committed
739 740 741

    /**
     * returns the outline of the shape in the form of a path.
Casper Boemann's avatar
Casper Boemann committed
742
     * The outline returned will always be relative to the position() of the shape, so
743
     * moving the shape will not alter the result.  The outline is used to draw the stroke
Thomas Zander's avatar
Thomas Zander committed
744 745 746
     * on, for example.
     * @returns the outline of the shape in the form of a path.
     */
747
    virtual QPainterPath outline() const;
Thomas Zander's avatar
Thomas Zander committed
748

749 750
    /**
     * returns the outline of the shape in the form of a rect.
Casper Boemann's avatar
Casper Boemann committed
751 752 753
     * The outlineRect returned will always be relative to the position() of the shape, so
     * moving the shape will not alter the result.  The outline is used to calculate
     * the boundingRect.
754 755 756 757
     * @returns the outline of the shape in the form of a rect.
     */
    virtual QRectF outlineRect() const;

758 759 760 761 762 763 764 765 766 767 768 769
    /**
     * returns the outline of the shape in the form of a path for the use of painting a shadow.
     *
     * Normally this would be the same as outline() if there is a fill (background) set on the
     * shape and empty if not.  However, a shape could reimplement this to return an outline
     * even if no fill is defined. A typical example of this would be the picture shape
     * which has a picture but almost never a background. 
     *
     * @returns the outline of the shape in the form of a path.
     */
    virtual QPainterPath shadowOutline() const;

Thomas Zander's avatar
Thomas Zander committed
770
    /**
771 772
     * Returns the currently set stroke, or 0 if there is no stroke.
     * @return the currently set stroke, or 0 if there is no stroke.
Thomas Zander's avatar
Thomas Zander committed
773
     */
774
    KoShapeStrokeModelSP stroke() const;
Thomas Zander's avatar
Thomas Zander committed
775 776

    /**
777 778
     * Set a new stroke, removing the old one.
     * @param stroke the new stroke, or 0 if there should be no stroke.
Thomas Zander's avatar
Thomas Zander committed
779
     */
780
    void setStroke(KoShapeStrokeModelSP stroke);
Thomas Zander's avatar
Thomas Zander committed
781

782
    /**
783 784
     * Return the insets of the stroke.
     * Convenience method for KoShapeStrokeModel::strokeInsets()
785
     */
786
    KoInsets strokeInsets() const;
787

788
    /// Sets the new shadow, removing the old one
789
    void setShadow(KoShapeShadow *shadow);
790

791
    /// Returns the currently set shadow or 0 if there is no shadow set
792
    KoShapeShadow *shadow() const;
793

794 795 796 797 798 799
    /// Sets the new border, removing the old one.
    void setBorder(KoBorder *border);

    /// Returns the currently set border or 0 if there is no border set
    KoBorder *border() const;

800
    /// Sets a new clip path, removing the old one
Jan Hambrecht's avatar
Jan Hambrecht committed
801
    void setClipPath(KoClipPath *clipPath);
802 803 804 805

    /// Returns the currently set clip path or 0 if there is no clip path set
    KoClipPath * clipPath() const;

806 807 808 809 810 811
    /// Sets a new clip mask, removing the old one. The mask is owned by the shape.
    void setClipMask(KoClipMask *clipMask);

    /// Returns the currently set clip mask or 0 if there is no clip mask set
    KoClipMask* clipMask() const;

Thomas Zander's avatar
Thomas Zander committed
812 813 814 815 816 817
    /**
     * Setting the shape to keep its aspect-ratio has the effect that user-scaling will
     * keep the width/hight ratio intact so as not to distort shapes that rely on that
     * ratio.
     * @param keepAspect the new value
     */
Thomas Zander's avatar
Thomas Zander committed
818
    void setKeepAspectRatio(bool keepAspect);
819

Thomas Zander's avatar
Thomas Zander committed
820 821 822 823 824 825
    /**
     * Setting the shape to keep its aspect-ratio has the effect that user-scaling will
     * keep the width/hight ratio intact so as not to distort shapes that rely on that
     * ratio.
     * @return whether to keep aspect ratio of this shape
     */
Thomas Zander's avatar
Thomas Zander committed
826
    bool keepAspectRatio() const;
Thomas Zander's avatar
Thomas Zander committed
827 828 829 830

    /**
     * Return the position of this shape regardless of rotation/skew/scaling and regardless of
     * this shape having a parent (being in a group) or not.<br>
831
     * @param anchor The place on the (unaltered) shape that you want the position of.
Thomas Zander's avatar
Thomas Zander committed
832 833
     * @return the point that is the absolute, centered position of this shape.
     */
834
    QPointF absolutePosition(KoFlake::AnchorPosition anchor = KoFlake::Center) const;
835

Thomas Zander's avatar
Thomas Zander committed
836 837 838 839 840 841 842 843 844 845 846 847
    /**
     * Move this shape to an absolute position where the end location will be the same
     * regardless of the shape's rotation/skew/scaling and regardless of this shape having
     * a parent (being in a group) or not.<br>
     * The newPosition is going to be the center of the shape.
     * This has the convenient effect that: <pre>
    shape-&gt;setAbsolutePosition(QPointF(0,0));
    shape-&gt;rotate(45);</pre>
        Will result in the same visual position of the shape as the opposite:<pre>
    shape-&gt;rotate(45);
    shape-&gt;setAbsolutePosition(QPointF(0,0));</pre>
     * @param newPosition the new absolute center of the shape.
Thomas Zander's avatar
Thomas Zander committed
848
     * @param anchor The place on the (unaltered) shape that you set the position of.
Thomas Zander's avatar
Thomas Zander committed
849
     */
850
    void setAbsolutePosition(const QPointF &newPosition, KoFlake::AnchorPosition anchor = KoFlake::Center);
851

852 853
    /**
     * Set a data object on the shape to be used by an application.
854
     * This is specifically useful when a shape is created in a plugin and that data from that
855 856 857 858 859 860 861 862 863 864
     * shape should be accessible outside the plugin.
     * @param userData the new user data, or 0 to delete the current one.
     */
    void setUserData(KoShapeUserData *userData);
    /**
     * Return the current userData.
     */
    KoShapeUserData *userData() const;

    /**
Marijn Kruisselbrink's avatar
Marijn Kruisselbrink committed
865
     * Return the Id of this shape, identifying the type of shape by the id of the factory.
866
     * @see KoShapeFactoryBase::shapeId()
867 868
     * @return the id of the shape-type
     */
869 870
    QString shapeId() const;

871 872 873
    /**
     * Set the Id of this shape.  A shapeFactory is expected to set the Id at creation
     * so applications can find out what kind of shape this is.
874
     * @see KoShapeFactoryBase::shapeId()
875 876
     * @param id the ID from the factory that created this shape
     */
Thomas Zander's avatar
Thomas Zander committed
877
    void setShapeId(const QString &id);
878

Thomas Zander's avatar
Thomas Zander committed
879 880
    /**
     * Create a matrix that describes all the transformations done on this shape.
881 882 883 884
     *
     * The absolute transformation is the combined transformation of this shape
     * and all its parents and grandparents.
     *
Thomas Zander's avatar
Thomas Zander committed
885 886 887
     * @param converter if not null, this method uses the converter to mark the right
     *        offsets in the current view.
     */
888
    QTransform absoluteTransformation(const KoViewConverter *converter) const;
Thomas Zander's avatar
Thomas Zander committed
889

890 891 892 893
    /**
     * Applies a transformation to this shape.
     *
     * The transformation given is relative to the global coordinate system, i.e. the document.
894 895
     * This is a convenience function to apply a global transformation to this shape.
     * @see applyTransformation
896 897 898
     *
     * @param matrix the transformation matrix to apply
     */
899
    void applyAbsoluteTransformation(const QTransform &matrix);
900 901 902 903 904

    /**
     * Sets a new transformation matrix describing the local transformations on this shape.
     * @param matrix the new transformation matrix
     */
905
    void setTransformation(const QTransform &matrix);
906

907
    /// Returns the shapes local transformation matrix
908
    QTransform transformation() const;
909 910 911 912 913 914 915 916

    /**
     * Applies a transformation to this shape.
     *
     * The transformation given is relative to the shape coordinate system.
     *
     * @param matrix the transformation matrix to apply
     */
917
    void applyTransformation(const QTransform &matrix);
918

Thomas Zander's avatar
Thomas Zander committed
919 920 921 922 923 924
    /**
     * Copy all the settings from the parameter shape and apply them to this shape.
     * Settings like the position and rotation to visible and locked.  The parent
     * is a notable exclusion.
     * @param shape the shape to use as original
     */
Thomas Zander's avatar
Thomas Zander committed
925
    void copySettings(const KoShape *shape);
Thomas Zander's avatar
Thomas Zander committed
926

Thomas Zander's avatar
Thomas Zander committed
927 928 929 930 931 932 933 934 935
    /**
     * Convenience method that allows people implementing paint() to use the shape
     * internal coordinate system directly to paint itself instead of considering the
     * views zoom.
     * @param painter the painter to alter the zoom level of.
     * @param converter the converter for the current views zoom.
     */
    static void applyConversion(QPainter &painter, const KoViewConverter &converter);

936 937 938 939 940 941 942
    /**
     * A convenience method that creates a handles helper with applying transformations at
     * the same time. Please note that you shouldn't save/restore additionally. All the work
     * on restoring original painter's transformations is done by the helper.
     */
    static KisHandlePainterHelper createHandlePainterHelper(QPainter *painter, KoShape *shape, const KoViewConverter &converter, qreal handleRadius = 0.0);

943 944 945 946 947
    /**
     * @brief Transforms point from shape coordinates to document coordinates
     * @param point in shape coordinates
     * @return point in document coordinates
     */
948
    QPointF shapeToDocument(const QPointF &point) const;
949 950 951 952 953 954

    /**
     * @brief Transforms rect from shape coordinates to document coordinates
     * @param rect in shape coordinates
     * @return rect in document coordinates
     */
955
    QRectF shapeToDocument(const QRectF &rect) const;
956 957 958 959 960 961

    /**
     * @brief Transforms point from document coordinates to shape coordinates
     * @param point in document coordinates
     * @return point in shape coordinates
     */
962
    QPointF documentToShape(const QPointF &point) const;
963 964 965 966 967 968

    /**
     * @brief Transform rect from document coordinates to shape coordinates
     * @param rect in document coordinates
     * @return rect in shape coordinates
     */
969
    QRectF documentToShape(const QRectF &rect) const;
970

971 972 973 974
    /**
     * Returns the name of the shape.
     * @return the shapes name
     */
975
    QString name() const;
976 977 978 979 980

    /**
     * Sets the name of the shape.
     * @param name the new shape name
     */
981
    void setName(const QString &name);
982

983 984 985 986 987
    /**
     * Update the position of the shape in the tree of the KoShapeManager.
     */
    void notifyChanged();

988
    /**
Thomas Zander's avatar
Thomas Zander committed
989
     * A shape can be in a state that it is doing processing data like loading or text layout.
990
     * In this case it can be shown on screen probably partially but it should really not be printed
Thomas Zander's avatar
Thomas Zander committed
991
     * until it is fully done processing.
992
     * Warning! This method can be blocking for a long time
Boudewijn Rempt's avatar
Boudewijn Rempt committed
993 994 995
     * @param asynchronous If set to true the processing will can take place in a different thread and the
     *                     function will not block until the shape is finised.
     *                     In case of printing Flake will call this method from a non-main thread and only
996
     *                     start printing it when the in case of printing method returned.
Boudewijn Rempt's avatar
Boudewijn Rempt committed
997
     *                     If set to false the processing needs to be done synchronously and will
998 999 1000
     *                     block until the result is finished.
     */
    virtual void waitUntilReady(const KoViewConverter &converter, bool asynchronous = true) const;
1001

1002 1003 1004
    /// checks recursively if the shape or one of its parents is not visible or locked
    bool isEditable() const;

1005 1006
    /**
     * Adds a shape which depends on this shape.
1007 1008
     * Making a shape dependent on this one means it will get shapeChanged() called
     * on each update of this shape.
1009 1010 1011 1012 1013
     *
     * If this shape already depends on the given shape, establishing the
     * dependency is refused to prevent circular dependencies.
     *
     * @param shape the shape which depends on this shape
1014 1015
     * @return true if dependency could be established, otherwise false
     * @see removeDependee(), hasDependee()
1016
     */
1017
    bool addDependee(KoShape *shape);
1018

1019 1020 1021 1022
    /**
     * Removes as shape depending on this shape.
     * @see addDependee(), hasDependee()
     */
1023
    void removeDependee(KoShape *shape);
1024

1025
    /// Returns if the given shape is dependent on this shape
1026
    bool hasDependee(KoShape *shape) const;
1027

1028 1029 1030
    /// Returns list of shapes depending on this shape
    QList<KoShape*> dependees() const;

1031 1032 1033
    /// Returns additional snap data the shape wants to have snapping to
    virtual KoSnapData snapData() const;

1034 1035 1036 1037 1038 1039 1040 1041 1042
    /**
     * Set additional attribute
     *
     * This can be used to attach additional attributes to a shape for attributes
     * that are application specific like presentation:placeholder
     *
     * @param name The name of the attribute in the following form prefix:tag e.g. presentation:placeholder
     * @param value The value of the attribute
     */
1043
    void setAdditionalAttribute(const QString &name, const QString &value);
1044 1045 1046 1047 1048 1049

    /**
     * Remove additional attribute
     *
     * @param name The name of the attribute in the following form prefix:tag e.g. presentation:placeholder
     */
1050
    void removeAdditionalAttribute(const QString &name);
1051 1052 1053 1054 1055 1056 1057 1058

    /**
     * Check if additional attribute is set
     *
     * @param name The name of the attribute in the following form prefix:tag e.g. presentation:placeholder
     *
     * @return true if there is a attribute with prefix:tag set, false otherwise
     */
1059
    bool hasAdditionalAttribute(const QString &name) const;
1060 1061 1062 1063 1064 1065 1066 1067

    /**
     * Get additional attribute
     *
     * @param name The name of the attribute in the following form prefix:tag e.g. presentation:placeholder
     *
     * @return The value of the attribute if it exists or a null string if not found.
     */
1068
    QString additionalAttribute(const QString &name) const;
1069

1070
    void setAdditionalStyleAttribute(const char *name, const QString &value);
1071

1072
    void removeAdditionalStyleAttribute(const char *name);
1073

1074
    /**
1075
     * Returns the filter effect stack of the shape
1076 1077 1078
     *
     * @return the list of filter effects applied on the shape when rendering.
     */
1079
    KoFilterEffectStack *filterEffectStack() const;
1080

1081
    /// Sets the new filter effect stack, removing the old one
1082
    void setFilterEffectStack(KoFilterEffectStack *filterEffectStack);
1083

1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097
    /**
     * Set the property collision detection.
     * Setting this to true will result in calls to shapeChanged() with the CollisionDetected
     * parameter whenever either this or another shape is moved/rotated etc and intersects this shape.
     * @param detect if true detect collisions.
     */
    void setCollisionDetection(bool detect);

    /**
     * get the property collision detection.
     * @returns true if collision detection is on.
     */
    bool collisionDetection();

1098 1099 1100 1101 1102 1103
    /**
     * Return the tool delegates for this shape.
     * In Flake a shape being selected will cause the tool manager to make available all tools that
     * can edit the selected shapes.  In some cases selecting one shape should allow the tool to
     * edit a related shape be available too.  The tool delegates allows this to happen by taking
     * all the shapes in the set into account on tool selection.
Thomas Zander's avatar
Thomas Zander committed
1104
     * Notice that if the set is non-empty 'this' shape is no longer looked at. You can choose
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
     * to add itself to the set too.
     */
    QSet<KoShape*> toolDelegates() const;

    /**
     * Set the tool delegates.
     * @param delegates the new delegates.
     * @see toolDelegates()
     */
    void setToolDelegates(const QSet<KoShape*> &delegates);

1116 1117 1118 1119 1120 1121 1122 1123 1124
    /**
     * Return the hyperlink for this shape.
     */
    QString hyperLink () const;

    /**
     * Set hyperlink for this shape.
     * @param hyperLink name.
     */
Friedrich W. H. Kossebau's avatar
Friedrich W. H. Kossebau committed
1125
    void setHyperLink(const QString &hyperLink);
1126

1127 1128
    /**
     * \internal
Marijn Kruisselbrink's avatar
Marijn Kruisselbrink committed
1129
     * Returns the private object for use within the flake lib
1130 1131 1132
     */
    KoShapePrivate *priv();

1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151
public:

    struct ShapeChangeListener {
        virtual ~ShapeChangeListener();
        virtual void notifyShapeChanged(ChangeType type, KoShape *shape) = 0;

    private:
        friend class KoShape;
        friend class KoShapePrivate;
        void registerShape(KoShape *shape);
        void unregisterShape(KoShape *shape);
        void notifyShapeChangedImpl(ChangeType type, KoShape *shape);

        QList<KoShape*> m_registeredShapes;
    };

    void addShapeChangeListener(ShapeChangeListener *listener);
    void removeShapeChangeListener(ShapeChangeListener *listener);

1152 1153 1154
public:
    static QList<KoShape*> linearizeSubtree(const QList<KoShape*> &shapes);

1155
protected:
1156
    /// constructor
1157
    KoShape(KoShapePrivate *);
Thomas Zander's avatar