vsegment.h

/* This file is part of the KDE project
   Copyright (C) 2001, 2002, 2003 The Karbon Developers
 
   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.
*/
 
#ifndef __VSEGMENT_H__
#define __VSEGMENT_H__
 
#include <tqptrlist.h>
#include <tqvaluelist.h>
 
#include <KoPoint.h>
#include <KoRect.h>
 
#include "vglobal.h"
#include <koffice_export.h>
 
class TQDomElement;
class VPainter;
 
class KARBONBASE_EXPORT VSegment
{
    friend class VSubpath;
    friend class VSubpathIterator;
 
public:
    enum VCtrlPointFixing
    {
        none = 0,
        first = 1,
        second = 2
    };
 
    enum VState
    {
        normal,
        deleted
    };
 
 
    VSegment( unsigned short deg = 3 );
 
    VSegment( const VSegment& segment );
 
    ~VSegment();
 
    unsigned short degree() const
    {
        return m_degree;
    }
 
    void setDegree( unsigned short deg );
 
    bool isBegin() const { return (degree() == 1) && !prev(); }
    bool isLine() const { return (degree() == 1) && prev(); }
    bool isCurve() const { return degree() > 1; }
 
    VState state() const
    {
        return m_state;
    }
 
    void setState( VState state )
    {
        m_state = state;
    }
 
 
    const KoPoint& point( int i ) const
    {
        return m_nodes[ i ].m_vector;
    }
 
    const KoPoint& p( int i ) const
    {
        return i == 0
               ? prev()->knot()
               : m_nodes[ --i ].m_vector;
    }
 
    const KoPoint& knot() const
    {
        return point( degree() - 1 );
    }
 
    void setPoint( int i, const KoPoint& p )
    {
        m_nodes[ i ].m_vector = p;
    }
 
    void setP( int i, const KoPoint& p )
    {
        if( i == 0 )
            prev()->setKnot( p );
        else
            m_nodes[ --i ].m_vector = p;
    }
 
    void setKnot( const KoPoint& p )
    {
        m_nodes[ degree() - 1 ].m_vector = p;
    }
 
 
    bool pointIsSelected( int i ) const
    {
        return m_nodes[ i ].m_isSelected;
    }
 
    bool knotIsSelected() const
    {
        return m_nodes[ degree() - 1 ].m_isSelected;
    }
 
    void selectPoint( int i, bool select = true )
    {
        m_nodes[ i ].m_isSelected = select;
    }
 
    void selectKnot( bool select = true )
    {
        m_nodes[ degree() - 1 ].m_isSelected = select;
    }
 
 
    // TODO: Move this function into "userland"
    uint nodeNear( const KoPoint& p,
                   double isNearRange = VGlobal::isNearRange ) const;
 
 
    VSegment* prev() const;
 
    VSegment* next() const;
 
    bool isFlat( double flatness = VGlobal::flatnessTolerance ) const;
 
 
    KoPoint pointAt( double t ) const;
 
    void pointDerivativesAt( double t, KoPoint* p = 0L,
                             KoPoint* d1 = 0L, KoPoint* d2 = 0L ) const;
 
 
    KoPoint tangentAt( double t ) const;
 
    void pointTangentNormalAt( double t, KoPoint* p = 0L,
                               KoPoint* tn = 0L, KoPoint* n = 0L ) const;
 
 
    double length( double t = 1.0 ) const;
 
    double chordLength() const;
 
    double polyLength() const;
 
 
    double lengthParam( double len ) const;
 
 
    double nearestPointParam( const KoPoint& p ) const;
 
 
    bool isSmooth( const VSegment& next ) const;
 
    bool isSmooth() const
    {
        return next()
               ? isSmooth( *next() )
               : false;
    }
 
 
    VSegment* revert() const;
 
 
    VSegment* splitAt( double t );
 
 
    static double height(
        const KoPoint& a,
        const KoPoint& p,
        const KoPoint& b );
 
 
    static bool linesIntersect(
        const KoPoint& a0,
        const KoPoint& a1,
        const KoPoint& b0,
        const KoPoint& b1 );
 
    bool intersects( const VSegment& segment ) const;
 
 
    double pointIsLeft( const KoPoint& p ) const
    {
        return
            ( knot().x() - prev()->knot().x() ) *
            ( p.y() - prev()->knot().y() )
            -
            ( p.x() - prev()->knot().x() ) *
            ( knot().y() - prev()->knot().y() );
    }
 
    KoRect boundingBox() const;
 
 
    void draw( VPainter* painter ) const;
 
    // TODO: remove this backward compatibility function after koffice 1.3.x.
    void load( const TQDomElement& element );
 
 
    VSegment* clone() const;
 
private:
    void rootParams( TQValueList<double>& params ) const;
 
    int controlPolygonZeros() const;
 
 
    unsigned short m_degree : 6;
 
    VState m_state : 2;
 
    struct VNodeData
    {
        KoPoint m_vector;
        bool m_isSelected;
    };
 
    VNodeData* m_nodes;
 
 
    VSegment* m_prev;
 
    VSegment* m_next;
};
 
#endif