#include <cmath>
#include <algorithm>
-#include <gtk--.h>
+#include <gtkmm.h>
-#include <gtkmmext/gtk_ui.h>
+#include <gtkmm2ext/gtk_ui.h>
#include <ardour/playlist.h>
#include <ardour/audioregion.h>
#include "streamview.h"
#include "regionview.h"
#include "audio_time_axis.h"
-#include "canvas-simplerect.h"
-#include "canvas-simpleline.h"
-#include "canvas-waveview.h"
+#include "simplerect.h"
+#include "simpleline.h"
+#include "waveview.h"
#include "public_editor.h"
#include "region_editor.h"
#include "region_gain_line.h"
#include "i18n.h"
-using namespace SigC;
+using namespace sigc;
using namespace ARDOUR;
using namespace Editing;
+using namespace ArdourCanvas;
static const int32_t sync_mark_width = 9;
-SigC::Signal1<void,AudioRegionView*> AudioRegionView::AudioRegionViewGoingAway;
+sigc::signal<void,AudioRegionView*> AudioRegionView::AudioRegionViewGoingAway;
-AudioRegionView::AudioRegionView (GtkCanvasGroup *parent, AudioTimeAxisView &tv,
+AudioRegionView::AudioRegionView (ArdourCanvas::Group *parent, AudioTimeAxisView &tv,
AudioRegion& r,
double spu,
double amplitude_above_axis,
- GdkColor& basic_color,
+ Gdk::Color& basic_color,
bool wfw)
- : TimeAxisViewItem (r.name(), parent, tv, spu, basic_color, r.position(), r.length(),
+ : TimeAxisViewItem (r.name(), *parent, tv, spu, basic_color, r.position(), r.length(),
TimeAxisViewItem::Visibility (TimeAxisViewItem::ShowNameText|
TimeAxisViewItem::ShowNameHighlight|
TimeAxisViewItem::ShowFrame)),
region (r)
{
- GtkCanvasPoints *shape;
+ ArdourCanvas::Points shape;
XMLNode *node;
editor = 0;
create_waves ();
- gtk_object_set_data (GTK_OBJECT(name_highlight), "regionview", this);
- gtk_object_set_data (GTK_OBJECT(name_text), "regionview", this);
+ name_highlight->set_data ("regionview", this);
+ name_text->set_data ("regionview", this);
- shape = gtk_canvas_points_new (4);
+ // shape = new ArdourCanvas::Points ();
/* an equilateral triangle */
- shape->coords[0] = -((sync_mark_width-1)/2);
- shape->coords[1] = 1;
+ shape.push_back (Gnome::Art::Point (-((sync_mark_width-1)/2), 1));
+ shape.push_back (Gnome::Art::Point ((sync_mark_width - 1)/2, 1));
+ shape.push_back (Gnome::Art::Point (0, sync_mark_width - 1));
+ shape.push_back (Gnome::Art::Point (-((sync_mark_width-1)/2), 1));
- shape->coords[2] = (sync_mark_width - 1)/2;
- shape->coords[3] = 1;
-
- shape->coords[4] = 0;
- shape->coords[5] = sync_mark_width - 1;
-
- shape->coords[6] = -((sync_mark_width-1)/2);
- shape->coords[7] = 1;
-
- // cerr << "set sync mark al points, nc = " << shape->num_points << endl;
- sync_mark = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_polygon_get_type(),
- "points", shape,
- "fill_color_rgba", fill_color,
- NULL);
- gtk_canvas_item_hide (sync_mark);
- gtk_canvas_points_unref (shape);
+ sync_mark = new ArdourCanvas::Polygon (*group);
+ sync_mark->property_points() = shape;
+ sync_mark->property_fill_color_rgba() = fill_color;
+ sync_mark->hide();
+ fade_in_shape = new ArdourCanvas::Polygon (*group);
+ fade_in_shape->property_fill_color_rgba() = fade_color;
+ fade_in_shape->set_data ("regionview", this);
- fade_in_shape = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_polygon_get_type(),
- "fill_color_rgba", fade_color,
- NULL);
- gtk_object_set_data (GTK_OBJECT(fade_in_shape), "regionview", this);
-
- fade_out_shape = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_polygon_get_type(),
- "fill_color_rgba", fade_color,
- NULL);
- gtk_object_set_data (GTK_OBJECT(fade_out_shape), "regionview", this);
-
+ fade_out_shape = new ArdourCanvas::Polygon (*group);
+ fade_out_shape->property_fill_color_rgba() = fade_color;
+ fade_out_shape->set_data ("regionview", this);
{
- uint32_t r,g,b,a;
- UINT_TO_RGBA(fill_color,&r,&g,&b,&a);
+ uint32_t r,g,b,a;
+ UINT_TO_RGBA(fill_color,&r,&g,&b,&a);
- fade_in_handle = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_simplerect_get_type(),
- "fill_color_rgba", RGBA_TO_UINT(r,g,b,0),
- "outline_pixels", 0,
- "y1", 2.0,
- "y2", 7.0,
- NULL);
- gtk_object_set_data (GTK_OBJECT(fade_in_handle), "regionview", this);
-
- fade_out_handle = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_simplerect_get_type(),
- "fill_color_rgba", RGBA_TO_UINT(r,g,b,0),
- "outline_pixels", 0,
- "y1", 2.0,
- "y2", 7.0,
- NULL);
- gtk_object_set_data (GTK_OBJECT(fade_out_handle), "regionview", this);
+ fade_in_handle = new ArdourCanvas::SimpleRect (*group);
+ fade_in_handle->property_fill_color_rgba() = RGBA_TO_UINT(r,g,b,0);
+ fade_in_handle->property_outline_pixels() = 0;
+ fade_in_handle->property_y1() = 2.0;
+ fade_in_handle->property_y2() = 7.0;
+
+ fade_in_handle->set_data ("regionview", this);
+
+ fade_out_handle = new ArdourCanvas::SimpleRect (*group);
+ fade_out_handle->property_fill_color_rgba() = RGBA_TO_UINT(r,g,b,0);
+ fade_out_handle->property_outline_pixels() = 0;
+ fade_out_handle->property_y1() = 2.0;
+ fade_out_handle->property_y2() = 7.0;
+
+ fade_out_handle->set_data ("regionview", this);
}
string foo = region.name();
foo += ':';
foo += "gain";
- gain_line = new AudioRegionGainLine (foo, tv.session(), *this, group, region.envelope(),
- PublicEditor::canvas_control_point_event,
- PublicEditor::canvas_line_event);
+ gain_line = new AudioRegionGainLine (foo, tv.session(), *this, *group, region.envelope());
if (!(_flags & EnvelopeVisible)) {
gain_line->hide ();
fade_in_active_changed ();
fade_out_active_changed ();
- region.StateChanged.connect (slot (*this, &AudioRegionView::region_changed));
-
- gtk_signal_connect (GTK_OBJECT(group), "event",
- (GtkSignalFunc) PublicEditor::canvas_region_view_event,
- this);
- gtk_signal_connect (GTK_OBJECT(name_highlight), "event",
- (GtkSignalFunc) PublicEditor::canvas_region_view_name_highlight_event,
- this);
-
- gtk_signal_connect (GTK_OBJECT(name_text), "event",
- (GtkSignalFunc) PublicEditor::canvas_region_view_name_event,
- this);
-
- gtk_signal_connect (GTK_OBJECT(fade_in_shape), "event",
- (GtkSignalFunc) PublicEditor::canvas_fade_in_event,
- this);
-
- gtk_signal_connect (GTK_OBJECT(fade_in_handle), "event",
- (GtkSignalFunc) PublicEditor::canvas_fade_in_handle_event,
- this);
-
- gtk_signal_connect (GTK_OBJECT(fade_out_shape), "event",
- (GtkSignalFunc) PublicEditor::canvas_fade_out_event,
- this);
+ region.StateChanged.connect (mem_fun(*this, &AudioRegionView::region_changed));
- gtk_signal_connect (GTK_OBJECT(fade_out_handle), "event",
- (GtkSignalFunc) PublicEditor::canvas_fade_out_handle_event,
- this);
+ group->signal_event().connect (bind (mem_fun (PublicEditor::instance(), &PublicEditor::canvas_region_view_event), group, this));
+ name_highlight->signal_event().connect (bind (mem_fun (PublicEditor::instance(), &PublicEditor::canvas_region_view_name_highlight_event), name_highlight, this));
+ fade_in_shape->signal_event().connect (bind (mem_fun (PublicEditor::instance(), &PublicEditor::canvas_fade_in_event), fade_in_shape, this));
+ fade_in_handle->signal_event().connect (bind (mem_fun (PublicEditor::instance(), &PublicEditor::canvas_fade_in_handle_event), fade_in_handle, this));
+ fade_out_shape->signal_event().connect (bind (mem_fun (PublicEditor::instance(), &PublicEditor::canvas_fade_out_event), fade_out_shape, this));
+ fade_out_handle->signal_event().connect (bind (mem_fun (PublicEditor::instance(), &PublicEditor::canvas_fade_out_handle_event), fade_out_handle, this));
set_colors ();
/* XXX sync mark drag? */
-
}
AudioRegionView::~AudioRegionView ()
AudioRegionViewGoingAway (this); /* EMIT_SIGNAL */
- for (vector<GtkCanvasWaveViewCache *>::iterator cache = wave_caches.begin(); cache != wave_caches.end() ; ++cache) {
- gtk_canvas_waveview_cache_destroy (*cache);
+ for (vector<GnomeCanvasWaveViewCache *>::iterator cache = wave_caches.begin(); cache != wave_caches.end() ; ++cache) {
+ gnome_canvas_waveview_cache_destroy (*cache);
}
/* all waveviews will be destroyed when the group is destroyed */
}
gint
-AudioRegionView::_lock_toggle (GtkCanvasItem* item, GdkEvent* ev, void* arg)
+AudioRegionView::_lock_toggle (ArdourCanvas::Item* item, GdkEvent* ev, void* arg)
{
switch (ev->type) {
case GDK_BUTTON_RELEASE:
void
AudioRegionView::region_changed (Change what_changed)
{
- ENSURE_GUI_THREAD (bind (slot (*this, &AudioRegionView::region_changed), what_changed));
+ ENSURE_GUI_THREAD (bind (mem_fun(*this, &AudioRegionView::region_changed), what_changed));
if (what_changed & BoundsChanged) {
region_resized (what_changed);
if (region.fade_in_active()) {
col = RGBA_TO_UINT(r,g,b,120);
- gtk_canvas_item_set (fade_in_shape,
- "fill_color_rgba", col,
- "width_pixels", 0,
- "outline_color_rgba", RGBA_TO_UINT(r,g,b,0),
- NULL);
+ fade_in_shape->property_fill_color_rgba() = col;
+ fade_in_shape->property_width_pixels() = 0;
+ fade_in_shape->property_outline_color_rgba() = RGBA_TO_UINT(r,g,b,0);
} else {
col = RGBA_TO_UINT(r,g,b,0);
- gtk_canvas_item_set (fade_in_shape,
- "fill_color_rgba", col,
- "width_pixels", 1,
- "outline_color_rgba", RGBA_TO_UINT(r,g,b,255),
- NULL);
+ fade_in_shape->property_fill_color_rgba() = col;
+ fade_in_shape->property_width_pixels() = 1;
+ fade_in_shape->property_outline_color_rgba() = RGBA_TO_UINT(r,g,b,255);
}
}
if (region.fade_out_active()) {
col = RGBA_TO_UINT(r,g,b,120);
- gtk_canvas_item_set (fade_out_shape,
- "fill_color_rgba", col,
- "width_pixels", 0,
- "outline_color_rgba", RGBA_TO_UINT(r,g,b,0),
- NULL);
+ fade_out_shape->property_fill_color_rgba() = col;
+ fade_out_shape->property_width_pixels() = 0;
+ fade_out_shape->property_outline_color_rgba() = RGBA_TO_UINT(r,g,b,0);
} else {
col = RGBA_TO_UINT(r,g,b,0);
- gtk_canvas_item_set (fade_out_shape,
- "fill_color_rgba", col,
- "width_pixels", 1,
- "outline_color_rgba", RGBA_TO_UINT(r,g,b,255),
- NULL);
+ fade_out_shape->property_fill_color_rgba() = col;
+ fade_out_shape->property_width_pixels() = 1;
+ fade_out_shape->property_outline_color_rgba() = RGBA_TO_UINT(r,g,b,255);
}
}
void
AudioRegionView::region_scale_amplitude_changed ()
{
- ENSURE_GUI_THREAD (slot (*this, &AudioRegionView::region_scale_amplitude_changed));
+ ENSURE_GUI_THREAD (mem_fun(*this, &AudioRegionView::region_scale_amplitude_changed));
for (uint32_t n = 0; n < waves.size(); ++n) {
// force a reload of the cache
- gtk_canvas_item_set (waves[n], "data_src", ®ion, NULL);
+ waves[n]->property_data_src() = ®ion;
}
}
reset_width_dependent_items (unit_length);
for (uint32_t n = 0; n < waves.size(); ++n) {
- gtk_canvas_item_set (waves[n], "region_start", (guint32) region.start(), NULL);
+ waves[n]->property_region_start() = region.start();
}
for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
(*i)->set_duration (unit_length);
- for (vector<GtkCanvasItem*>::iterator w = (*i)->waves.begin(); w != (*i)->waves.end(); ++w) {
- gtk_canvas_item_set ((*w), "region_start", region.start(), NULL);
+ for (vector<WaveView*>::iterator w = (*i)->waves.begin(); w != (*i)->waves.end(); ++w) {
+ (*w)->property_region_start() = region.start();
}
}
}
_pixel_width = pixel_width;
if (zero_line) {
- gtk_canvas_item_set (zero_line, "x2", pixel_width - 1.0, NULL);
+ zero_line->property_x2() = pixel_width - 1.0;
}
if (pixel_width <= 6.0) {
- gtk_canvas_item_hide (fade_in_handle);
- gtk_canvas_item_hide (fade_out_handle);
+ fade_in_handle->hide();
+ fade_out_handle->hide();
} else {
if (_height < 5.0) {
- gtk_canvas_item_hide (fade_in_handle);
- gtk_canvas_item_hide (fade_out_handle);
+ fade_in_handle->hide();
+ fade_out_handle->hide();
} else {
- gtk_canvas_item_show (fade_in_handle);
- gtk_canvas_item_show (fade_out_handle);
+ fade_in_handle->show();
+ fade_out_handle->show();
}
}
for (uint32_t n=0; n < waves.size(); ++n) {
if (region.muted()) {
- gtk_canvas_item_set (waves[n], "wave_color", color_map[cMutedWaveForm], NULL);
+ waves[n]->property_wave_color() = color_map[cMutedWaveForm];
} else {
- gtk_canvas_item_set (waves[n], "wave_color", color_map[cWaveForm], NULL);
+ waves[n]->property_wave_color() = color_map[cWaveForm];
}
}
}
if (delta) {
for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
- gtk_canvas_item_move ((*i)->group, delta, 0.0);
+ (*i)->group->move (delta, 0.0);
}
}
gdouble yoff = n * (ht+1);
- gtk_canvas_item_set (waves[n], "height", ht, NULL);
- gtk_canvas_item_set (waves[n], "y", yoff + 2, NULL);
+ waves[n]->property_height() = ht;
+ waves[n]->property_y() = yoff + 2;
}
if ((height/wcnt) < NAME_HIGHLIGHT_SIZE) {
gain_line->set_height ((uint32_t) rint (height - NAME_HIGHLIGHT_SIZE));
reset_fade_shapes ();
- gtk_canvas_item_raise_to_top (name_text) ;
+ name_text->raise_to_top();
}
void
if (_height >= 100) {
gdouble wave_midpoint = (_height - NAME_HIGHLIGHT_SIZE) / 2.0;
- gtk_canvas_item_set (zero_line,
- "y1", wave_midpoint,
- "y2", wave_midpoint,
- NULL);
- gtk_canvas_item_show (zero_line);
+ zero_line->property_y1() = wave_midpoint;
+ zero_line->property_y2() = wave_midpoint;
+ zero_line->show();
} else {
- gtk_canvas_item_hide (zero_line);
+ zero_line->hide();
}
}
width = std::max ((jack_nframes_t) 64, width);
- GtkCanvasPoints* points;
+ Points* points;
double pwidth = width / samples_per_unit;
uint32_t npoints = std::min (gdk_screen_width(), (int) pwidth);
double h;
if (_height < 5) {
- gtk_canvas_item_hide (fade_in_shape);
- gtk_canvas_item_hide (fade_in_handle);
+ fade_in_shape->hide();
+ fade_in_handle->hide();
return;
}
handle_center = 3.0;
}
- gtk_canvas_item_set (fade_in_handle,
- "x1", handle_center - 3.0,
- "x2", handle_center + 3.0,
- NULL);
+ fade_in_handle->property_x1() = handle_center - 3.0;
+ fade_in_handle->property_x2() = handle_center + 3.0;
if (pwidth < 5) {
- gtk_canvas_item_hide (fade_in_shape);
+ fade_in_shape->hide();
return;
}
- gtk_canvas_item_show (fade_in_shape);
+ fade_in_shape->show();
float curve[npoints];
region.fade_in().get_vector (0, region.fade_in().back()->when, curve, npoints);
double xdelta = pwidth/npoints;
for (pi = 0, pc = 0; pc < npoints; ++pc) {
- points->coords[pi++] = 1 + (pc * xdelta);
- points->coords[pi++] = 2 + (h - (curve[pc] * h));
+ (*points)[pi].set_x(1 + (pc * xdelta));
+ (*points)[pi++].set_y(2 + (h - (curve[pc] * h)));
}
/* fold back */
- points->coords[pi++] = pwidth;
- points->coords[pi++] = 2;
+ (*points)[pi].set_x(pwidth);
+ (*points)[pi++].set_y(2);
- points->coords[pi++] = 1;
- points->coords[pi++] = 2;
+ (*points)[pi].set_x(1);
+ (*points)[pi++].set_y(2);
/* connect the dots ... */
- points->coords[pi++] = points->coords[0];
- points->coords[pi] = points->coords[1];
+ (*points)[pi] = (*points)[0];
- gtk_canvas_item_set (fade_in_shape, "points", points, NULL);
- gtk_canvas_points_unref (points);
+ fade_in_shape->property_points() = *points;
+ delete points;
}
void
width = std::max ((jack_nframes_t) 64, width);
- GtkCanvasPoints* points;
+ Points* points;
double pwidth = width / samples_per_unit;
uint32_t npoints = std::min (gdk_screen_width(), (int) pwidth);
double h;
if (_height < 5) {
- gtk_canvas_item_hide (fade_out_shape);
- gtk_canvas_item_hide (fade_out_handle);
+ fade_out_shape->hide();
+ fade_out_handle->hide();
return;
}
handle_center = 3.0;
}
- gtk_canvas_item_set (fade_out_handle,
- "x1", handle_center - 3.0,
- "x2", handle_center + 3.0,
- NULL);
+ fade_out_handle->property_x1() = handle_center - 3.0;
+ fade_out_handle->property_x2() = handle_center + 3.0;
/* don't show shape if its too small */
if (pwidth < 5) {
- gtk_canvas_item_hide (fade_out_shape);
+ fade_out_shape->hide();
return;
}
- gtk_canvas_item_show (fade_out_shape);
+ fade_out_shape->show();
float curve[npoints];
region.fade_out().get_vector (0, region.fade_out().back()->when, curve, npoints);
double xdelta = pwidth/npoints;
for (pi = 0, pc = 0; pc < npoints; ++pc) {
- points->coords[pi++] = _pixel_width - 1 - pwidth + (pc*xdelta);
- points->coords[pi++] = 2 + (h - (curve[pc] * h));
+ (*points)[pi].set_x(_pixel_width - 1 - pwidth + (pc*xdelta));
+ (*points)[pi++].set_y(2 + (h - (curve[pc] * h)));
}
/* fold back */
- points->coords[pi++] = _pixel_width;
- points->coords[pi++] = h;
+ (*points)[pi].set_x(_pixel_width);
+ (*points)[pi++].set_y(h);
- points->coords[pi++] = _pixel_width;
- points->coords[pi++] = 2;
+ (*points)[pi].set_x(_pixel_width);
+ (*points)[pi++].set_y(2);
/* connect the dots ... */
- points->coords[pi++] = points->coords[0];
- points->coords[pi] = points->coords[1];
+ (*points)[pi] = (*points)[0];
- gtk_canvas_item_set (fade_out_shape, "points", points, NULL);
- gtk_canvas_points_unref (points);
+ fade_out_shape->property_points() = *points;
+ delete points;
}
void
TimeAxisViewItem::set_samples_per_unit (spu);
for (uint32_t n=0; n < waves.size(); ++n) {
- gtk_canvas_item_set (waves[n], "samples_per_unit", spu, NULL);
+ waves[n]->property_samples_per_unit() = spu;
}
for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
AudioRegionView::set_amplitude_above_axis (gdouble spp)
{
for (uint32_t n=0; n < waves.size(); ++n) {
- gtk_canvas_item_set (waves[n], "amplitude_above_axis", spp, NULL);
+ waves[n]->property_amplitude_above_axis() = spp;
}
}
void
-AudioRegionView::compute_colors (GdkColor& basic_color)
+AudioRegionView::compute_colors (Gdk::Color& basic_color)
{
TimeAxisViewItem::compute_colors (basic_color);
uint32_t r, g, b, a;
TimeAxisViewItem::set_colors ();
gain_line->set_line_color (region.envelope_active() ? color_map[cGainLine] : color_map[cGainLineInactive]);
- gtk_canvas_item_set (sync_mark, "fill_color_rgba", fill_color, NULL);
+ sync_mark->property_fill_color_rgba() = fill_color;
for (uint32_t n=0; n < waves.size(); ++n) {
if (region.muted()) {
- gtk_canvas_item_set (waves[n], "wave_color", color_map[cMutedWaveForm], NULL);
+ waves[n]->property_wave_color() = color_map[cMutedWaveForm];
} else {
- gtk_canvas_item_set (waves[n], "wave_color", color_map[cWaveForm], NULL);
+ waves[n]->property_wave_color() = color_map[cWaveForm];
}
}
}
{
if (editor == 0) {
editor = new AudioRegionEditor (trackview.session(), region, *this);
- editor->realize ();
- trackview.editor.ensure_float (*editor);
+ // GTK2FIX : how to ensure float without realizing
+ // editor->realize ();
+ // trackview.editor.ensure_float (*editor);
}
editor->show_all ();
- editor->get_window().raise();
+ editor->get_window()->raise();
}
void
/* no sync mark - its the start of the region */
- gtk_canvas_item_hide (sync_mark);
+ sync_mark->hide();
} else {
/* no sync mark - its out of the bounds of the region */
- gtk_canvas_item_hide (sync_mark);
+ sync_mark->hide();
} else {
/* lets do it */
- GtkArg args[1];
- GtkCanvasPoints* points;
-
- args[0].name = X_("points");
+ Points points;
- gtk_object_getv (GTK_OBJECT(sync_mark), 1, args);
- points = static_cast<GtkCanvasPoints *> (GTK_VALUE_POINTER(args[0]));
+ //points = sync_mark->property_points().get_value();
double offset = sync_offset / samples_per_unit;
-
- points->coords[0] = offset - ((sync_mark_width-1)/2);
- points->coords[1] = 1;
-
- points->coords[2] = offset + (sync_mark_width-1)/2;
- points->coords[3] = 1;
-
- points->coords[4] = offset;
- points->coords[5] = sync_mark_width - 1;
-
- points->coords[6] = offset - ((sync_mark_width-1)/2);
- points->coords[7] = 1;
-
- gtk_canvas_item_show (sync_mark);
- gtk_canvas_item_set (sync_mark, "points", points, NULL);
+ points.push_back (Gnome::Art::Point (offset - ((sync_mark_width-1)/2), 1));
+ points.push_back (Gnome::Art::Point (offset + ((sync_mark_width-1)/2), 1));
+ points.push_back (Gnome::Art::Point (offset, sync_mark_width - 1));
+ points.push_back (Gnome::Art::Point (offset - ((sync_mark_width-1)/2), 1));
+ sync_mark->property_points().set_value (points);
+ sync_mark->show();
- gtk_canvas_points_unref (points);
}
}
}
if (((_flags & WaveformVisible) != yn)) {
if (yn) {
for (uint32_t n=0; n < waves.size(); ++n) {
- gtk_canvas_item_show (waves[n]);
+ waves[n]->show();
}
_flags |= WaveformVisible;
} else {
for (uint32_t n=0; n < waves.size(); ++n) {
- gtk_canvas_item_hide (waves[n]);
+ waves[n]->hide();
}
_flags &= ~WaveformVisible;
}
break;
}
- wave_caches.push_back (gtk_canvas_waveview_cache_new ());
+ wave_caches.push_back (WaveView::create_cache ());
if (wait_for_waves) {
- if (region.source(n).peaks_ready (bind (slot (*this, &AudioRegionView::peaks_ready_handler), n))) {
+ if (region.source(n).peaks_ready (bind (mem_fun(*this, &AudioRegionView::peaks_ready_handler), n))) {
create_one_wave (n, true);
} else {
create_zero_line = false;
}
if (create_zero_line) {
- zero_line = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_simpleline_get_type(),
- "x1", (gdouble) 1.0,
- "x2", (gdouble) (region.length() / samples_per_unit) - 1.0,
- "color_rgba", (guint) color_map[cZeroLine],
- NULL);
+ zero_line = new ArdourCanvas::SimpleLine (*group);
+ zero_line->property_x1() = (gdouble) 1.0;
+ zero_line->property_x2() = (gdouble) (region.length() / samples_per_unit) - 1.0;
+ zero_line->property_color_rgba() = (guint) color_map[cZeroLine];
manage_zero_line ();
}
}
uint32_t nchans = atv.get_diskstream()->n_channels();
uint32_t n;
uint32_t nwaves = std::min (nchans, region.n_channels());
-
gdouble ht;
+
if (trackview.height < NAME_HIGHLIGHT_SIZE) {
ht = ((trackview.height) / (double) nchans);
} else {
ht = ((trackview.height - NAME_HIGHLIGHT_SIZE) / (double) nchans);
}
+
gdouble yoff = which * ht;
- GtkCanvasItem *wave = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_waveview_get_type (),
- "data_src", (gpointer) ®ion,
- "cache", wave_caches[which],
- "cache_updater", (gboolean) true,
- "channel", (guint32) which,
- "length_function", (gpointer) region_length_from_c,
- "sourcefile_length_function",(gpointer) sourcefile_length_from_c,
- "peak_function", (gpointer) region_read_peaks_from_c,
- "x", 0.0,
- "y", yoff,
- "height", (double) ht,
- "samples_per_unit", samples_per_unit,
- "amplitude_above_axis", _amplitude_above_axis,
- "wave_color", (guint32) (region.muted() ? color_map[cMutedWaveForm] : color_map[cWaveForm]),
- "region_start",(guint32) region.start(),
- NULL);
-
+ WaveView *wave = new WaveView(*group);
+
+ wave->property_data_src() = (gpointer) ®ion;
+ wave->property_cache() = wave_caches[which];
+ wave->property_cache_updater() = true;
+ wave->property_channel() = which;
+ wave->property_length_function() = (gpointer) region_length_from_c;
+ wave->property_sourcefile_length_function() = (gpointer) sourcefile_length_from_c;
+ wave->property_peak_function() = (gpointer) region_read_peaks_from_c;
+ wave->property_x() = 0.0;
+ wave->property_y() = yoff;
+ wave->property_height() = (double) ht;
+ wave->property_samples_per_unit() = samples_per_unit;
+ wave->property_amplitude_above_axis() = _amplitude_above_axis;
+ wave->property_wave_color() = region.muted() ? color_map[cMutedWaveForm] : color_map[cWaveForm];
+ wave->property_region_start() = region.start();
+
if (!(_flags & WaveformVisible)) {
- gtk_canvas_item_hide (wave);
+ wave->hide();
}
/* note: calling this function is serialized by the lock
tmp_waves.clear ();
if (!zero_line) {
- zero_line = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_simpleline_get_type(),
- "x1", (gdouble) 1.0,
- "x2", (gdouble) (region.length() / samples_per_unit) - 1.0,
- "color_rgba", (guint) color_map[cZeroLine],
- NULL);
+ zero_line = new ArdourCanvas::SimpleLine (*group);
+ zero_line->property_x1() = (gdouble) 1.0;
+ zero_line->property_x2() = (gdouble) (region.length() / samples_per_unit) - 1.0;
+ zero_line->property_color_rgba() = (guint) color_map[cZeroLine];
manage_zero_line ();
}
}
void
AudioRegionView::peaks_ready_handler (uint32_t which)
{
- Gtkmmext::UI::instance()->call_slot (bind (slot (*this, &AudioRegionView::create_one_wave), which, false));
+ Gtkmm2ext::UI::instance()->call_slot (bind (mem_fun(*this, &AudioRegionView::create_one_wave), which, false));
}
void
-AudioRegionView::add_gain_point_event (GtkCanvasItem *item, GdkEvent *ev)
+AudioRegionView::add_gain_point_event (ArdourCanvas::Item *item, GdkEvent *ev)
{
double x, y;
x = ev->button.x;
y = ev->button.y;
- gtk_canvas_item_w2i (item, &x, &y);
+ item->w2i (x, y);
jack_nframes_t fx = trackview.editor.pixel_to_frame (x);
if (!region.envelope_active()) {
- trackview.session().add_undo( bind( slot(region, &AudioRegion::set_envelope_active), false) );
+ trackview.session().add_undo( bind( mem_fun(region, &AudioRegion::set_envelope_active), false) );
region.set_envelope_active(true);
- trackview.session().add_redo( bind( slot(region, &AudioRegion::set_envelope_active), true) );
+ trackview.session().add_redo( bind( mem_fun(region, &AudioRegion::set_envelope_active), true) );
}
region.envelope().add (fx, y);
}
void
-AudioRegionView::remove_gain_point_event (GtkCanvasItem *item, GdkEvent *ev)
+AudioRegionView::remove_gain_point_event (ArdourCanvas::Item *item, GdkEvent *ev)
{
- ControlPoint *cp = reinterpret_cast<ControlPoint *> (gtk_object_get_data(GTK_OBJECT(item), "control_point"));
+ ControlPoint *cp = reinterpret_cast<ControlPoint *> (item->get_data ("control_point"));
region.envelope().erase (cp->model);
}
}
if (yn != (bool) (_flags & WaveformRectified)) {
- for (vector<GtkCanvasItem *>::iterator wave = waves.begin(); wave != waves.end() ; ++wave) {
- gtk_canvas_item_set ((*wave), "rectified", (gboolean) yn, NULL);
+ for (vector<WaveView *>::iterator wave = waves.begin(); wave != waves.end() ; ++wave) {
+ (*wave)->property_rectified() = yn;
}
if (zero_line) {
if (yn) {
- gtk_canvas_item_hide (zero_line);
+ zero_line->hide();
} else {
- gtk_canvas_item_show (zero_line);
+ zero_line->show();
}
}
return;
}
- gtk_canvas_item_move (get_canvas_group(), x_delta, y_delta);
+ get_canvas_group()->move (x_delta, y_delta);
/* note: ghosts never leave their tracks so y_delta for them is always zero */
for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
- gtk_canvas_item_move ((*i)->group, x_delta, 0.0);
+ (*i)->group->move (x_delta, 0.0);
}
}
break;
}
- GtkCanvasItem *wave = gtk_canvas_item_new (GTK_CANVAS_GROUP(ghost->group),
- gtk_canvas_waveview_get_type (),
- "data_src", (gpointer) ®ion,
- "cache", wave_caches[n],
- "cache_updater", (gboolean) false,
- "channel", (guint32) n,
- "length_function", (gpointer) region_length_from_c,
- "sourcefile_length_function",(gpointer) sourcefile_length_from_c,
- "peak_function", (gpointer) region_read_peaks_from_c,
- "x", 0.0,
- "samples_per_unit", samples_per_unit,
- "amplitude_above_axis", _amplitude_above_axis,
- "wave_color", color_map[cGhostTrackWave],
- "region_start", (guint32) region.start(),
- NULL);
+ WaveView *wave = new WaveView(*ghost->group);
+
+ wave->property_data_src() = ®ion;
+ wave->property_cache() = wave_caches[n];
+ wave->property_cache_updater() = false;
+ wave->property_channel() = n;
+ wave->property_length_function() = (gpointer)region_length_from_c;
+ wave->property_sourcefile_length_function() = (gpointer) sourcefile_length_from_c;
+ wave->property_peak_function() = (gpointer) region_read_peaks_from_c;
+ wave->property_x() = 0.0;
+ wave->property_samples_per_unit() = samples_per_unit;
+ wave->property_amplitude_above_axis() = _amplitude_above_axis;
+ wave->property_wave_color() = color_map[cGhostTrackWave];
+ wave->property_region_start() = region.start();
-
ghost->waves.push_back(wave);
}
ghost->set_duration (region.length() / samples_per_unit);
ghosts.push_back (ghost);
- ghost->GoingAway.connect (slot (*this, &AudioRegionView::remove_ghost));
+ ghost->GoingAway.connect (mem_fun(*this, &AudioRegionView::remove_ghost));
return ghost;
}
UINT_TO_RGBA(fade_color,&r,&g,&b,&a);
a=255;
- gtk_canvas_item_set (fade_in_handle, "fill_color_rgba", RGBA_TO_UINT(r,g,b,a), NULL);
- gtk_canvas_item_set (fade_out_handle, "fill_color_rgba", RGBA_TO_UINT(r,g,b,a), NULL);
+ fade_in_handle->property_fill_color_rgba() = RGBA_TO_UINT(r,g,b,a);
+ fade_out_handle->property_fill_color_rgba() = RGBA_TO_UINT(r,g,b,a);
}
void
UINT_TO_RGBA(fade_color,&r,&g,&b,&a);
a=0;
- gtk_canvas_item_set (fade_in_handle, "fill_color_rgba", RGBA_TO_UINT(r,g,b,a), NULL);
- gtk_canvas_item_set (fade_out_handle, "fill_color_rgba", RGBA_TO_UINT(r,g,b,a), NULL);
+ fade_in_handle->property_fill_color_rgba() = RGBA_TO_UINT(r,g,b,a);
+ fade_out_handle->property_fill_color_rgba() = RGBA_TO_UINT(r,g,b,a);
}
void
for (uint32_t n = 0; n < waves.size(); ++n) {
// TODO: something else to let it know the channel
- gtk_canvas_item_set (waves[n], "data_src", ®ion, NULL);
+ waves[n]->property_data_src() = ®ion;
}
for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
(*i)->set_duration (unit_length);
- for (vector<GtkCanvasItem*>::iterator w = (*i)->waves.begin(); w != (*i)->waves.end(); ++w) {
- gtk_canvas_item_set ((*w), "data_src", ®ion, NULL);
+ for (vector<WaveView*>::iterator w = (*i)->waves.begin(); w != (*i)->waves.end(); ++w) {
+ (*w)->property_data_src() = ®ion;
}
}