root/gui/flowcanvas/Connection.cpp @ 67cc9c9e05d47e6074167fc05c12ec87e8c0058e

/* This file is part of FlowCanvas.
 * Copyright (C) 2007-2009 David Robillard <http://drobilla.net>
 *
 * FlowCanvas is free software; you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option) any later
 * version.
 *
 * FlowCanvas 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 General Public License for details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
 */

#include <algorithm>
#include <cassert>
#include <cmath>
#include <string>

#include <libgnomecanvasmm.h>

#include "Canvas.hpp"
#include "Connectable.hpp"
#include "Connection.hpp"
#include "Ellipse.hpp"

namespace FlowCanvas {


Connection::Connection(boost::shared_ptr<Canvas>      canvas,
                           boost::shared_ptr<Connectable> source,
                           boost::shared_ptr<Connectable> dest,
                       uint32_t                       color,
                       bool                           show_arrowhead)
        : Gnome::Canvas::Group(*canvas->root())
        , _canvas(canvas)
        , _source(source)
        , _dest(dest)
        , _bpath(*this)
        , _path(gnome_canvas_path_def_new())
        , _handle(NULL)
        , _color(color)
        , _handle_style(HANDLE_NONE)
        , _selected(false)
        , _show_arrowhead(show_arrowhead)
{
        _bpath.property_width_units() = 2.0;
        set_color(color);

        update_location();
        raise_to_top();
}


Connection::~Connection()
{
        gnome_canvas_path_def_unref(_path);
}


void
Connection::set_color(uint32_t color)
{
        _color = color;
        _bpath.property_outline_color_rgba() = _color;
        if (_handle) {
                if (_handle->text) {
                        _handle->text->property_fill_color_rgba() = _color;
                }
                if (_handle->shape) {
                        _handle->shape->property_fill_color_rgba() = 0x000000FF;
                        _handle->shape->property_outline_color_rgba() = _color;
                }
        }
}


/** Updates the path of the connection to match it's ports if they've moved.
 */
void
Connection::update_location()
{
        boost::shared_ptr<Connectable> src = _source.lock();
        boost::shared_ptr<Connectable> dst = _dest.lock();

        if (!src || !dst)
                return;

        bool straight = (boost::dynamic_pointer_cast<Ellipse>(src)
                      || boost::dynamic_pointer_cast<Ellipse>(dst));

        const Gnome::Art::Point src_point = src->src_connection_point();
        const Gnome::Art::Point dst_point = dst->dst_connection_point(src_point);

        const double src_x = src_point.get_x();
        const double src_y = src_point.get_y();
        const double dst_x = dst_point.get_x();
        const double dst_y = dst_point.get_y();

        if (straight) {

                gnome_canvas_path_def_reset(_path);
                gnome_canvas_path_def_moveto(_path, src_x, src_y);
                gnome_canvas_path_def_lineto(_path, dst_x, dst_y);
                double dx = src_x - dst_x;
                double dy = src_y - dst_y;

                if (_handle) {
                        _handle->property_x() = src_x - dx/2.0;
                        _handle->property_y() = src_y - dy/2.0;
                        _handle->move(0, 0);
                }

                if (_show_arrowhead) {

                        const double h  = sqrt(dx*dx + dy*dy);

                        dx = dx / h * 10;
                        dy = dy / h * 10;

                        gnome_canvas_path_def_lineto(_path,
                                        dst_x + dx - dy/1.5,
                                        dst_y + dy + dx/1.5);

                        gnome_canvas_path_def_moveto(_path, dst_x, dst_y);

                        gnome_canvas_path_def_lineto(_path,
                                        dst_x + dx + dy/1.5,
                                        dst_y + dy - dx/1.5);
                }

        } else {

                const double join_x = (src_x + dst_x)/2.0;
                const double join_y = (src_y + dst_y)/2.0;

                double dx = fabs(dst_x - src_x);
                double dy = fabs(dst_y - src_y);

                Gnome::Art::Point src_vec = src->connection_point_vector(dx/3.0, dy/3.0);
                Gnome::Art::Point dst_vec = dst->connection_point_vector(dx/3.0, dy/3.0);

                double src_point_dx = src_vec.get_x();
                double src_point_dy = src_vec.get_y();
                double dst_point_dx = dst_vec.get_x();
                double dst_point_dy = dst_vec.get_y();

                // Path 1 (src_x, src_y) -> (join_x, join_y)
                // Control point 1
                const double src_x1 = src_x + src_point_dx;
                const double src_y1 = src_y + src_point_dy;
                // Control point 2
                const double src_x2 = (join_x + src_x1) / 2.0;
                const double src_y2 = (join_y + src_y1) / 2.0;

                // Path 2, (join_x, join_y) -> (dst_x, dst_y)
                // Control point 1
                const double dst_x1 = dst_x - dst_point_dx;
                const double dst_y1 = dst_y - dst_point_dy;
                // Control point 2
                const double dst_x2 = (join_x + dst_x1) / 2.0;
                const double dst_y2 = (join_y + dst_y1) / 2.0;

                // libgnomecanvasmm + GTK 2.8 screwed up the Path API; use the C one.
                gnome_canvas_path_def_reset(_path);
                gnome_canvas_path_def_moveto(_path, src_x, src_y);
                gnome_canvas_path_def_curveto(_path, src_x1, src_y1, src_x2, src_y2, join_x, join_y);
                gnome_canvas_path_def_curveto(_path, dst_x2, dst_y2, dst_x1, dst_y1, dst_x, dst_y);

                // Uncomment to see control point path as straight lines
                /*gnome_canvas_path_def_reset(_path);
                gnome_canvas_path_def_moveto(_path, src_x, src_y);
                gnome_canvas_path_def_lineto(_path, src_x1, src_y1);
                gnome_canvas_path_def_lineto(_path, src_x2, src_y2);
                gnome_canvas_path_def_lineto(_path, join_x, join_y);
                gnome_canvas_path_def_lineto(_path, dst_x2, dst_y2);
                gnome_canvas_path_def_lineto(_path, dst_x1, dst_y1);
                gnome_canvas_path_def_lineto(_path, dst_x, dst_y);*/

                if (_show_arrowhead) {

                        const double h  = sqrt(dx*dx + dy*dy);

                        dx = dx / h * 10;
                        dy = dy / h * 10;

                        gnome_canvas_path_def_lineto(_path,
                                        dst_x - 12,
                                        dst_y - 4);

                        gnome_canvas_path_def_moveto(_path, dst_x, dst_y);

                        gnome_canvas_path_def_lineto(_path,
                                        dst_x - 12,
                                        dst_y + 4);
                }
        }

        GnomeCanvasBpath* c_obj = _bpath.gobj();
        gnome_canvas_item_set(GNOME_CANVAS_ITEM(c_obj), "bpath", _path, NULL);
}


/** Set label text displayed next to the edge.
 *
 * Passing the empty string will remove the label.
 */
void
Connection::set_label(const std::string& str)
{
        if (str != "") {
                if (!_handle)
                        _handle = new Handle(*this);

                if (!_handle->text) {
                        _handle->text = new Gnome::Canvas::Text(*_handle, 0, 0, str);
                        _handle->text->property_size_set() = true;
                        _handle->text->property_size() = 9000;
                        _handle->text->property_weight_set() = true;
                        _handle->text->property_weight() = 200;
                        _handle->text->property_fill_color_rgba() = _color;
                        _handle->text->show();
                } else {
                        _handle->text->property_text() = str;
                }

                if (_handle->shape)
                        show_handle(true);

                _handle->text->raise(1);
                update_location();
        } else if (_handle) {
                delete _handle->text;
                _handle->text = NULL;
        }
}


void
Connection::show_handle(bool show)
{
        if (show) {
                if (!_handle)
                        _handle = new Handle(*this);

                double handle_width = 8.0;
                double handle_height = 8.0;
                if (_handle->text) {
                        handle_width = _handle->text->property_text_width();
                        handle_height = _handle->text->property_text_height();
                }

                // FIXME: slow
                delete _handle->shape;

                if (_handle_style != HANDLE_NONE) {
                        if (_handle_style == HANDLE_RECT)
                                _handle->shape = new Gnome::Canvas::Rect(*_handle,
                                                -handle_width/2.0 - 1.0, -handle_height/2.0,
                                                handle_width/2.0 + 1.0, handle_height/2.0);
                        else// if (_handle_style == HANDLE_CIRCLE)
                                _handle->shape = new Gnome::Canvas::Ellipse(*_handle,
                                                -handle_width/2.0 - 1.0, -handle_height/2.0,
                                                handle_width/2.0 + 1.0, handle_height/2.0);
                }

                _handle->shape->property_fill_color_rgba() = 0x000000FF;
                _handle->shape->property_outline_color_rgba() = _color;
                _handle->shape->show();
                _handle->show();

        } else {
                delete _handle;
                _handle = NULL;
        }
}


void
Connection::set_highlighted(bool b)
{
        if (b)
                _bpath.property_outline_color_rgba() = 0xFF0000FF;
        else
                _bpath.property_outline_color_rgba() = _color;
}


void
Connection::set_selected(bool selected)
{
        _selected = selected;

        if (selected) {
                _bpath.property_dash() = _canvas.lock()->select_dash();
        } else {
                _bpath.property_dash() = NULL;
        }
}


/** Overloaded Gnome::Canvas::Item::raise_to_top to ensure src and dst
 * are still above connections (to hide the part behind connected Ellipses).
 */
void
Connection::raise_to_top()
{
        Gnome::Canvas::Item::raise_to_top();

        // Raise source above us
        boost::shared_ptr<Item> item = boost::dynamic_pointer_cast<Item>(_source.lock());
        if (item)
                item->raise_to_top();

        // Raise dest above us
        item = boost::dynamic_pointer_cast<Item>(_dest.lock());
        if (item)
                item->raise_to_top();

        /* Raise the roof
               \o/
                |
               / \
        */
}


void
Connection::select_tick()
{
        _bpath.property_dash() = _canvas.lock()->select_dash();
}


void
Connection::zoom(double z)
{
        if (_handle && _handle->text) {
                _handle->text->property_size() = static_cast<int>(floor((double)9000.0f * z));
        }
}


} // namespace FlowCanvas