vdrawselection.cpp

/* This file is part of the KDE project
   Copyright (C) 2002, 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.
*/
 
 
#include "vdrawselection.h"
#include "vcomposite.h"
#include "vsegment.h"
#include "vcolor.h"
#include "vstroke.h"
#include "vpainter.h"
#include "vpath.h"
 
void
VDrawSelection::visitVPath( VPath &composite )
{
    if(
        composite.state() == VObject::deleted ||
        composite.state() == VObject::hidden ||
        composite.state() == VObject::hidden_locked )
    {
        return;
    }
 
 
    m_painter->save();
    m_painter->setPen( TQt::SolidLine );
 
    const bool editnodes = composite.state() == VObject::edit && m_nodeediting;
 
    VSubpathListIterator itr( composite.paths() );
 
    if(
        composite.state() == VObject::selected ||
        editnodes )
    {
        // paint fill:
        m_painter->newPath();
 
        if( editnodes )
            m_painter->setRasterOp( TQt::XorROP );
 
        m_painter->setPen( editnodes ? TQt::yellow : TQt::blue );
        m_painter->setBrush( TQt::NoBrush );
 
        for( itr.toFirst(); itr.current(); ++itr )
        {
            VSubpathIterator jtr( *( itr.current() ) );
 
            for( ; jtr.current(); ++jtr )
            {
                jtr.current()->draw( m_painter );
            }
 
            m_painter->strokePath();
        }
    }
 
    // Draw nodes and control lines.
    if(
        composite.state() == VObject::selected ||
        editnodes )
    {
        itr.toFirst();
        //++itr;        // Skip "begin".
 
        for( ; itr.current(); ++itr )
        {
            if( (*itr)->isEmpty() )
                continue;
            VSubpathIterator jtr( *( itr.current() ) );
            //++jtr;
 
            for( ; jtr.current(); ++jtr )
            {
                if( editnodes )
                    m_painter->setRasterOp( TQt::XorROP );
 
                VColor color;
                color.set( 0.5, 0.5, 1.0 );
 
                VStroke stroke( color );
                stroke.setLineWidth( 1.0 );
 
                if( !editnodes )
                {
                    m_painter->setPen( stroke );
                    m_painter->setPen( TQt::blue );
                }
                else
                    m_painter->setPen( TQt::yellow );
 
                m_painter->setBrush( TQt::NoBrush );
 
                if( ( editnodes || composite.state() == VObject::selected && m_nodeediting ) &&
                        jtr.current()->isCurve() )
                {
                    VSegment* curr = jtr.current();
                    VSegment* next = curr->next();
                    VSegment* prev = curr->prev();
 
                    // Draw control lines.
                    if ( curr->pointIsSelected( curr->degree()-2 ) || curr->knotIsSelected() 
                    || ( next && next->isCurve() && next->pointIsSelected( 0 ) && curr->isSmooth() ) )
                    {
                        m_painter->newPath();
                        m_painter->moveTo( curr->point( curr->degree()-2 ) );
                        m_painter->lineTo( curr->knot() );
                        m_painter->strokePath();
                        // Draw control node2:
                        m_painter->newPath();
                        m_painter->setBrush( editnodes ? TQt::yellow : TQt::blue );
                        m_painter->drawNode( curr->point( curr->degree()-2 ), m_nodeSize );
                        m_painter->strokePath();
                    }
 
                    if ( prev && ( ( prev->knotIsSelected() || curr->pointIsSelected( 0 ) ) 
                    || ( prev->isCurve() && prev->pointIsSelected( prev->degree()-2 ) && prev->isSmooth() ) ) )
                    {
                        m_painter->newPath();
                        m_painter->moveTo( prev->knot() );
                        m_painter->lineTo( curr->point( 0 ) );
                        m_painter->strokePath();
                        // Draw control node1:
                        m_painter->newPath();
                        m_painter->setBrush( editnodes ? TQt::yellow : TQt::blue );
                        m_painter->drawNode( curr->point( 0 ), m_nodeSize );
                        m_painter->strokePath();
                    }
                }
 
                // Draw knot.
                m_painter->setPen( editnodes ? TQt::yellow : TQt::blue );
 
                if( !m_nodeediting )
                    m_painter->setBrush( TQt::blue );
                else if( jtr.current()->knotIsSelected() )
                    m_painter->setBrush( editnodes ? TQt::yellow : TQt::blue );
                else
                    m_painter->setBrush( TQt::white );
 
                m_painter->drawNode( jtr.current()->knot(), m_nodeSize );
            }
        }
    }
 
    // Draw center node.
    if( composite.drawCenterNode() && composite.state() == VObject::selected && !m_nodeediting )
    {
        m_painter->setPen( TQt::NoPen );
        m_painter->setBrush( TQt::blue.light() );
        m_painter->drawNode( composite.boundingBox().center(), m_nodeSize );
    }
 
    m_painter->restore();
 
    setSuccess();
}