vselectobjects.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 "vselectobjects.h"
#include "vlayer.h"
#include "vdocument.h"
#include "vsegment.h"
#include <kdebug.h>
 
void
VSelectObjects::visitVPath( VPath& composite )
{
    // Never select a deleted, locked or hidden object.
    if( composite.state() > VObject::normal &&
        composite.state() < VObject::selected )
        return;
 
    if( m_rectMode && m_rect.isEmpty() ) // in this mode everything is selected
    {
        visitVObject( composite );
        return;
    }
 
    bool selected = false;
 
    if( m_rectMode )
    {
        // Check if composite is completely inside the selection rectangle.
        // This test should be the first test since it's the less expensive one.
        if( m_rect.contains( composite.boundingBox() ) )
        {
            selected = true;
        }
    
        // Check if any of the rectangle corners is inside the composite.
        // This test should be done before the intersect test since it covers many
        // intersection cases.
        if( !selected )
        {
            if(
                composite.pointIsInside( m_rect.topLeft() ) ||
                composite.pointIsInside( m_rect.topRight() ) ||
                composite.pointIsInside( m_rect.bottomRight() ) ||
                composite.pointIsInside( m_rect.bottomLeft() ) )
            {
                selected = true;
            }
        }
    
        // Check if selection rectangle intersects the composite.
        if( !selected )
        {
            // Path for holding a helper segment.
            VSubpath path( 0L );
    
            path.moveTo( m_rect.topLeft() );
            path.lineTo( m_rect.topRight() );
    
            if( composite.intersects( *path.getLast() ) )
            {
                selected = true;
            }
            else
            {
                path.getFirst()->setKnot( m_rect.bottomRight() );
    
                if( composite.intersects( *path.getLast() ) )
                {
                    selected = true;
                }
                else
                {
                    path.getLast()->setKnot( m_rect.bottomLeft() );
    
                    if( composite.intersects( *path.getLast() ) )
                    {
                        selected = true;
                    }
                    else
                    {
                        path.getFirst()->setKnot( m_rect.topLeft() );
    
                        if( composite.intersects( *path.getLast() ) )
                        {
                            selected = true;
                        }
                    }
                }
            }
        }
    }
    else
    {
        if( composite.pointIsInside( m_point ) )
            selected = true;
    }
 
    if( selected )
    {
        if( m_select )
        {
            composite.setState( VObject::selected );
            if( ! m_selection.containsRef( &composite ) )
                m_selection.append( &composite );
        }
        else
        {
            composite.setState( VObject::normal );
            m_selection.remove( &composite );
        }
 
        setSuccess();
    }
}
 
void
VSelectObjects::visitVObject( VObject& object )
{
    // Never select a deleted, locked or hidden object.
    if( object.state() > VObject::normal &&
        object.state() < VObject::selected )
        return;
 
    // selection by selection rectangle
    if( m_rectMode )
    {
        if( !m_rect.isEmpty() )
        {
            if( m_select )
            {
                if( m_rect.intersects( object.boundingBox() ) )
                {
                    object.setState( VObject::selected );
                    if( ! m_selection.containsRef( &object ) )
                        m_selection.append( &object );
                    setSuccess();
                }
            }
            else
            {
                if( m_rect.intersects( object.boundingBox() ) )
                {
                    object.setState( VObject::normal );
                    m_selection.remove( &object );
                    setSuccess();
                }
            }
        }
        else
        {
            if( m_select )
            {
                object.setState( VObject::selected );
                if( ! m_selection.containsRef( &object ) )
                    m_selection.append( &object );
                setSuccess();
            }
            else
            {
                object.setState( VObject::normal );
                m_selection.remove( &object );
                setSuccess();
            }
        }
    }
    // selection by point
    else
    {
        if( object.boundingBox().contains( m_point ) )
        {
            if( m_select )
            {
                object.setState( VObject::selected );
                if( ! m_selection.containsRef( &object ) )
                    m_selection.append( &object );
            }
            else
            {
                object.setState( VObject::normal );
                m_selection.remove( &object );
            }
            setSuccess();
        }
    }
 
}
 
void
VSelectObjects::visitVLayer( VLayer& layer )
{
    VDocument* doc = (VDocument*)layer.parent();
    if ( ( layer.state() != VObject::deleted ) &&
         ( ( doc->selectionMode() == VDocument::AllLayers ) ||
           ( doc->selectionMode() == VDocument::VisibleLayers && ( layer.state() == VObject::normal || layer.state() == VObject::normal_locked ) ) ||
           ( doc->selectionMode() == VDocument::SelectedLayers && layer.selected() ) ||
           ( doc->selectionMode() == VDocument::ActiveLayer && doc->activeLayer() == &layer ) ) )
    {
        VObjectListIterator itr( layer.objects() );
        for( ; itr.current(); ++itr )
            itr.current()->accept( *this );
    }
}
 
void 
VSelectObjects::visitVText( VText& text )
{
    // Never select a deleted, locked or hidden object.
    if( text.state() > VObject::normal &&
        text.state() < VObject::selected )
        return;
 
    int deselectedGlyphs = 0;
 
    VPathListIterator itr( text.glyphs() );
    for( ; itr.current(); ++itr )
    {
        VPath c( 0L );
        c.combine( *itr.current() );
        visitVPath( c );
        if( m_select && c.state() == VObject::selected )
        {
            kdDebug(38000) << "selected: " << itr.current() << endl;
            m_selection.remove( &c );
            text.setState( VObject::selected );
            if( ! m_selection.containsRef( &text ) )
                m_selection.append( &text );
            return;
        }
        else if( c.state() == VObject::normal )
        {
            kdDebug(38000) << "deselected: " << itr.current() << endl;
            deselectedGlyphs++;
        }
    }
    if( deselectedGlyphs >= 0 && uint( deselectedGlyphs ) == text.glyphs().count() )
    {
        text.setState( VObject::normal );
        m_selection.remove( &text );
    }
}
 
void 
VSelectObjects::visitVGroup( VGroup& group )
{ 
    // Never select a deleted, locked or hidden object.
    if( group.state() > VObject::normal &&
        group.state() < VObject::selected )
        return;
 
    if( ! m_insideGroups )
        visitVObject( group );
    else
    {
        VVisitor::visitVGroup( group );
    }
}