_row_labels->clear_channel_highlights ();
_column_labels->clear_channel_highlights ();
+ } else if (Gdk::Region (_grid->parent_rectangle()).point_in (ev->x, ev->y)) {
+
+ _grid->button_release (
+ _grid->parent_to_component_x (ev->x),
+ _grid->parent_to_component_y (ev->y),
+ ev->button, ev->time
+ );
+
}
return true;
PortMatrixBody::on_motion_notify_event (GdkEventMotion* ev)
{
if (Gdk::Region (_grid->parent_rectangle()).point_in (ev->x, ev->y)) {
- _grid->mouseover_event (
+
+ _grid->motion (
_grid->parent_to_component_x (ev->x),
_grid->parent_to_component_y (ev->y)
);
+
_mouse_over_grid = true;
+
} else {
if (_mouse_over_grid) {
set_mouseover (PortMatrixNode ());
_column_labels->mouseover_changed (old);
}
-
-
void
PortMatrixBody::highlight_associated_channels (int dim, ARDOUR::BundleChannel h)
{
}
if (_matrix->show_only_bundles()) {
- _width += column_width();
+ _width += grid_spacing();
} else {
- _width += i->bundle->nchannels() * column_width();
+ _width += i->bundle->nchannels() * grid_spacing();
}
}
_highest_group_name = ext.height;
}
} else {
- _width += column_width ();
+ _width += grid_spacing ();
}
}
double
PortMatrixColumnLabels::basic_text_x_pos (int c) const
{
- return column_width() / 2 +
+ return grid_spacing() / 2 +
_highest_text / (2 * sin (angle ()));
}
/* compute width of this group */
uint32_t w = 0;
if (!(*i)->visible() || (*i)->bundles().empty()) {
- w = column_width ();
+ w = grid_spacing ();
} else {
if (_matrix->show_only_bundles()) {
- w = (*i)->bundles().size() * column_width();
+ w = (*i)->bundles().size() * grid_spacing();
} else {
- w = (*i)->total_channels() * column_width();
+ w = (*i)->total_channels() * grid_spacing();
}
}
render_bundle_name (cr, c, x, 0, j->bundle);
if (_matrix->show_only_bundles()) {
- x += column_width();
+ x += grid_spacing();
} else {
- x += j->bundle->nchannels () * column_width();
+ x += j->bundle->nchannels () * grid_spacing();
}
++N;
} else {
- x += column_width ();
+ x += grid_spacing ();
}
}
for (uint32_t k = 0; k < j->bundle->nchannels(); ++k) {
Gdk::Color c = j->has_colour ? j->colour : get_a_bundle_colour (N);
render_channel_name (cr, c, x, 0, ARDOUR::BundleChannel (j->bundle, k));
- x += column_width();
+ x += grid_spacing();
}
++N;
} else {
- x += column_width ();
+ x += grid_spacing ();
}
}
vector<pair<double, double> > shape;
double const lc = _longest_channel_name + name_pad();
- double const w = column_width();
+ double const w = grid_spacing();
if (_matrix->arrangement() == PortMatrix::LEFT_TO_BOTTOM) {
x_ += lc * cos (angle());
y_ -= lc * sin (angle());
shape.push_back (make_pair (x_, y_));
- x_ -= column_width() * pow (sin (angle()), 2);
- y_ -= column_width() * sin (angle()) * cos (angle());
+ x_ -= grid_spacing() * pow (sin (angle()), 2);
+ y_ -= grid_spacing() * sin (angle()) * cos (angle());
shape.push_back (make_pair (x_, y_));
}
double w = 0;
if (_matrix->show_only_bundles()) {
- w = column_width ();
+ w = grid_spacing ();
} else {
- w = b->nchannels() * column_width();
+ w = b->nchannels() * grid_spacing();
}
double x_ = xoff;
double
PortMatrixColumnLabels::channel_x (ARDOUR::BundleChannel const &bc) const
{
- uint32_t n = 0;
-
- PortGroup::BundleList const & b = _matrix->columns()->bundles ();
- PortGroup::BundleList::const_iterator i = b.begin();
- while (i != b.end() && i->bundle != bc.bundle) {
- if (_matrix->show_only_bundles()) {
- n += 1;
- } else {
- n += i->bundle->nchannels ();
- }
- ++i;
- }
-
- if (!_matrix->show_only_bundles()) {
- n += bc.channel;
- }
-
- return n * column_width();
+ return channel_to_position (bc, _matrix->columns()) * grid_spacing ();
}
double
_body->queue_draw_area (
component_to_parent_x (channel_x (bc)),
component_to_parent_y (0),
- column_width() + _height * tan (angle()),
+ grid_spacing() + _height * tan (angle()),
_height
);
double const x = channel_x (bc);
double const lc = _longest_channel_name + name_pad();
- double const h = lc * sin (angle ()) + column_width() * sin (angle()) * cos (angle());
+ double const h = lc * sin (angle ()) + grid_spacing() * sin (angle()) * cos (angle());
if (_matrix->arrangement() == PortMatrix::TOP_TO_RIGHT) {
_body->queue_draw_area (
component_to_parent_x (x),
component_to_parent_y (_height - h),
- column_width() + lc * cos (angle()),
+ grid_spacing() + lc * cos (angle()),
h
);
_body->queue_draw_area (
component_to_parent_x (x_),
component_to_parent_y (0),
- column_width() + lc * cos (angle()),
+ grid_spacing() + lc * cos (angle()),
h
);
}
}
-pair<boost::shared_ptr<PortGroup>, ARDOUR::BundleChannel>
-PortMatrixColumnLabels::x_position_to_group_and_channel (double x, double y) const
+void
+PortMatrixColumnLabels::button_press (double x, double y, int b, uint32_t t)
{
uint32_t cx = 0;
uint32_t const gh = _highest_group_name + 2 * name_pad();
}
}
- uint32_t px = 0;
-
- pair<boost::shared_ptr<PortGroup>, ARDOUR::BundleChannel> gc;
-
- for (PortGroupList::List::const_iterator i = _matrix->columns()->begin(); i != _matrix->columns()->end(); ++i) {
-
- if (!(*i)->visible()) {
-
- uint32_t const gw = group_width (*i);
-
- if (px <= cx && cx < (px + gw)) {
- return make_pair (*i, ARDOUR::BundleChannel ());
- } else {
- px += gw;
- }
-
- } else {
-
- PortGroup::BundleList bundles = (*i)->bundles ();
- for (PortGroup::BundleList::iterator j = bundles.begin(); j != bundles.end(); ++j) {
-
- if (_matrix->show_only_bundles()) {
-
- if (px <= cx && cx < (px + column_width())) {
- return make_pair (*i, ARDOUR::BundleChannel (j->bundle, 0));
- } else {
- px += column_width ();
- }
-
- } else {
-
- for (uint32_t k = 0; k < j->bundle->nchannels(); ++k) {
-
- if (px <= cx && cx < (px + column_width())) {
- if (group_name) {
- return make_pair (*i, ARDOUR::BundleChannel ());
- } else {
- return make_pair (*i, ARDOUR::BundleChannel (j->bundle, k));
- }
- }
-
- px += column_width ();
- }
- }
-
- }
- }
-
- }
-
- return make_pair (boost::shared_ptr<PortGroup> (), ARDOUR::BundleChannel ());
-}
-
-void
-PortMatrixColumnLabels::button_press (double x, double y, int b, uint32_t t)
-{
- pair<boost::shared_ptr<PortGroup>, ARDOUR::BundleChannel> gc = x_position_to_group_and_channel (x, y);
+ pair<boost::shared_ptr<PortGroup>, ARDOUR::BundleChannel> gc = position_to_group_and_channel (cx / grid_spacing(), _matrix->columns());
if (b == 1) {
- if (gc.second.bundle) {
- _body->highlight_associated_channels (_matrix->column_index(), gc.second);
- } else if (gc.first) {
+ if (group_name && gc.first) {
gc.first->set_visible (!gc.first->visible ());
+ } else if (gc.second.bundle) {
+ _body->highlight_associated_channels (_matrix->column_index(), gc.second);
}
} else if (b == 3) {
return _height - _highest_group_name - 2 * name_pad();
}
- std::pair<boost::shared_ptr<PortGroup>, ARDOUR::BundleChannel> x_position_to_group_and_channel (double, double) const;
-
double _longest_bundle_name;
double _longest_channel_name;
double _highest_text;
return _matrix->get_style()->get_bg (Gtk::STATE_NORMAL);
}
+/** @param g Group.
+ * @return Visible size of the group in grid units, taking visibility and show_only_bundles into account.
+ */
uint32_t
-PortMatrixComponent::group_width (boost::shared_ptr<const PortGroup> g) const
+PortMatrixComponent::group_size (boost::shared_ptr<const PortGroup> g) const
{
- uint32_t width = 0;
+ uint32_t s = 0;
if (g->visible()) {
PortGroup::BundleList const & bundles = g->bundles ();
if (_matrix->show_only_bundles()) {
- width = bundles.size() * column_width ();
+ s = bundles.size();
} else {
for (PortGroup::BundleList::const_iterator i = bundles.begin(); i != bundles.end(); ++i) {
- width += i->bundle->nchannels() * column_width ();
+ s += i->bundle->nchannels();
}
}
} else {
- width = column_width ();
+ s = 1;
}
- return width;
+ return s;
}
+/** @param bc Channel.
+ * @param groups List of groups.
+ * @return Position of bc in groups in grid units, taking visibility and show_only_bundles into account.
+ */
uint32_t
-PortMatrixComponent::group_height (boost::shared_ptr<const PortGroup> g) const
+PortMatrixComponent::channel_to_position (ARDOUR::BundleChannel bc, PortGroupList const * groups) const
{
- uint32_t height = 0;
+ uint32_t p = 0;
+
+ for (PortGroupList::List::const_iterator i = groups->begin(); i != groups->end(); ++i) {
+
+ PortGroup::BundleList const & bundles = (*i)->bundles ();
+
+ for (PortGroup::BundleList::const_iterator j = bundles.begin(); j != bundles.end(); ++j) {
+
+ if (j->bundle == bc.bundle) {
+
+ /* found the bundle */
+
+ if (_matrix->show_only_bundles() || !(*i)->visible()) {
+ return p;
+ } else {
+ return p + bc.channel;
+ }
- if (g->visible ()) {
- PortGroup::BundleList const & bundles = g->bundles ();
- if (_matrix->show_only_bundles()) {
- height = bundles.size() * row_height ();
- } else {
- for (PortGroup::BundleList::const_iterator i = bundles.begin(); i != bundles.end(); ++i) {
- height += i->bundle->nchannels() * row_height ();
+ }
+
+ if ((*i)->visible()) {
+
+ /* move past this bundle */
+
+ if (_matrix->show_only_bundles()) {
+ p += 1;
+ } else {
+ p += j->bundle->nchannels ();
+ }
}
}
- } else {
- height = row_height ();
+
+ if (!(*i)->visible()) {
+ /* if this group isn't visible we won't have updated p, so do it now */
+ p += 1;
+ }
}
- return height;
+ return 0;
}
pair<boost::shared_ptr<PortGroup>, ARDOUR::BundleChannel>
-PortMatrixComponent::y_position_to_group_and_channel (double y) const
+PortMatrixComponent::position_to_group_and_channel (uint32_t p, PortGroupList const * groups) const
{
- PortGroupList::List::const_iterator i = _matrix->rows()->begin();
+ PortGroupList::List::const_iterator i = groups->begin ();
- while (i != _matrix->rows()->end()) {
+ while (i != groups->end()) {
- uint32_t const gh = group_height (*i);
+ uint32_t const gs = group_size (*i);
- if (y < gh) {
+ if (p < gs) {
/* it's in this group */
+ if (!(*i)->visible()) {
+ return make_pair (*i, ARDOUR::BundleChannel (boost::shared_ptr<ARDOUR::Bundle> (), 0));
+ }
+
PortGroup::BundleList const & bundles = (*i)->bundles ();
for (PortGroup::BundleList::const_iterator j = bundles.begin(); j != bundles.end(); ++j) {
if (_matrix->show_only_bundles()) {
- if (y < row_height()) {
+ if (p == 0) {
return make_pair (*i, ARDOUR::BundleChannel (j->bundle, 0));
} else {
- y -= row_height ();
+ p -= 1;
}
} else {
- uint32_t const h = j->bundle->nchannels () * row_height ();
- if (y < h) {
- return make_pair (*i, ARDOUR::BundleChannel (j->bundle, y / row_height()));
+ uint32_t const s = j->bundle->nchannels ();
+ if (p < s) {
+ return make_pair (*i, ARDOUR::BundleChannel (j->bundle, p));
} else {
- y -= h;
+ p -= s;
}
}
} else {
- y -= gh;
+ p -= gs;
}
class PortMatrixBody;
class PortMatrixNode;
class PortGroup;
+class PortGroupList;
namespace ARDOUR {
class BundleChannel;
return _parent_rectangle;
}
- /** @return width of columns in the grid */
- static uint32_t column_width () {
- return 32;
- }
-
- /** @return height of rows in the grid */
- static uint32_t row_height () {
+ /** @return grid spacing */
+ static uint32_t grid_spacing () {
return 32;
}
void set_source_rgb (cairo_t *, Gdk::Color const &);
void set_source_rgba (cairo_t *, Gdk::Color const &, double);
- uint32_t group_width (boost::shared_ptr<const PortGroup>) const;
- uint32_t group_height (boost::shared_ptr<const PortGroup>) const;
- std::pair<boost::shared_ptr<PortGroup>, ARDOUR::BundleChannel> y_position_to_group_and_channel (double) const;
+ uint32_t group_size (boost::shared_ptr<const PortGroup>) const;
+ uint32_t channel_to_position (ARDOUR::BundleChannel, PortGroupList const *) const;
+ std::pair<boost::shared_ptr<PortGroup>, ARDOUR::BundleChannel> position_to_group_and_channel (uint32_t, PortGroupList const *) const;
/** Render the complete component to a cairo context. */
virtual void render (cairo_t *) = 0;
using namespace std;
PortMatrixGrid::PortMatrixGrid (PortMatrix* m, PortMatrixBody* b)
- : PortMatrixComponent (m, b)
+ : PortMatrixComponent (m, b),
+ _dragging (false),
+ _moved (false)
{
}
{
_width = 0;
for (PortGroupList::List::const_iterator i = _matrix->columns()->begin(); i != _matrix->columns()->end(); ++i) {
- _width += group_width (*i);
+ _width += group_size (*i) * grid_spacing ();
}
_height = 0;
for (PortGroupList::List::const_iterator i = _matrix->rows()->begin(); i != _matrix->rows()->end(); ++i) {
- _height += group_height (*i);
+ _height += group_size (*i) * grid_spacing ();
}
}
render_group_pair (cr, *r, *c, x, y);
}
- y += group_height (*r);
+ y += group_size (*r) * grid_spacing ();
}
- x += group_width (*c);
+ x += group_size (*c) * grid_spacing ();
}
}
PortGroup::BundleList const & column_bundles = column->bundles();
/* unfortunately we need to compute the height of the row group here */
- uint32_t height = group_height (row);
+ uint32_t height = group_size (row) * grid_spacing ();
uint32_t tx = x;
if (!_matrix->show_only_bundles()) {
cairo_set_line_width (cr, thin_grid_line_width());
for (uint32_t j = 0; j < i->bundle->nchannels(); ++j) {
- tx += column_width ();
+ tx += grid_spacing ();
cairo_move_to (cr, tx, y);
cairo_line_to (cr, tx, y + height);
cairo_stroke (cr);
} else {
- tx += column_width ();
+ tx += grid_spacing ();
}
if (!_matrix->show_only_bundles()) {
cairo_set_line_width (cr, thin_grid_line_width());
for (uint32_t j = 0; j < i->bundle->nchannels(); ++j) {
- ty += row_height ();
+ ty += grid_spacing ();
cairo_move_to (cr, x, ty);
cairo_line_to (cr, x + width, ty);
cairo_stroke (cr);
} else {
- ty += row_height ();
+ ty += grid_spacing ();
}
break;
}
- by += row_height();
+ by += grid_spacing();
}
- bx += column_width();
+ bx += grid_spacing();
}
break;
}
- ty += row_height();
+ ty += grid_spacing();
}
- tx += column_width();
+ tx += grid_spacing();
}
- by += j->bundle->nchannels () * row_height();
+ by += j->bundle->nchannels () * grid_spacing();
}
- bx += i->bundle->nchannels () * column_width();
+ bx += i->bundle->nchannels () * grid_spacing();
}
}
}
PortMatrixGrid::draw_association_indicator (cairo_t* cr, uint32_t x, uint32_t y, double p)
{
set_source_rgba (cr, association_colour(), 0.5);
+
cairo_arc (
cr,
- x + column_width() / 2,
- y + column_width() / 2,
- (column_width() - (2 * connection_indicator_pad())) / 2,
+ x + grid_spacing() / 2,
+ y + grid_spacing() / 2,
+ (grid_spacing() - (2 * connection_indicator_pad())) / 2,
0,
p * 2 * M_PI
);
cr,
x + thick_grid_line_width(),
y + thick_grid_line_width(),
- column_width() - 2 * thick_grid_line_width(),
- row_height() - 2 * thick_grid_line_width()
+ grid_spacing() - 2 * thick_grid_line_width(),
+ grid_spacing() - 2 * thick_grid_line_width()
);
cairo_fill (cr);
}
PortMatrixNode
-PortMatrixGrid::position_to_node (double x, double y) const
+PortMatrixGrid::position_to_node (uint32_t x, uint32_t y) const
{
return PortMatrixNode (
- y_position_to_group_and_channel (y).second,
- x_position_to_group_and_channel (x).second
+ position_to_group_and_channel (y, _matrix->rows()).second,
+ position_to_group_and_channel (x, _matrix->columns()).second
);
}
-
-pair<boost::shared_ptr<PortGroup>, ARDOUR::BundleChannel>
-PortMatrixGrid::x_position_to_group_and_channel (double x) const
+void
+PortMatrixGrid::button_press (double x, double y, int b, uint32_t t)
{
- PortGroupList::List::const_iterator i = _matrix->columns()->begin();
-
- while (i != _matrix->columns()->end()) {
-
- uint32_t const gw = group_width (*i);
-
- if (x < gw) {
-
- /* it's in this group */
-
- PortGroup::BundleList const & bundles = (*i)->bundles ();
- for (PortGroup::BundleList::const_iterator j = bundles.begin(); j != bundles.end(); ++j) {
-
- if (_matrix->show_only_bundles()) {
-
- if (x < column_width()) {
- return make_pair (*i, ARDOUR::BundleChannel (j->bundle, 0));
- } else {
- x -= column_width ();
- }
-
- } else {
-
- uint32_t const w = j->bundle->nchannels () * column_width ();
- if (x < w) {
- return make_pair (*i, ARDOUR::BundleChannel (j->bundle, x / column_width()));
- } else {
- x -= w;
- }
-
- }
-
- }
-
- } else {
+ if (b == 1) {
- x -= gw;
+ _dragging = true;
+ _moved = false;
+ _drag_start_x = x / grid_spacing ();
+ _drag_start_y = y / grid_spacing ();
- }
+ } else if (b == 3) {
- ++i;
+ _matrix->popup_menu (
+ position_to_group_and_channel (x / grid_spacing(), _matrix->columns()),
+ position_to_group_and_channel (y / grid_spacing(), _matrix->rows()), t);
+
}
-
- return make_pair (boost::shared_ptr<PortGroup> (), ARDOUR::BundleChannel (boost::shared_ptr<ARDOUR::Bundle> (), 0));
}
-
-
-double
-PortMatrixGrid::channel_position (
- ARDOUR::BundleChannel bc,
- PortGroup::BundleList const& bundles,
- double inc) const
+void
+PortMatrixGrid::button_release (double x, double y, int b, uint32_t t)
{
- double p = 0;
-
- PortGroup::BundleList::const_iterator i = bundles.begin ();
- while (i != bundles.end() && i->bundle != bc.bundle) {
+ if (b == 1) {
- if (_matrix->show_only_bundles()) {
- p += inc;
- } else {
- p += inc * i->bundle->nchannels();
- }
-
- ++i;
- }
+ if (_dragging && _moved) {
- if (i == bundles.end()) {
- return 0;
- }
+ list<PortMatrixNode> const p = nodes_on_line (_drag_start_x, _drag_start_y, _drag_x, _drag_y);
- p += inc * bc.channel;
+ if (_matrix->show_only_bundles()) {
+ /* XXX: err... */
+ } else {
+ for (list<PortMatrixNode>::const_iterator i = p.begin(); i != p.end(); ++i) {
- return p;
-}
-
-void
-PortMatrixGrid::button_press (double x, double y, int b, uint32_t t)
-{
- if (b == 1) {
-
- PortMatrixNode const node = position_to_node (x, y);
-
- if (_matrix->show_only_bundles()) {
-
- PortMatrixNode::State const s = bundle_to_bundle_state (node.column.bundle, node.row.bundle);
-
- for (uint32_t i = 0; i < node.column.bundle->nchannels(); ++i) {
- for (uint32_t j = 0; j < node.row.bundle->nchannels(); ++j) {
-
ARDOUR::BundleChannel c[2];
- c[_matrix->column_index()] = ARDOUR::BundleChannel (node.column.bundle, i);
- c[_matrix->row_index()] = ARDOUR::BundleChannel (node.row.bundle, j);
- if (s == PortMatrixNode::NOT_ASSOCIATED || s == PortMatrixNode::PARTIAL) {
- _matrix->set_state (c, i == j);
- } else {
- _matrix->set_state (c, false);
+ c[_matrix->row_index()] = i->row;
+ c[_matrix->column_index()] = i->column;
+
+ PortMatrixNode::State const s = _matrix->get_state (c);
+
+ if (s == PortMatrixNode::ASSOCIATED || s == PortMatrixNode::NOT_ASSOCIATED) {
+ bool const n = !(s == PortMatrixNode::ASSOCIATED);
+ _matrix->set_state (c, n);
}
}
}
-
+
+ require_render ();
+ _body->queue_draw ();
+
} else {
+
+ PortMatrixNode const node = position_to_node (x / grid_spacing(), y / grid_spacing());
- if (node.row.bundle && node.column.bundle) {
+ if (_matrix->show_only_bundles()) {
- ARDOUR::BundleChannel c[2];
- c[_matrix->row_index()] = node.row;
- c[_matrix->column_index()] = node.column;
+ PortMatrixNode::State const s = bundle_to_bundle_state (node.column.bundle, node.row.bundle);
- PortMatrixNode::State const s = _matrix->get_state (c);
+ for (uint32_t i = 0; i < node.column.bundle->nchannels(); ++i) {
+ for (uint32_t j = 0; j < node.row.bundle->nchannels(); ++j) {
+
+ ARDOUR::BundleChannel c[2];
+ c[_matrix->column_index()] = ARDOUR::BundleChannel (node.column.bundle, i);
+ c[_matrix->row_index()] = ARDOUR::BundleChannel (node.row.bundle, j);
+ if (s == PortMatrixNode::NOT_ASSOCIATED || s == PortMatrixNode::PARTIAL) {
+ _matrix->set_state (c, i == j);
+ } else {
+ _matrix->set_state (c, false);
+ }
+ }
+ }
- if (s == PortMatrixNode::ASSOCIATED || s == PortMatrixNode::NOT_ASSOCIATED) {
-
- bool const n = !(s == PortMatrixNode::ASSOCIATED);
+ } else {
+
+ if (node.row.bundle && node.column.bundle) {
ARDOUR::BundleChannel c[2];
c[_matrix->row_index()] = node.row;
c[_matrix->column_index()] = node.column;
- _matrix->set_state (c, n);
+ PortMatrixNode::State const s = _matrix->get_state (c);
+
+ if (s == PortMatrixNode::ASSOCIATED || s == PortMatrixNode::NOT_ASSOCIATED) {
+
+ bool const n = !(s == PortMatrixNode::ASSOCIATED);
+ _matrix->set_state (c, n);
+ }
+
}
-
}
+
+ require_render ();
+ _body->queue_draw ();
}
-
- require_render ();
- _body->queue_draw ();
-
- } else if (b == 3) {
-
- _matrix->popup_menu (x_position_to_group_and_channel (x), y_position_to_group_and_channel (y), t);
-
}
+
+ _dragging = false;
}
+
void
PortMatrixGrid::draw_extra (cairo_t* cr)
{
set_source_rgba (cr, mouseover_line_colour(), 0.3);
cairo_set_line_width (cr, mouseover_line_width());
- double const x = component_to_parent_x (
- channel_position (_body->mouseover().column, _matrix->columns()->bundles(), column_width()) + column_width() / 2
- );
-
- double const y = component_to_parent_y (
- channel_position (_body->mouseover().row, _matrix->rows()->bundles(), row_height()) + row_height() / 2
- );
+ double const x = component_to_parent_x (channel_to_position (_body->mouseover().column, _matrix->columns()) * grid_spacing()) + grid_spacing() / 2;
+ double const y = component_to_parent_y (channel_to_position (_body->mouseover().row, _matrix->rows()) * grid_spacing()) + grid_spacing() / 2;
if (_body->mouseover().row.bundle) {
}
cairo_stroke (cr);
}
+
+ if (_dragging && _moved) {
+
+ set_source_rgba (cr, association_colour (), 0.3);
+
+ cairo_move_to (
+ cr,
+ component_to_parent_x (_drag_start_x * grid_spacing() + grid_spacing() / 2),
+ component_to_parent_y (_drag_start_y * grid_spacing() + grid_spacing() / 2)
+ );
+
+ cairo_line_to (
+ cr,
+ component_to_parent_x (_drag_x * grid_spacing() + grid_spacing() / 2),
+ component_to_parent_y (_drag_y * grid_spacing() + grid_spacing() / 2)
+ );
+
+ cairo_stroke (cr);
+
+ list<PortMatrixNode> const p = nodes_on_line (_drag_start_x, _drag_start_y, _drag_x, _drag_y);
+
+ for (list<PortMatrixNode>::const_iterator i = p.begin(); i != p.end(); ++i) {
+ draw_association_indicator (
+ cr,
+ component_to_parent_x (channel_to_position (i->column, _matrix->columns()) * grid_spacing ()),
+ component_to_parent_y (channel_to_position (i->row, _matrix->rows()) * grid_spacing ())
+ );
+ }
+ }
}
void
}
void
-PortMatrixGrid::mouseover_event (double x, double y)
+PortMatrixGrid::motion (double x, double y)
{
- _body->set_mouseover (position_to_node (x, y));
+ _body->set_mouseover (position_to_node (x / grid_spacing(), y / grid_spacing()));
+
+ int const px = x / grid_spacing ();
+ int const py = y / grid_spacing ();
+
+ if (_dragging && !_moved && ( (px != _drag_start_x || py != _drag_start_x) )) {
+ _moved = true;
+ }
+
+ if (_dragging && _moved) {
+ _drag_x = px;
+ _drag_y = py;
+ _body->queue_draw ();
+ }
}
void
{
if (n.row.bundle) {
- double const y = channel_position (n.row, _matrix->rows()->bundles(), row_height());
+ double const y = channel_to_position (n.row, _matrix->rows()) * grid_spacing ();
_body->queue_draw_area (
_parent_rectangle.get_x(),
component_to_parent_y (y),
_parent_rectangle.get_width(),
- row_height()
+ grid_spacing()
);
}
if (n.column.bundle) {
- double const x = channel_position (n.column, _matrix->columns()->bundles(), column_width());
+ double const x = channel_to_position (n.column, _matrix->columns()) * grid_spacing ();
_body->queue_draw_area (
component_to_parent_x (x),
_parent_rectangle.get_y(),
- column_width(),
+ grid_spacing(),
_parent_rectangle.get_height()
);
}
return PortMatrixNode::PARTIAL;
}
+list<PortMatrixNode>
+PortMatrixGrid::nodes_on_line (int x0, int y0, int x1, int y1) const
+{
+ list<PortMatrixNode> p;
+
+ bool const steep = abs (y1 - y0) > abs (x1 - x0);
+ if (steep) {
+ int tmp = x0;
+ x0 = y0;
+ y0 = tmp;
+
+ tmp = y1;
+ y1 = x1;
+ x1 = tmp;
+ }
+
+ if (x0 > x1) {
+ int tmp = x0;
+ x0 = x1;
+ x1 = tmp;
+
+ tmp = y0;
+ y0 = y1;
+ y1 = tmp;
+ }
+
+ int dx = x1 - x0;
+ int dy = abs (y1 - y0);
+ double err = 0;
+ double derr = double (dy) / dx;
+
+ int y = y0;
+ int const ystep = y0 < y1 ? 1 : -1;
+
+ for (int x = x0; x <= x1; ++x) {
+ if (steep) {
+ p.push_back (position_to_node (y, x));
+ } else {
+ p.push_back (position_to_node (x, y));
+ }
+
+ err += derr;
+
+ if (err >= 0.5) {
+ y += ystep;
+ err -= 1;
+ }
+ }
+
+ return p;
+}
PortMatrixGrid (PortMatrix *, PortMatrixBody *);
void button_press (double, double, int, uint32_t);
- void mouseover_event (double, double);
+ void button_release (double, double, int, uint32_t);
+ void motion (double, double);
double component_to_parent_x (double x) const;
double parent_to_component_x (double x) const;
void render (cairo_t *);
void render_group_pair (cairo_t *, boost::shared_ptr<const PortGroup>, boost::shared_ptr<const PortGroup>, uint32_t, uint32_t);
- double channel_position (ARDOUR::BundleChannel, PortGroup::BundleList const &, double) const;
- PortMatrixNode position_to_node (double, double) const;
- std::pair<boost::shared_ptr<PortGroup>, ARDOUR::BundleChannel> x_position_to_group_and_channel (double) const;
+ PortMatrixNode position_to_node (uint32_t, uint32_t) const;
void queue_draw_for (PortMatrixNode const &);
void draw_association_indicator (cairo_t *, uint32_t, uint32_t, double p = 1);
void draw_unknown_indicator (cairo_t *, uint32_t, uint32_t);
PortMatrixNode::State bundle_to_bundle_state (boost::shared_ptr<ARDOUR::Bundle>, boost::shared_ptr<ARDOUR::Bundle>) const;
-
+ std::list<PortMatrixNode> nodes_on_line (int, int, int, int) const;
+
+ bool _dragging;
+ bool _moved;
+ int _drag_start_x;
+ int _drag_start_y;
+ int _drag_x;
+ int _drag_y;
};
#endif
}
if (_matrix->show_only_bundles()) {
- _height += row_height ();
+ _height += grid_spacing ();
} else {
- _height += i->bundle->nchannels() * row_height();
+ _height += i->bundle->nchannels() * grid_spacing();
}
}
_highest_group_name = ext.height;
}
} else {
- /* add another row_height for a tab for this hidden group */
- _height += row_height ();
+ /* add another grid_spacing for a tab for this hidden group */
+ _height += grid_spacing ();
}
}
/* compute height of this group */
double h = 0;
if (!(*i)->visible() || (*i)->bundles().empty()) {
- h = row_height ();
+ h = grid_spacing ();
} else {
if (_matrix->show_only_bundles()) {
- h = (*i)->bundles().size() * row_height();
+ h = (*i)->bundles().size() * grid_spacing();
} else {
- h = (*i)->total_channels () * row_height();
+ h = (*i)->total_channels () * grid_spacing();
}
}
for (uint32_t k = 0; k < j->bundle->nchannels(); ++k) {
Gdk::Color c = j->has_colour ? j->colour : get_a_bundle_colour (M);
render_channel_name (cr, c, 0, y, ARDOUR::BundleChannel (j->bundle, k));
- y += row_height();
+ y += grid_spacing();
++M;
}
} else {
- y += row_height();
+ y += grid_spacing();
}
++N;
} else {
- y += row_height ();
+ y += grid_spacing ();
}
}
}
{
uint32_t const gw = (_highest_group_name + 2 * name_pad());
- pair<boost::shared_ptr<PortGroup>, ARDOUR::BundleChannel> w = y_position_to_group_and_channel (y);
+ pair<boost::shared_ptr<PortGroup>, ARDOUR::BundleChannel> w = position_to_group_and_channel (y / grid_spacing (), _matrix->rows());
if (
(_matrix->arrangement() == PortMatrix::LEFT_TO_BOTTOM && x < gw) ||
} else if (b == 3) {
- if (
- (_matrix->arrangement() == PortMatrix::LEFT_TO_BOTTOM && x < (_longest_port_name + name_pad() * 2)) ||
- (_matrix->arrangement() == PortMatrix::TOP_TO_RIGHT && x > (_longest_port_name + name_pad() * 2))
-
- ) {
-
- _matrix->popup_menu (
- make_pair (boost::shared_ptr<PortGroup> (), ARDOUR::BundleChannel ()),
- make_pair (w.first, ARDOUR::BundleChannel ()),
- t
- );
- } else {
- _matrix->popup_menu (
- make_pair (boost::shared_ptr<PortGroup> (), ARDOUR::BundleChannel ()),
- make_pair (w.first, ARDOUR::BundleChannel ()),
- t
- );
- }
+ _matrix->popup_menu (
+ make_pair (boost::shared_ptr<PortGroup> (), ARDOUR::BundleChannel ()),
+ w,
+ t
+ );
}
}
int const n = _matrix->show_only_bundles() ? 1 : b->nchannels();
set_source_rgb (cr, colour);
- cairo_rectangle (cr, xoff + x, yoff, _longest_bundle_name + name_pad() * 2, row_height() * n);
+ cairo_rectangle (cr, xoff + x, yoff, _longest_bundle_name + name_pad() * 2, grid_spacing() * n);
cairo_fill_preserve (cr);
set_source_rgb (cr, background_colour());
cairo_set_line_width (cr, label_border_width ());
cairo_stroke (cr);
- double const off = row_height() / 2;
+ double const off = grid_spacing() / 2;
// if ((*i)->nchannels () > 0 && !_matrix->show_only_bundles()) {
// /* use the extent of our first channel name so that the bundle name is vertically aligned with it */
// cairo_text_extents_t ext;
// cairo_text_extents (cr, (*i)->channel_name(0).c_str(), &ext);
-// off = (row_height() - ext.height) / 2;
+// off = (grid_spacing() - ext.height) / 2;
// }
set_source_rgb (cr, text_colour());
)
{
set_source_rgb (cr, colour);
- cairo_rectangle (cr, port_name_x() + xoff, yoff, _longest_port_name + name_pad() * 2, row_height());
+ cairo_rectangle (cr, port_name_x() + xoff, yoff, _longest_port_name + name_pad() * 2, grid_spacing());
cairo_fill_preserve (cr);
set_source_rgb (cr, background_colour());
cairo_set_line_width (cr, label_border_width ());
cairo_text_extents_t ext;
cairo_text_extents (cr, bc.bundle->channel_name(bc.channel).c_str(), &ext);
- double const off = (row_height() - ext.height) / 2;
+ double const off = (grid_spacing() - ext.height) / 2;
set_source_rgb (cr, text_colour());
cairo_move_to (cr, port_name_x() + xoff + name_pad(), yoff + name_pad() + off);
double
PortMatrixRowLabels::channel_y (ARDOUR::BundleChannel const& bc) const
{
- uint32_t n = 0;
-
- PortGroup::BundleList const & bundles = _matrix->rows()->bundles();
- PortGroup::BundleList::const_iterator i = bundles.begin ();
- while (i != bundles.end() && i->bundle != bc.bundle) {
- if (_matrix->show_only_bundles()) {
- n += 1;
- } else {
- n += i->bundle->nchannels ();
- }
- ++i;
- }
-
- if (!_matrix->show_only_bundles()) {
- n += bc.channel;
- }
-
- return n * row_height();
+ return channel_to_position (bc, _matrix->rows()) * grid_spacing ();
}
void
component_to_parent_x (bundle_name_x()),
component_to_parent_y (channel_y (bc)),
_longest_bundle_name + name_pad() * 2,
- row_height()
+ grid_spacing()
);
} else {
_body->queue_draw_area (
component_to_parent_x (port_name_x()),
component_to_parent_y (channel_y (bc)),
_longest_port_name + name_pad() * 2,
- row_height()
+ grid_spacing()
);
}
}
projects / ardour.git / commitdiff