← Back to branch summary

~ubuntu-branches/ubuntu/utopic/ardour3/utopic

« back to all changes in this revision

Viewing changes to gtk2_ardour/port_matrix_component.cc

  • Committer: Package Import Robot
  • Author(s): Felipe Sateler
  • Date: 2013-09-21 19:05:02 UTC
  • Revision ID: package-import@ubuntu.com-20130921190502-8gsftrku6jnzhd7v
Tags: upstream-3.4~dfsg
Import upstream version 3.4~dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
gtk2_ardour/port_matrix_component.cc
 
1
/*
 
2
    Copyright (C) 2002-2009 Paul Davis
 
3
 
 
4
    This program is free software; you can redistribute it and/or modify
 
5
    it under the terms of the GNU General Public License as published by
 
6
    the Free Software Foundation; either version 2 of the License, or
 
7
    (at your option) any later version.
 
8
 
 
9
    This program is distributed in the hope that it will be useful,
 
10
    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
    GNU General Public License for more details.
 
13
 
 
14
    You should have received a copy of the GNU General Public License
 
15
    along with this program; if not, write to the Free Software
 
16
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
17
 
 
18
*/
 
19
 
 
20
#include "port_matrix_component.h"
 
21
#include "port_matrix.h"
 
22
#include "port_matrix_body.h"
 
23
 
 
24
using namespace std;
 
25
 
 
26
/** Constructor.
 
27
 *  @param m Port matrix that we're in.
 
28
 *  @param b Port matrix body that we're in.
 
29
 */
 
30
PortMatrixComponent::PortMatrixComponent (PortMatrix* m, PortMatrixBody* b)
 
31
        : _matrix (m),
 
32
          _body (b),
 
33
          _pixmap (0),
 
34
          _render_required (true),
 
35
          _dimension_computation_required (true)
 
36
{
 
37
 
 
38
}
 
39
 
 
40
/** Destructor */
 
41
PortMatrixComponent::~PortMatrixComponent ()
 
42
{
 
43
        if (_pixmap) {
 
44
                g_object_unref (_pixmap);
 
45
        }
 
46
}
 
47
 
 
48
void
 
49
PortMatrixComponent::setup ()
 
50
{
 
51
        _dimension_computation_required = true;
 
52
        _render_required = true;
 
53
}
 
54
 
 
55
GdkPixmap *
 
56
PortMatrixComponent::get_pixmap (GdkDrawable *drawable)
 
57
{
 
58
        if (_render_required) {
 
59
 
 
60
                if (_dimension_computation_required) {
 
61
                        compute_dimensions ();
 
62
                        _dimension_computation_required = false;
 
63
                        _body->component_size_changed ();
 
64
                }
 
65
 
 
66
                /* we may be zero width or height; if so, just
 
67
                   use the smallest allowable pixmap */
 
68
                if (_width == 0) {
 
69
                        _width = 1;
 
70
                }
 
71
                if (_height == 0) {
 
72
                        _height = 1;
 
73
                }
 
74
 
 
75
                /* make a pixmap of the right size */
 
76
                if (_pixmap) {
 
77
                        g_object_unref (_pixmap);
 
78
                }
 
79
                _pixmap = gdk_pixmap_new (drawable, _width, _height, -1);
 
80
 
 
81
                /* render */
 
82
                cairo_t* cr = gdk_cairo_create (_pixmap);
 
83
                render (cr);
 
84
                cairo_destroy (cr);
 
85
 
 
86
                _render_required = false;
 
87
        }
 
88
 
 
89
        return _pixmap;
 
90
}
 
91
 
 
92
void
 
93
PortMatrixComponent::set_source_rgb (cairo_t *cr, Gdk::Color const & c)
 
94
{
 
95
        cairo_set_source_rgb (cr, c.get_red_p(), c.get_green_p(), c.get_blue_p());
 
96
}
 
97
 
 
98
void
 
99
PortMatrixComponent::set_source_rgba (cairo_t *cr, Gdk::Color const & c, double a)
 
100
{
 
101
        cairo_set_source_rgba (cr, c.get_red_p(), c.get_green_p(), c.get_blue_p(), a);
 
102
}
 
103
 
 
104
pair<uint32_t, uint32_t>
 
105
PortMatrixComponent::dimensions ()
 
106
{
 
107
        if (_dimension_computation_required) {
 
108
                compute_dimensions ();
 
109
                _dimension_computation_required = false;
 
110
                _body->component_size_changed ();
 
111
        }
 
112
 
 
113
        return make_pair (_width, _height);
 
114
}
 
115
 
 
116
Gdk::Color
 
117
PortMatrixComponent::background_colour ()
 
118
{
 
119
        return _matrix->get_style()->get_bg (Gtk::STATE_NORMAL);
 
120
}
 
121
 
 
122
/** @param g Group.
 
123
 *  @return Visible size of the group in grid units, taking visibility and show_only_bundles into account.
 
124
 */
 
125
uint32_t
 
126
PortMatrixComponent::group_size (boost::shared_ptr<const PortGroup> g) const
 
127
{
 
128
        uint32_t s = 0;
 
129
 
 
130
        PortGroup::BundleList const & bundles = g->bundles ();
 
131
        if (_matrix->show_only_bundles()) {
 
132
                s = bundles.size();
 
133
        } else {
 
134
                for (PortGroup::BundleList::const_iterator i = bundles.begin(); i != bundles.end(); ++i) {
 
135
                        s += _matrix->count_of_our_type_min_1 ((*i)->bundle->nchannels());
 
136
                }
 
137
        }
 
138
 
 
139
        return s;
 
140
}
 
141
 
 
142
/** @param bc Channel.
 
143
 *  @param group Group.
 
144
 *  @return Position of bc in groups in grid units, taking show_only_bundles into account.
 
145
 */
 
146
uint32_t
 
147
PortMatrixComponent::channel_to_position (ARDOUR::BundleChannel bc, boost::shared_ptr<const PortGroup> group) const
 
148
{
 
149
        uint32_t p = 0;
 
150
 
 
151
        PortGroup::BundleList const & bundles = group->bundles ();
 
152
 
 
153
        for (PortGroup::BundleList::const_iterator i = bundles.begin(); i != bundles.end(); ++i) {
 
154
 
 
155
                if ((*i)->bundle == bc.bundle) {
 
156
 
 
157
                        /* found the bundle */
 
158
 
 
159
                        if (_matrix->show_only_bundles()) {
 
160
                                return p;
 
161
                        } else {
 
162
                                return p + bc.bundle->overall_channel_to_type (_matrix->type (), bc.channel);
 
163
                        }
 
164
 
 
165
                }
 
166
 
 
167
                /* move past this bundle */
 
168
 
 
169
                if (_matrix->show_only_bundles()) {
 
170
                        p += 1;
 
171
                } else {
 
172
                        p += _matrix->count_of_our_type_min_1 ((*i)->bundle->nchannels());
 
173
                }
 
174
        }
 
175
 
 
176
        return 0;
 
177
}
 
178
 
 
179
 
 
180
ARDOUR::BundleChannel
 
181
PortMatrixComponent::position_to_channel (double p, double, boost::shared_ptr<const PortGroup> group) const
 
182
{
 
183
        p /= grid_spacing ();
 
184
 
 
185
        PortGroup::BundleList const & bundles = group->bundles ();
 
186
        for (PortGroup::BundleList::const_iterator j = bundles.begin(); j != bundles.end(); ++j) {
 
187
 
 
188
                if (_matrix->show_only_bundles()) {
 
189
 
 
190
                        if (p < 1) {
 
191
                                return ARDOUR::BundleChannel ((*j)->bundle, -1);
 
192
                        } else {
 
193
                                p -= 1;
 
194
                        }
 
195
 
 
196
                } else {
 
197
 
 
198
                        ARDOUR::ChanCount const N = (*j)->bundle->nchannels ();
 
199
 
 
200
                        uint32_t const s = _matrix->count_of_our_type_min_1 (N);
 
201
                        if (p < s) {
 
202
                                if (p < _matrix->count_of_our_type (N)) {
 
203
                                        return ARDOUR::BundleChannel ((*j)->bundle, (*j)->bundle->type_channel_to_overall (_matrix->type (), p));
 
204
                                } else {
 
205
                                        return ARDOUR::BundleChannel (boost::shared_ptr<ARDOUR::Bundle> (), -1);
 
206
                                }
 
207
                        } else {
 
208
                                p -= s;
 
209
                        }
 
210
 
 
211
                }
 
212
 
 
213
        }
 
214
 
 
215
        return ARDOUR::BundleChannel (boost::shared_ptr<ARDOUR::Bundle> (), -1);
 
216
}