}
bool
-AddRouteDialog::channel_separator (const Glib::RefPtr<Gtk::TreeModel> &m, const Gtk::TreeModel::iterator &i)
+AddRouteDialog::channel_separator (const Glib::RefPtr<Gtk::TreeModel> &, const Gtk::TreeModel::iterator &i)
{
channel_combo.set_active (i);
}
bool
-AddRouteDialog::route_separator (const Glib::RefPtr<Gtk::TreeModel> &m, const Gtk::TreeModel::iterator &i)
+AddRouteDialog::route_separator (const Glib::RefPtr<Gtk::TreeModel> &, const Gtk::TreeModel::iterator &i)
{
route_group_combo.set_active (i);
}
void
-AnalysisWindow::track_list_row_changed(const Gtk::TreeModel::Path& path, const Gtk::TreeModel::iterator& iter)
+AnalysisWindow::track_list_row_changed(const Gtk::TreeModel::Path& /*path*/, const Gtk::TreeModel::iterator& /*iter*/)
{
if (track_list_ready) {
fft_graph.redraw();
}
void
-AnalysisWindow::analyze_data (Gtk::Button *button)
+AnalysisWindow::analyze_data (Gtk::Button */*button*/)
{
track_list_ready = false;
{
}
gboolean
-ARDOUR_UI::configure_handler (GdkEventConfigure* conf)
+ARDOUR_UI::configure_handler (GdkEventConfigure* /*conf*/)
{
if (have_configure_timeout) {
last_configure_time = get_microseconds();
}
gint
-ARDOUR_UI::session_menu (GdkEventButton *ev)
+ARDOUR_UI::session_menu (GdkEventButton */*ev*/)
{
session_popup_menu->popup (0, 0);
return TRUE;
}
void
-ARDOUR_UI::recent_session_row_activated (const TreePath& path, TreeViewColumn* col)
+ARDOUR_UI::recent_session_row_activated (const TreePath& /*path*/, TreeViewColumn* /*col*/)
{
session_selector_window->response (RESPONSE_ACCEPT);
}
}
void
-ARDOUR_UI::loading_message (const std::string& msg)
+ARDOUR_UI::loading_message (const std::string& /*msg*/)
{
// show_splash ();
// splash->message (msg);
}
void
-ARDOUR_UI::about_signal_response(int response)
+ARDOUR_UI::about_signal_response (int /*response*/)
{
hide_about();
}
}
void
-ARDOUR_UI::disk_speed_dialog_gone (int ignored_response, MessageDialog* msg)
+ARDOUR_UI::disk_speed_dialog_gone (int /*ignored_response*/, MessageDialog* msg)
{
have_disk_speed_dialog_displayed = false;
delete msg;
}
gint
-ARDOUR_UI::exit_on_main_window_close (GdkEventAny *ev)
+ARDOUR_UI::exit_on_main_window_close (GdkEventAny * /*ev*/)
{
#ifdef TOP_MENUBAR
/* just hide the window, and return - the top menu stays up */
}
void
-ARDOUR_UI::handle_locations_change (Location* ignored)
+ARDOUR_UI::handle_locations_change (Location *)
{
if (session) {
if (session->locations()->num_range_markers()) {
}
bool
-AudioClock::drop_focus_handler (GdkEventFocus* ignored)
+AudioClock::drop_focus_handler (GdkEventFocus*)
{
Keyboard::magic_widget_drop_focus ();
return false;
}
void
-AudioClock::set_frames (nframes_t when, bool force)
+AudioClock::set_frames (nframes_t when, bool /*force*/)
{
char buf[32];
snprintf (buf, sizeof (buf), "%u", when);
bool
-AudioClock::field_key_press_event (GdkEventKey *ev, Field field)
+AudioClock::field_key_press_event (GdkEventKey */*ev*/, Field /*field*/)
{
/* all key activity is handled on key release */
return true;
}
bool
-AudioClock::field_focus_in_event (GdkEventFocus *ev, Field field)
+AudioClock::field_focus_in_event (GdkEventFocus */*ev*/, Field field)
{
key_entry_state = 0;
}
bool
-AudioClock::field_focus_out_event (GdkEventFocus *ev, Field field)
+AudioClock::field_focus_out_event (GdkEventFocus */*ev*/, Field field)
{
switch (field) {
}
bool
-AudioClock::field_button_press_event (GdkEventButton *ev, Field field)
+AudioClock::field_button_press_event (GdkEventButton *ev, Field /*field*/)
{
- if (session == 0) return false;
+ if (session == 0) {
+ return false;
+ }
nframes_t frames = 0;
}
gint
-AudioRegionEditor::bpressed (GdkEventButton* ev, Gtk::SpinButton* but, void (AudioRegionEditor::*pmf)())
+AudioRegionEditor::bpressed (GdkEventButton* ev, Gtk::SpinButton* /*but*/, void (AudioRegionEditor::*/*pmf*/)())
{
switch (ev->button) {
case 1:
}
gint
-AudioRegionEditor::breleased (GdkEventButton* ev, Gtk::SpinButton* but, void (AudioRegionEditor::*pmf)())
+AudioRegionEditor::breleased (GdkEventButton* /*ev*/, Gtk::SpinButton* /*but*/, void (AudioRegionEditor::*pmf)())
{
if (spin_arrow_grab) {
(this->*pmf)();
}
void
-AudioRegionView::create_one_wave (uint32_t which, bool direct)
+AudioRegionView::create_one_wave (uint32_t which, bool /*direct*/)
{
//cerr << "AudioRegionView::create_one_wave() called which: " << which << " this: " << this << endl;//DEBUG
RouteTimeAxisView& atv (*(dynamic_cast<RouteTimeAxisView*>(&trackview))); // ick
}
void
-AudioRegionView::remove_gain_point_event (ArdourCanvas::Item *item, GdkEvent *ev)
+AudioRegionView::remove_gain_point_event (ArdourCanvas::Item *item, GdkEvent */*ev*/)
{
ControlPoint *cp = reinterpret_cast<ControlPoint *> (item->get_data ("control_point"));
audio_region()->envelope()->erase (cp->model());
}
void
-AutomationLine::get_inverted_selectables (Selection&, list<Selectable*>& results)
+AutomationLine::get_inverted_selectables (Selection&, list<Selectable*>& /*results*/)
{
// hmmm ....
}
}
void
-AutomationLine::change_model (AutomationList::iterator i, double x, double y)
+AutomationLine::change_model (AutomationList::iterator /*i*/, double /*x*/, double /*y*/)
{
}
}
void
-AutomationRegionView::init (Gdk::Color const & basic_color, bool wfd)
+AutomationRegionView::init (Gdk::Color const & basic_color, bool /*wfd*/)
{
_enable_display = false;
}
void
-AutomationRegionView::add_automation_event (GdkEvent* event, nframes_t when, double y)
+AutomationRegionView::add_automation_event (GdkEvent* /*event*/, nframes_t when, double y)
{
if (!_line) {
boost::shared_ptr<Evoral::Control> c = _region->control(_parameter, true);
RegionView*
-AutomationStreamView::add_region_view_internal (boost::shared_ptr<Region> region, bool wfd, bool recording)
+AutomationStreamView::add_region_view_internal (boost::shared_ptr<Region> region, bool wfd, bool /*recording*/)
{
if ( ! region) {
cerr << "No region" << endl;
}
void
-AutomationStreamView::update_rec_regions (nframes_t start, nframes_t dur)
+AutomationStreamView::update_rec_regions (nframes_t /*start*/, nframes_t /*dur*/)
{
}
}
void
-AutomationTimeAxisView::add_automation_event (ArdourCanvas::Item* item, GdkEvent* event, nframes_t when, double y)
+AutomationTimeAxisView::add_automation_event (ArdourCanvas::Item* /*item*/, GdkEvent* /*event*/, nframes_t when, double y)
{
if (!_line)
return;
void get_selectables (nframes_t start, nframes_t end, double top, double bot, std::list<Selectable *>&);
void get_inverted_selectables (Selection&, std::list<Selectable*>& results);
- void show_timestretch (nframes_t start, nframes_t end) {}
+ void show_timestretch (nframes_t /*start*/, nframes_t /*end*/) {}
void hide_timestretch () {}
/* editing operations */
return (dim == OTHER);
}
-BundleEditor::BundleEditor (Session& session, boost::shared_ptr<UserBundle> bundle, bool add)
+BundleEditor::BundleEditor (Session& session, boost::shared_ptr<UserBundle> bundle, bool /*add*/)
: ArdourDialog (_("Edit Bundle")), _matrix (session, bundle), _bundle (bundle)
{
Gtk::Table* t = new Gtk::Table (3, 2);
}
bool
-CanvasFlag::on_event(GdkEvent* ev)
+CanvasFlag::on_event(GdkEvent* /*ev*/)
{
return false;
}
GParamSpec *pspec)
{
+ (void) pspec;
+
GnomeCanvasSimpleLine *simpleline;
int update = FALSE;
int bounds_changed = FALSE;
static double
gnome_canvas_simpleline_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item)
{
+ (void) cx;
+ (void) cy;
+
GnomeCanvasSimpleLine *simpleline;
double x1, y1, x2, y2;
double dx, dy;
GParamSpec *pspec)
{
+ (void) pspec;
+
GnomeCanvasSimpleRect *simplerect;
int update = FALSE;
int bounds_changed = FALSE;
static double
gnome_canvas_simplerect_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item)
{
+ (void) cx;
+ (void) cy;
+
GnomeCanvasSimpleRect *simplerect;
double x1, y1, x2, y2;
double dx, dy;
GParamSpec *pspec)
{
+ (void) pspec;
+
GnomeCanvasItem *item;
GnomeCanvasWaveView *waveview;
int redraw = FALSE;
static double
gnome_canvas_waveview_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item)
{
+ (void) item;
+ (void) x;
+ (void) y;
+ (void) cx;
+ (void) cy;
+ (void) actual_item;
+
/* XXX for now, point is never inside the wave
GnomeCanvasWaveView *waveview;
double x1, y1, x2, y2;
set_visible (false);
}
-ControlPoint::ControlPoint (const ControlPoint& other, bool dummy_arg_to_force_special_copy_constructor)
+ControlPoint::ControlPoint (const ControlPoint& other, bool /*dummy_arg_to_force_special_copy_constructor*/)
: _line (other._line)
{
if (&other == this) {
}
void
-CrossfadeEditor::canvas_allocation (Gtk::Allocation& alloc)
+CrossfadeEditor::canvas_allocation (Gtk::Allocation& /*alloc*/)
{
if (toplevel) {
toplevel->property_x1() = 0.0;
void
-CrossfadeEditor::xfade_changed (Change ignored)
+CrossfadeEditor::xfade_changed (Change)
{
set (xfade->fade_in(), In);
set (xfade->fade_out(), Out);
}
bool
-CrossfadeEditor::on_key_press_event (GdkEventKey *ev)
+CrossfadeEditor::on_key_press_event (GdkEventKey */*ev*/)
{
return true;
}
}
bool
-Editor::deferred_control_scroll (nframes64_t target)
+Editor::deferred_control_scroll (nframes64_t /*target*/)
{
session->request_locate (*_control_scroll_target, session->transport_rolling());
// reset for next stream
}
Menu*
-Editor::build_track_context_menu (nframes64_t ignored)
+Editor::build_track_context_menu (nframes64_t)
{
using namespace Menu_Helpers;
}
Menu*
-Editor::build_track_bus_context_menu (nframes64_t ignored)
+Editor::build_track_bus_context_menu (nframes64_t)
{
using namespace Menu_Helpers;
}
Menu*
-Editor::build_track_selection_context_menu (nframes64_t ignored)
+Editor::build_track_selection_context_menu (nframes64_t)
{
using namespace Menu_Helpers;
MenuList& edit_items = track_selection_context_menu.items();
* @param edit_items List to add the items to.
*/
void
-Editor::add_crossfade_context_items (AudioStreamView* view, boost::shared_ptr<Crossfade> xfade, Menu_Helpers::MenuList& edit_items, bool many)
+Editor::add_crossfade_context_items (AudioStreamView* /*view*/, boost::shared_ptr<Crossfade> xfade, Menu_Helpers::MenuList& edit_items, bool many)
{
using namespace Menu_Helpers;
Menu *xfade_menu = manage (new Menu);
int
Editor::convert_drop_to_paths (
vector<ustring>& paths,
- const RefPtr<Gdk::DragContext>& context,
- gint x,
- gint y,
+ const RefPtr<Gdk::DragContext>& /*context*/,
+ gint /*x*/,
+ gint /*y*/,
const SelectionData& data,
- guint info,
- guint time)
+ guint /*info*/,
+ guint /*time*/)
{
if (session == 0) {
return -1;
}
void
-Editor::detach_tearoff (Box* b, Window* w)
+Editor::detach_tearoff (Box* /*b*/, Window* /*w*/)
{
if (tools_tearoff->torn_off() &&
mouse_mode_tearoff->torn_off()) {
}
void
-Editor::reattach_tearoff (Box* b, Window* w, int32_t n)
+Editor::reattach_tearoff (Box* /*b*/, Window* /*w*/, int32_t /*n*/)
{
if (toolbar_frame.get_parent() == 0) {
top_hbox.pack_end (toolbar_frame);
}
void
-Editor::mapped_clear_playlist (RouteTimeAxisView& atv, uint32_t sz)
+Editor::mapped_clear_playlist (RouteTimeAxisView& atv, uint32_t /*sz*/)
{
atv.clear_playlist ();
}
}
void
-Editor::hide_track_in_display (TimeAxisView& tv, bool temponly)
+Editor::hide_track_in_display (TimeAxisView& tv, bool /*temponly*/)
{
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (&tv);
int
Editor::add_sources (vector<Glib::ustring> paths, SourceList& sources, nframes64_t& pos, ImportMode mode,
- int target_regions, int target_tracks, boost::shared_ptr<Track>& track, bool add_channel_suffix)
+ int target_regions, int target_tracks, boost::shared_ptr<Track>& track, bool /*add_channel_suffix*/)
{
vector<boost::shared_ptr<Region> > regions;
ustring region_name;
}
gint
-Editor::import_progress_timeout (void *arg)
+Editor::import_progress_timeout (void */*arg*/)
{
bool reset = false;
}
bool
-Editor::track_canvas_map_handler (GdkEventAny* ev)
+Editor::track_canvas_map_handler (GdkEventAny* /*ev*/)
{
track_canvas->get_window()->set_cursor (*current_canvas_cursor);
return false;
}
void
-Editor::drop_regions (const RefPtr<Gdk::DragContext>& context,
- int x, int y,
- const SelectionData& data,
- guint info, guint time)
+Editor::drop_regions (const RefPtr<Gdk::DragContext>& /*context*/,
+ int /*x*/, int /*y*/,
+ const SelectionData& /*data*/,
+ guint /*info*/, guint /*time*/)
{
assert (_drag);
_drag->end_grab (0);
}
bool
-Editor::left_track_canvas (GdkEventCrossing *ev)
+Editor::left_track_canvas (GdkEventCrossing */*ev*/)
{
set_entered_track (0);
set_entered_regionview (0);
}
bool
-Editor::entered_track_canvas (GdkEventCrossing *ev)
+Editor::entered_track_canvas (GdkEventCrossing */*ev*/)
{
reset_canvas_action_sensitivity (true);
return FALSE;
}
bool
-Editor::track_canvas_button_press_event (GdkEventButton *event)
+Editor::track_canvas_button_press_event (GdkEventButton */*event*/)
{
selection->clear ();
track_canvas->grab_focus();
}
bool
-Editor::track_canvas_motion_notify_event (GdkEventMotion *event)
+Editor::track_canvas_motion_notify_event (GdkEventMotion */*event*/)
{
int x, y;
/* keep those motion events coming */
}
bool
-Editor::canvas_marker_event (GdkEvent *event, ArdourCanvas::Item* item, Marker* marker)
+Editor::canvas_marker_event (GdkEvent *event, ArdourCanvas::Item* item, Marker* /*marker*/)
{
return typed_event (item, event, MarkerItem);
}
}
bool
-Editor::canvas_tempo_marker_event (GdkEvent *event, ArdourCanvas::Item* item, TempoMarker* marker)
+Editor::canvas_tempo_marker_event (GdkEvent *event, ArdourCanvas::Item* item, TempoMarker* /*marker*/)
{
return typed_event (item, event, TempoMarkerItem);
}
bool
-Editor::canvas_meter_marker_event (GdkEvent *event, ArdourCanvas::Item* item, MeterMarker* marker)
+Editor::canvas_meter_marker_event (GdkEvent *event, ArdourCanvas::Item* item, MeterMarker* /*marker*/)
{
return typed_event (item, event, MeterMarkerItem);
}
}
bool
-Editor::track_canvas_drag_motion (Glib::RefPtr<Gdk::DragContext> const & c, int x, int y, guint time)
+Editor::track_canvas_drag_motion (Glib::RefPtr<Gdk::DragContext> const & /*c*/, int x, int y, guint /*time*/)
{
double wx;
double wy;
}
void
-RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred)
+RegionMoveDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
{
bool nocommit = true;
vector<RegionView*> copies;
void
-RegionInsertDrag::finished (GdkEvent* event, bool movement_occurred)
+RegionInsertDrag::finished (GdkEvent* /*event*/, bool /*movement_occurred*/)
{
_editor->update_canvas_now ();
};
void
-RegionSpliceDrag::motion (GdkEvent* event, bool)
+RegionSpliceDrag::motion (GdkEvent* /*event*/, bool)
{
RouteTimeAxisView* tv;
layer_t layer;
}
void
-RegionSpliceDrag::finished (GdkEvent* event, bool)
+RegionSpliceDrag::finished (GdkEvent* /*event*/, bool)
{
}
void
-RegionCreateDrag::motion (GdkEvent* event, bool first_move)
+RegionCreateDrag::motion (GdkEvent* /*event*/, bool first_move)
{
if (first_move) {
// TODO: create region-create-drag region view here
void
-RegionGainDrag::motion (GdkEvent* event, bool)
+RegionGainDrag::motion (GdkEvent* /*event*/, bool)
{
}
void
-ControlPointDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
+ControlPointDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
{
Drag::start_grab (event, _editor->fader_cursor);
}
void
-LineDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
+LineDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
{
_line = reinterpret_cast<AutomationLine*> (_item->get_data ("line"));
assert (_line);
}
void
-TimeFXDrag::finished (GdkEvent* event, bool movement_occurred)
+TimeFXDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
{
_primary->get_time_axis_view().hide_timestretch ();
}
void
-ScrubDrag::motion (GdkEvent* event, bool)
+ScrubDrag::motion (GdkEvent* /*event*/, bool)
{
_editor->scrub ();
}
void
-ScrubDrag::finished (GdkEvent* event, bool movement_occurred)
+ScrubDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
{
if (movement_occurred && _editor->session) {
/* make sure we stop */
using namespace PBD;
void
-Editor::hscrollbar_allocate (Gtk::Allocation &alloc)
+Editor::hscrollbar_allocate (Gtk::Allocation &)
{
}
bool
-Editor::hscrollbar_button_press (GdkEventButton *ev)
+Editor::hscrollbar_button_press (GdkEventButton *)
{
_dragging_hscrollbar = true;
return false;
}
bool
-Editor::hscrollbar_button_release (GdkEventButton *ev)
+Editor::hscrollbar_button_release (GdkEventButton *)
{
_dragging_hscrollbar = false;
}
int
-Editor::get_prefix (float& val, bool& was_floating)
+Editor::get_prefix (float& /*val*/, bool& was_floating)
{
was_floating = false;
return 1;
}
void
-Editor::remove_marker (ArdourCanvas::Item& item, GdkEvent* event)
+Editor::remove_marker (ArdourCanvas::Item& item, GdkEvent*)
{
Marker* marker;
bool is_start;
}
void
-Editor::new_transport_marker_context_menu (GdkEventButton* ev, ArdourCanvas::Item* item)
+Editor::new_transport_marker_context_menu (GdkEventButton* ev, ArdourCanvas::Item*)
{
if (new_transport_marker_menu == 0) {
build_new_transport_marker_menu ();
}
void
-Editor::transport_marker_context_menu (GdkEventButton* ev, ArdourCanvas::Item* item)
+Editor::transport_marker_context_menu (GdkEventButton* ev, ArdourCanvas::Item*)
{
if (transport_marker_menu == 0) {
build_range_marker_menu (true);
}
void
-Editor::set_midi_edit_cursor (MidiEditMode m)
+Editor::set_midi_edit_cursor (MidiEditMode)
{
switch (midi_edit_mode) {
case MidiEditPencil:
}
void
-Editor::button_selection (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
+Editor::button_selection (ArdourCanvas::Item* /*item*/, GdkEvent* event, ItemType item_type)
{
/* in object/audition/timefx/gain-automation mode,
any button press sets the selection if the object
}
bool
-Editor::enter_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
+Editor::enter_handler (ArdourCanvas::Item* item, GdkEvent* /*event*/, ItemType item_type)
{
ControlPoint* cp;
Marker * marker;
}
bool
-Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
+Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent* /*event*/, ItemType item_type)
{
AutomationLine* al;
ControlPoint* cp;
}
bool
-Editor::motion_handler (ArdourCanvas::Item* item, GdkEvent* event, bool from_autoscroll)
+Editor::motion_handler (ArdourCanvas::Item* /*item*/, GdkEvent* event, bool from_autoscroll)
{
if (event->motion.is_hint) {
gint x, y;
}
void
-Editor::remove_gain_control_point (ArdourCanvas::Item*item, GdkEvent* event)
+Editor::remove_gain_control_point (ArdourCanvas::Item*item, GdkEvent* /*event*/)
{
ControlPoint* control_point;
}
void
-Editor::remove_control_point (ArdourCanvas::Item* item, GdkEvent* event)
+Editor::remove_control_point (ArdourCanvas::Item* item, GdkEvent* /*event*/)
{
ControlPoint* control_point;
}
void
-Editor::hide_marker (ArdourCanvas::Item* item, GdkEvent* event)
+Editor::hide_marker (ArdourCanvas::Item* item, GdkEvent* /*event*/)
{
Marker* marker;
bool is_start;
gint
-Editor::mouse_rename_region (ArdourCanvas::Item* item, GdkEvent* event)
+Editor::mouse_rename_region (ArdourCanvas::Item* /*item*/, GdkEvent* /*event*/)
{
using namespace Gtkmm2ext;
* the section of the clicked region that lies within the time range.
*/
void
-Editor::start_selection_grab (ArdourCanvas::Item* item, GdkEvent* event)
+Editor::start_selection_grab (ArdourCanvas::Item* /*item*/, GdkEvent* event)
{
if (clicked_regionview == 0) {
return;
}
boost::shared_ptr<Region>
-Editor::select_region_for_operation (int dir, TimeAxisView **tv)
+Editor::select_region_for_operation (int /*dir*/, TimeAxisView **tv)
{
RegionView* rv;
boost::shared_ptr<Region> region;
}
void
-Editor::temporal_zoom_by_frame (nframes64_t start, nframes64_t end, const string & op)
+Editor::temporal_zoom_by_frame (nframes64_t start, nframes64_t end, const string & /*op*/)
{
if (!session) return;
}
gint
-Editor::freeze_progress_timeout (void *arg)
+Editor::freeze_progress_timeout (void */*arg*/)
{
interthread_progress_bar.set_fraction (current_interthread_info->progress);
return !(current_interthread_info->done || current_interthread_info->cancel);
}
bool
-EditorRegions::key_press (GdkEventKey* ev)
+EditorRegions::key_press (GdkEventKey* /*ev*/)
{
return false;
}
}
bool
-EditorRegions::selection_filter (const RefPtr<TreeModel>& model, const TreeModel::Path& path, bool yn)
+EditorRegions::selection_filter (const RefPtr<TreeModel>& model, const TreeModel::Path& path, bool /*yn*/)
{
/* not possible to select rows that do not represent regions, like "Hidden" */
}
void
-EditorRouteGroups::row_change (const Gtk::TreeModel::Path& path,const Gtk::TreeModel::iterator& iter)
+EditorRouteGroups::row_change (const Gtk::TreeModel::Path&, const Gtk::TreeModel::iterator& iter)
{
RouteGroup* group;
}
void
-EditorRoutes::route_deleted (Gtk::TreeModel::Path const & path)
+EditorRoutes::route_deleted (Gtk::TreeModel::Path const &)
{
/* this could require an order reset & sync */
_session->set_remote_control_ids();
void
-EditorRoutes::changed (Gtk::TreeModel::Path const & path, Gtk::TreeModel::iterator const & iter)
+EditorRoutes::changed (Gtk::TreeModel::Path const &, Gtk::TreeModel::iterator const &)
{
/* never reset order keys because of a property change */
_redisplay_does_not_reset_order_keys = true;
}
void
-EditorRoutes::reordered (TreeModel::Path const & path, TreeModel::iterator const & iter, int* what)
+EditorRoutes::reordered (TreeModel::Path const &, TreeModel::iterator const &, int* /*what*/)
{
redisplay ();
}
void
-EditorRoutes::hide_all_tracks (bool with_select)
+EditorRoutes::hide_all_tracks (bool /*with_select*/)
{
TreeModel::Children rows = _model->children();
TreeModel::Children::iterator i;
}
void
-EditorRoutes::track_list_reorder (Gtk::TreeModel::Path const & path, Gtk::TreeModel::iterator const & iter, int* new_order)
+EditorRoutes::track_list_reorder (Gtk::TreeModel::Path const &, Gtk::TreeModel::iterator const &, int* /*new_order*/)
{
_redisplay_does_not_sync_order_keys = true;
_session->set_remote_control_ids();
}
gint
-Editor::metric_get_smpte (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
+Editor::metric_get_smpte (GtkCustomRulerMark **marks, gdouble lower, gdouble /*upper*/, gint /*maxchars*/)
{
nframes_t pos;
nframes64_t spacer;
}
gint
-Editor::metric_get_bbt (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
+Editor::metric_get_bbt (GtkCustomRulerMark **marks, gdouble lower, gdouble /*upper*/, gint /*maxchars*/)
{
if (session == 0) {
return 0;
}
gint
-Editor::metric_get_frames (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
+Editor::metric_get_frames (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint /*maxchars*/)
{
nframes64_t mark_interval;
nframes64_t pos;
}
gint
-Editor::metric_get_minsec (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
+Editor::metric_get_minsec (GtkCustomRulerMark **marks, gdouble lower, gdouble /*upper*/, gint /*maxchars*/)
{
nframes64_t pos;
nframes64_t spacer;
}
bool
-Editor::set_selected_control_point_from_click (Selection::Operation op, bool no_remove)
+Editor::set_selected_control_point_from_click (Selection::Operation op, bool /*no_remove*/)
{
if (!clicked_control_point) {
return false;
}
void
-Editor::mapped_get_equivalent_regions (RouteTimeAxisView& tv, uint32_t ignored, RegionView * basis, vector<RegionView*>* all_equivs) const
+Editor::mapped_get_equivalent_regions (RouteTimeAxisView& tv, uint32_t, RegionView * basis, vector<RegionView*>* all_equivs) const
{
boost::shared_ptr<Playlist> pl;
vector<boost::shared_ptr<Region> > results;
bool
-Editor::set_selected_regionview_from_click (bool press, Selection::Operation op, bool no_track_remove)
+Editor::set_selected_regionview_from_click (bool press, Selection::Operation op, bool /*no_track_remove*/)
{
vector<RegionView*> all_equivalent_regions;
bool commit = false;
}
bool
-Editor::set_selected_regionview_from_map_event (GdkEventAny* ev, StreamView* sv, boost::weak_ptr<Region> weak_r)
+Editor::set_selected_regionview_from_map_event (GdkEventAny* /*ev*/, StreamView* sv, boost::weak_ptr<Region> weak_r)
{
RegionView* rv;
boost::shared_ptr<Region> r (weak_r.lock());
}
void
-Editor::select_all_selectables_between (bool within)
+Editor::select_all_selectables_between (bool /*within*/)
{
nframes64_t start;
nframes64_t end;
}
}
-static bool jack_server_filter(const string& str, void *arg)
+static bool jack_server_filter(const string& str, void */*arg*/)
{
return str == "jackd" || str == "jackdmp";
}
}
void
-ExportFormatDialog::show_ogg_enconding_options (boost::shared_ptr<ARDOUR::ExportFormatOggVorbis> ptr)
+ExportFormatDialog::show_ogg_enconding_options (boost::shared_ptr<ARDOUR::ExportFormatOggVorbis> /*ptr*/)
{
encoding_options_label.set_label (_("Ogg Vorbis options"));
}
bool
-FFTGraph::on_expose_event (GdkEventExpose* event)
+FFTGraph::on_expose_event (GdkEventExpose* /*event*/)
{
redraw();
return true;
}
gint
-GainMeterBase::meter_release(GdkEventButton* ev)
+GainMeterBase::meter_release(GdkEventButton*)
{
if(!ignore_toggle){
if (wait_for_release){
}
gint
-GainMeterBase::start_gain_touch (GdkEventButton* ev)
+GainMeterBase::start_gain_touch (GdkEventButton*)
{
_amp->gain_control()->start_touch ();
return FALSE;
}
gint
-GainMeterBase::end_gain_touch (GdkEventButton* ev)
+GainMeterBase::end_gain_touch (GdkEventButton*)
{
_amp->gain_control()->stop_touch ();
return FALSE;
}
-static void integer_printer (char buf[32], Adjustment &adj, void *arg)
+static void integer_printer (char buf[32], Adjustment &adj, void */*arg*/)
{
snprintf (buf, 32, "%.0f", adj.get_value());
}
}
void
-GenericPluginUI::astate_clicked (ControlUI* cui, uint32_t port)
+GenericPluginUI::astate_clicked (ControlUI* cui, uint32_t /*port*/)
{
using namespace Menu_Helpers;
}
bool
-GenericPluginUI::start_updating (GdkEventAny* ignored)
+GenericPluginUI::start_updating (GdkEventAny*)
{
if (output_controls.size() > 0 ) {
screen_update_connection.disconnect();
}
bool
-GenericPluginUI::stop_updating (GdkEventAny* ignored)
+GenericPluginUI::stop_updating (GdkEventAny*)
{
if (output_controls.size() > 0 ) {
screen_update_connection.disconnect();
}
void
-MidiGhostRegion::set_samples_per_unit (double spu)
+MidiGhostRegion::set_samples_per_unit (double /*spu*/)
{
}
}
void
-MidiGhostRegion::add_hit(ArdourCanvas::CanvasHit* h)
+MidiGhostRegion::add_hit(ArdourCanvas::CanvasHit* /*h*/)
{
//events.push_back(new Hit(h, group));
}
static gint
default_metric_get_marks (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
{
+ (void) marks;
+ (void) lower;
+ (void) upper;
+ (void) maxchars;
+
return 0;
}
const GValue *value,
GParamSpec *pspec)
{
+ (void) pspec;
+
GtkCustomRuler *ruler = GTK_CUSTOM_RULER (object);
switch (prop_id)
return (dim == _other);
}
-IOSelectorWindow::IOSelectorWindow (ARDOUR::Session& session, boost::shared_ptr<ARDOUR::IO> io, bool can_cancel)
+IOSelectorWindow::IOSelectorWindow (ARDOUR::Session& session, boost::shared_ptr<ARDOUR::IO> io, bool /*can_cancel*/)
: _selector (session, io)
{
set_name ("IOSelectorWindow2");
}
bool
-Keyboard::enter_window (GdkEventCrossing *ev, Gtk::Window* win)
+Keyboard::enter_window (GdkEventCrossing *, Gtk::Window* win)
{
current_window = win;
return false;
}
bool
-Keyboard::leave_window (GdkEventCrossing *ev, Gtk::Window* win)
+Keyboard::leave_window (GdkEventCrossing *ev, Gtk::Window* /*win*/)
{
if (ev) {
switch (ev->detail) {
static void
-accel_map_changed (GtkAccelMap* map,
- gchar* path,
- guint key,
- GdkModifierType mod,
- gpointer arg)
+accel_map_changed (GtkAccelMap* /*map*/,
+ gchar* /*path*/,
+ guint /*key*/,
+ GdkModifierType /*mod*/,
+ gpointer /*arg*/)
{
Keyboard::keybindings_changed ();
}
}
void
-LevelMeter::configuration_changed(ChanCount in, ChanCount out)
+LevelMeter::configuration_changed (ChanCount /*in*/, ChanCount /*out*/)
{
color_changed = true;
setup_meters (meter_length, regular_meter_width);
}
gint
-LevelMeter::meter_button_release (GdkEventButton* ev, uint32_t which)
+LevelMeter::meter_button_release (GdkEventButton* ev, uint32_t /*which*/)
{
if (ev->button == 1) {
clear_meters();
}
void
-LineSetClass::class_init_function(void* g_class, void* class_data)
+LineSetClass::class_init_function(void* /*g_class*/, void* /*class_data*/)
{
}
* N. find out if the item moved. if it moved, the old bbox and the new bbox need to be updated.
*/
void
-LineSet::update_vfunc(double* affine, ArtSVP* clip_path, int flags)
+LineSet::update_vfunc(double* /*affine*/, ArtSVP* /*clip_path*/, int /*flags*/)
{
GnomeCanvasItem* item = GNOME_CANVAS_ITEM(gobj());
bool lines_need_redraw = true;
}
void
-LineSet::draw_vfunc(const Glib::RefPtr<Gdk::Drawable>& drawable, int x, int y, int width, int height)
+LineSet::draw_vfunc(const Glib::RefPtr<Gdk::Drawable>& /*drawable*/, int /*x*/, int /*y*/, int /*width*/, int /*height*/)
{
cerr << "please don't use the GnomeCanvasLineSet item in a non-aa Canvas" << endl;
abort();
double
-LineSet::point_vfunc(double x, double y, int cx, int cy, GnomeCanvasItem** actual_item)
+LineSet::point_vfunc(double x, double y, int /*cx*/, int /*cy*/, GnomeCanvasItem** actual_item)
{
double x1, y1, x2, y2;
double dx, dy;
* These have been defined to avoid endless recursion with gnomecanvasmm.
* Don't know why this happens
*/
-bool LineSet::on_event(GdkEvent* p1)
+bool LineSet::on_event(GdkEvent* /*p1*/)
{
return false;
}
}
void
-LocationEditRow::change_aborted (LocationPart part)
+LocationEditRow::change_aborted (LocationPart /*part*/)
{
if (i_am_the_modifier || !location) return;
}
bool
-LocationUI::on_delete_event (GdkEventAny* ev)
+LocationUI::on_delete_event (GdkEventAny*)
{
hide ();
return true;
LV2PluginUI::lv2_ui_write(
LV2UI_Controller controller,
uint32_t port_index,
- uint32_t buffer_size,
- uint32_t format,
+ uint32_t /*buffer_size*/,
+ uint32_t /*format*/,
const void* buffer)
{
LV2PluginUI* me = (LV2PluginUI*)controller;
}
bool
-LV2PluginUI::start_updating(GdkEventAny* event)
+LV2PluginUI::start_updating(GdkEventAny*)
{
if (!_output_ports.empty()) {
_screen_update_connection.disconnect();
}
bool
-LV2PluginUI::stop_updating(GdkEventAny* event)
+LV2PluginUI::stop_updating(GdkEventAny*)
{
if (!_output_ports.empty()) {
_screen_update_connection.disconnect();
}
bool
-LV2PluginUI::configure_handler (GdkEventConfigure* ev)
+LV2PluginUI::configure_handler (GdkEventConfigure*)
{
std::cout << "CONFIGURE" << std::endl;
return false;
}
bool
-LV2PluginUI::is_update_wanted(uint32_t index)
+LV2PluginUI::is_update_wanted(uint32_t /*index*/)
{
/* FIXME this should check the port notification properties, which nobody sets now anyway :) */
return true;
#endif
static void
-sigpipe_handler (int sig)
+sigpipe_handler (int /*sig*/)
{
cerr << _("SIGPIPE received - JACK has probably died") << endl;
}
}
void
-MidiMultipleChannelSelector::button_toggled(ToggleButton *button, uint8_t channel)
+MidiMultipleChannelSelector::button_toggled(ToggleButton */*button*/, uint8_t channel)
{
++_recursion_counter;
if (_recursion_counter == 1) {
}
RegionView*
-MidiStreamView::create_region_view (boost::shared_ptr<Region> r, bool wfd, bool)
+MidiStreamView::create_region_view (boost::shared_ptr<Region> r, bool /*wfd*/, bool)
{
boost::shared_ptr<MidiRegion> region = boost::dynamic_pointer_cast<MidiRegion> (r);
}
void
-MixerStrip::input_changed (IOChange change, void *src)
+MixerStrip::input_changed (IOChange /*change*/, void */*src*/)
{
Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &MixerStrip::update_input_display));
set_width_enum (_width, this);
}
void
-MixerStrip::output_changed (IOChange change, void *src)
+MixerStrip::output_changed (IOChange /*change*/, void */*src*/)
{
Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &MixerStrip::update_output_display));
set_width_enum (_width, this);
}
bool
-MixerStrip::on_enter_notify_event (GdkEventCrossing* ev)
+MixerStrip::on_enter_notify_event (GdkEventCrossing*)
{
Keyboard::magic_widget_grab_focus ();
grab_focus ();
}
void
-Mixer_UI::track_list_reorder (const TreeModel::Path& path, const TreeModel::iterator& iter, int* new_order)
+Mixer_UI::track_list_reorder (const TreeModel::Path&, const TreeModel::iterator&, int* /*new_order*/)
{
strip_redisplay_does_not_sync_order_keys = true;
session->set_remote_control_ids();
}
void
-Mixer_UI::track_list_change (const Gtk::TreeModel::Path& path,const Gtk::TreeModel::iterator& iter)
+Mixer_UI::track_list_change (const Gtk::TreeModel::Path&, const Gtk::TreeModel::iterator&)
{
// never reset order keys because of a property change
strip_redisplay_does_not_reset_order_keys = true;
}
void
-Mixer_UI::track_list_delete (const Gtk::TreeModel::Path& path)
+Mixer_UI::track_list_delete (const Gtk::TreeModel::Path&)
{
/* this could require an order sync */
session->set_remote_control_ids();
}
void
-Mixer_UI::route_group_row_change (const Gtk::TreeModel::Path& path,const Gtk::TreeModel::iterator& iter)
+Mixer_UI::route_group_row_change (const Gtk::TreeModel::Path&, const Gtk::TreeModel::iterator& iter)
{
RouteGroup* group;
void
-Mixer_UI::pane_allocation_handler (Allocation& alloc, Gtk::Paned* which)
+Mixer_UI::pane_allocation_handler (Allocation&, Gtk::Paned* which)
{
int pos;
XMLProperty* prop = 0;
using namespace Glib;
using namespace Gtk;
-NagScreen::NagScreen (std::string context, bool maybe_sub)
+NagScreen::NagScreen (std::string /*context*/, bool maybe_sub)
: ArdourDialog (_("Support Ardour Development"), true)
, donate_button (button_group, _("I'd like to make a one-time donation"))
, subscribe_button (button_group, _("Tell me more about becoming a subscriber"))
}
bool
-PannerUI::panning_link_button_press (GdkEventButton* ev)
+PannerUI::panning_link_button_press (GdkEventButton*)
{
return true;
}
bool
-PannerUI::panning_link_button_release (GdkEventButton* ev)
+PannerUI::panning_link_button_release (GdkEventButton*)
{
if (!ignore_toggle) {
_panner->set_linked (!_panner->linked());
}
inline void
-render_rect(Cairo::RefPtr<Cairo::Context> cr, int note, double x[], double y[],
+render_rect(Cairo::RefPtr<Cairo::Context> cr, int /*note*/, double x[], double y[],
PianoRollHeader::Color& bg, PianoRollHeader::Color& tl_shadow, PianoRollHeader::Color& br_shadow)
{
cr->set_source_rgb(bg.r, bg.g, bg.b);
}
inline void
-render_cf(Cairo::RefPtr<Cairo::Context> cr, int note, double x[], double y[],
+render_cf(Cairo::RefPtr<Cairo::Context> cr, int /*note*/, double x[], double y[],
PianoRollHeader::Color& bg, PianoRollHeader::Color& tl_shadow, PianoRollHeader::Color& br_shadow)
{
cr->set_source_rgb(bg.r, bg.g, bg.b);
}
inline void
-render_eb(Cairo::RefPtr<Cairo::Context> cr, int note, double x[], double y[],
+render_eb(Cairo::RefPtr<Cairo::Context> cr, int /*note*/, double x[], double y[],
PianoRollHeader::Color& bg, PianoRollHeader::Color& tl_shadow, PianoRollHeader::Color& br_shadow)
{
cr->set_source_rgb(bg.r, bg.g, bg.b);
}
inline void
-render_dga(Cairo::RefPtr<Cairo::Context> cr, int note, double x[], double y[],
+render_dga(Cairo::RefPtr<Cairo::Context> cr, int /*note*/, double x[], double y[],
PianoRollHeader::Color& bg, PianoRollHeader::Color& tl_shadow, PianoRollHeader::Color& br_shadow)
{
cr->set_source_rgb(bg.r, bg.g, bg.b);
}
bool
-PianoRollHeader::on_scroll_event (GdkEventScroll* ev)
+PianoRollHeader::on_scroll_event (GdkEventScroll*)
{
return true;
}
}
bool
-PluginEqGui::expose_analysis_area(GdkEventExpose *evt)
+PluginEqGui::expose_analysis_area(GdkEventExpose *)
{
redraw_analysis_area();
#define PHASE_PROPORTION 0.5
void
-PluginEqGui::draw_scales_phase(Gtk::Widget *w, cairo_t *cr)
+PluginEqGui::draw_scales_phase(Gtk::Widget */*w*/, cairo_t *cr)
{
float y;
cairo_font_extents_t extents;
}
void
-PluginEqGui::draw_scales_power(Gtk::Widget *w, cairo_t *cr)
+PluginEqGui::draw_scales_power(Gtk::Widget */*w*/, cairo_t *cr)
{
static float scales[] = { 30.0, 70.0, 125.0, 250.0, 500.0, 1000.0, 2000.0, 5000.0, 10000.0, 15000.0, 20000.0, -1.0 };
}
void
+#ifdef VST_SUPPORT
PluginSelector::vst_refiller (const std::string& filterstr)
+#else
+PluginSelector::vst_refiller (const std::string&)
+#endif
{
#ifdef VST_SUPPORT
refiller (manager->vst_plugin_info(), filterstr, "VST");
}
void
+#ifdef HAVE_AUDIOUNITS
PluginSelector::au_refiller (const std::string& filterstr)
+#else
+PluginSelector::au_refiller (const std::string&)
+#endif
{
#ifdef HAVE_AUDIOUNITS
refiller (manager->au_plugin_info(), filterstr, "AU");
}
bool
+#ifdef VST_SUPPORT
PluginUIWindow::create_vst_editor(boost::shared_ptr<PluginInsert> insert)
+#else
+PluginUIWindow::create_vst_editor(boost::shared_ptr<PluginInsert>)
+#endif
{
#ifndef VST_SUPPORT
return false;
}
bool
+#if defined (HAVE_AUDIOUNITS) && defined (GTKOSX)
PluginUIWindow::create_audiounit_editor (boost::shared_ptr<PluginInsert> insert)
+#else
+PluginUIWindow::create_audiounit_editor (boost::shared_ptr<PluginInsert>)
+#endif
{
#if !defined(HAVE_AUDIOUNITS) || !defined(GTKOSX)
return false;
}
void
+#if defined (HAVE_AUDIOUNITS) && defined(GTKOSX)
PluginUIWindow::app_activated (bool yn)
+#else
+PluginUIWindow::app_activated (bool)
+#endif
{
#if defined (HAVE_AUDIOUNITS) && defined(GTKOSX)
cerr << "APP activated ? " << yn << endl;
}
bool
-PluginUIWindow::on_key_release_event (GdkEventKey* event)
+PluginUIWindow::on_key_release_event (GdkEventKey *)
{
return true;
}
}
bool
-PlugUIBase::focus_toggled (GdkEventButton* ev)
+PlugUIBase::focus_toggled (GdkEventButton*)
{
if (Keyboard::the_keyboard().some_magic_widget_has_focus()) {
Keyboard::the_keyboard().magic_widget_drop_focus();
bool max_unbound;
bool packed;
- MeterInfo(int i) {
+ MeterInfo (int /*i*/) {
meter = 0;
packed = false;
min = 1.0e10;
}
double
-PortMatrixColumnLabels::basic_text_x_pos (int c) const
+PortMatrixColumnLabels::basic_text_x_pos (int) const
{
return grid_spacing() / 2 +
_highest_text / (2 * sin (angle ()));
}
double
-PortMatrixColumnLabels::channel_y (ARDOUR::BundleChannel const &bc) const
+PortMatrixColumnLabels::channel_y (ARDOUR::BundleChannel const &) const
{
return 0;
}
}
void
-PortMatrixGrid::button_release (double x, double y, int b, uint32_t t)
+PortMatrixGrid::button_release (double x, double y, int b, uint32_t /*t*/)
{
if (b == 1) {
}
double
-PortMatrixRowLabels::channel_x (ARDOUR::BundleChannel const& bc) const
+PortMatrixRowLabels::channel_x (ARDOUR::BundleChannel const &) const
{
return 0;
}
}
void
-ProcessorBox::processor_drag_begin (GdkDragContext *context)
+ProcessorBox::processor_drag_begin (GdkDragContext *)
{
processor_drag_in_progress = true;
}
void
-ProcessorBox::processor_drag_end (GdkDragContext *context)
+ProcessorBox::processor_drag_end (GdkDragContext *)
{
processor_drag_in_progress = false;
}
bool
-ProcessorBox::enter_notify (GdkEventCrossing* ev)
+ProcessorBox::enter_notify (GdkEventCrossing*)
{
_current_processor_box = this;
Keyboard::magic_widget_grab_focus ();
}
bool
-ProcessorBox::processor_key_press_event (GdkEventKey *ev)
+ProcessorBox::processor_key_press_event (GdkEventKey *)
{
/* do real stuff on key release */
return false;
}
void
-ProcessorBox::row_deleted (const Gtk::TreeModel::Path& path)
+ProcessorBox::row_deleted (const Gtk::TreeModel::Path &)
{
if (!ignore_delete) {
compute_processor_sort_keys ();
private:
- void model_changed (TreeModel::Path const & p, TreeModel::iterator const & i)
+ void model_changed (TreeModel::Path const &, TreeModel::iterator const & i)
{
TreeModel::Row r = *i;
_box->pack_start (*t, false, false);
}
- void parameter_changed (string const & p)
+ void parameter_changed (string const &)
{
/* XXX: these aren't really config options... */
}
private:
- void model_changed (TreeModel::Path const & p, TreeModel::iterator const & i)
+ void model_changed (TreeModel::Path const &, TreeModel::iterator const & i)
{
TreeModel::Row r = *i;
}
gint
-RegionView::_lock_toggle (ArdourCanvas::Item* item, GdkEvent* ev, void* arg)
+RegionView::_lock_toggle (ArdourCanvas::Item*, GdkEvent* ev, void* arg)
{
switch (ev->type) {
case GDK_BUTTON_RELEASE:
}
bool
-RegionView::set_position (nframes_t pos, void* src, double* ignored)
+RegionView::set_position (nframes_t pos, void* /*src*/, double* ignored)
{
double delta;
bool ret;
}
void
-RouteTimeAxisView::set_playlist (boost::shared_ptr<Playlist> newplaylist)
+RouteTimeAxisView::set_playlist (boost::shared_ptr<Playlist> /*newplaylist*/)
{
boost::shared_ptr<Playlist> pl = playlist();
assert(pl);
}
void
-RouteTimeAxisView::io_changed (IOChange change, void *src)
+RouteTimeAxisView::io_changed (IOChange /*change*/, void */*src*/)
{
reset_meter ();
}
}
bool
-RouteUI::mute_release(GdkEventButton* ev)
+RouteUI::mute_release(GdkEventButton*)
{
if (!ignore_toggle) {
if (wait_for_release){
}
bool
-RouteUI::solo_release(GdkEventButton* ev)
+RouteUI::solo_release(GdkEventButton*)
{
if (!ignore_toggle) {
if (wait_for_release) {
}
bool
-RouteUI::rec_enable_release (GdkEventButton* ev)
+RouteUI::rec_enable_release (GdkEventButton*)
{
return true;
}
}
bool
-RouteUI::show_sends_release (GdkEventButton* ev)
+RouteUI::show_sends_release (GdkEventButton*)
{
return true;
}
}
void
-RouteUI::solo_changed(void* src)
+RouteUI::solo_changed(void* /*src*/)
{
Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &RouteUI::update_solo_display));
}
void
-RouteUI::listen_changed(void* src)
+RouteUI::listen_changed(void* /*src*/)
{
Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &RouteUI::update_solo_display));
}
}
void
-RouteUI::mute_changed(void* src)
+RouteUI::mute_changed(void* /*src*/)
{
Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &RouteUI::update_mute_display));
}
}
void
-RouteUI::toggle_mute_menu(MuteMaster::MutePoint mp, Gtk::CheckMenuItem* check)
+RouteUI::toggle_mute_menu(MuteMaster::MutePoint /*mp*/, Gtk::CheckMenuItem* /*check*/)
{
// _route->set_mute_config(type, check->get_active(), this);
}
}
void
-RouteUI::solo_isolated_toggle(void* src, Gtk::CheckMenuItem* check)
+RouteUI::solo_isolated_toggle(void* /*src*/, Gtk::CheckMenuItem* check)
{
bool yn = _route->solo_isolated ();
}
void
-Selection::remove (nframes_t start, nframes_t end)
+Selection::remove (nframes_t /*start*/, nframes_t /*end*/)
{
}
}
void
-SessionImportDialog::show_info(const Gtk::TreeModel::Path& path, Gtk::TreeViewColumn* column)
+SessionImportDialog::show_info(const Gtk::TreeModel::Path& path, Gtk::TreeViewColumn*)
{
if (path.size() == 1) {
return;
/// Sets session, into which the data is eventually saved
virtual void set_session (ARDOUR::Session * s) { session = s; }
/// allows loading extra data into data sets (for importing etc.)
- virtual void load_extra_data (ARDOUR::SessionMetadata const & data) { }
+ virtual void load_extra_data (ARDOUR::SessionMetadata const & /*data*/) { }
/// Saves data to session
virtual void save_data () = 0;
_box->pack_start (_port_matrix);
}
- void parameter_changed (string const & p)
+ void parameter_changed (string const &)
{
}
}
bool
-SoundFileBox::tags_entry_left (GdkEventFocus *ev)
+SoundFileBox::tags_entry_left (GdkEventFocus *)
{
tags_changed ();
return false;
}
void
-SoundFileBrowser::found_list_view_activated (const TreeModel::Path& path, TreeViewColumn* col)
+SoundFileBrowser::found_list_view_activated (const TreeModel::Path&, TreeViewColumn*)
{
preview.audition ();
}
void
-SoundFileBrowser::freesound_list_view_activated (const TreeModel::Path& path, TreeViewColumn* col)
+SoundFileBrowser::freesound_list_view_activated (const TreeModel::Path&, TreeViewColumn*)
{
preview.audition ();
}
bool
-Splash::on_button_release_event (GdkEventButton* ev)
+Splash::on_button_release_event (GdkEventButton*)
{
hide ();
return true;
}
void
-ArdourStartup::recent_row_activated (const Gtk::TreePath& path, Gtk::TreeViewColumn* col)
+ArdourStartup::recent_row_activated (const Gtk::TreePath&, Gtk::TreeViewColumn*)
{
set_page_complete (session_vbox, true);
move_along_now ();
void get_selectables (nframes_t start, nframes_t end, std::list<Selectable* >&);
void get_inverted_selectables (Selection&, std::list<Selectable* >& results);
- virtual void update_contents_metrics(boost::shared_ptr<ARDOUR::Region> r) {}
+ virtual void update_contents_metrics(boost::shared_ptr<ARDOUR::Region>) {}
void add_region_view_weak (boost::weak_ptr<ARDOUR::Region> r);
void add_region_view (boost::shared_ptr<ARDOUR::Region>);
}
void
-TapeAudioRegionView::init (Gdk::Color const & basic_color, bool wfw)
+TapeAudioRegionView::init (Gdk::Color const & basic_color, bool /*wfw*/)
{
/* never wait for data: always just create the waves, connect once and then
we'll update whenever we need to.
}
bool
-TempoDialog::bpm_button_press (GdkEventButton* ev)
+TempoDialog::bpm_button_press (GdkEventButton*)
{
return false;
}
bool
-TempoDialog::bpm_button_release (GdkEventButton* ev)
+TempoDialog::bpm_button_release (GdkEventButton*)
{
/* the value has been modified, accept should work now */
}
bool
-TempoDialog::entry_key_release (GdkEventKey* ev)
+TempoDialog::entry_key_release (GdkEventKey*)
{
if (when_beat_entry.get_text() != "" && when_bar_entry.get_text() != "") {
set_response_sensitive (RESPONSE_ACCEPT, true);
}
bool
-MeterDialog::entry_key_release (GdkEventKey* ev)
+MeterDialog::entry_key_release (GdkEventKey*)
{
if (when_bar_entry.get_text() != "" && bpb_entry.get_text() != "") {
set_response_sensitive (RESPONSE_ACCEPT, true);
}
int
-ThemeManager::save (string path)
+ThemeManager::save (string /*path*/)
{
return 0;
}
bool TimeAxisView::need_size_info = true;
int const TimeAxisView::_max_order = 512;
-TimeAxisView::TimeAxisView (ARDOUR::Session& sess, PublicEditor& ed, TimeAxisView* rent, Canvas& canvas)
+TimeAxisView::TimeAxisView (ARDOUR::Session& sess, PublicEditor& ed, TimeAxisView* rent, Canvas& /*canvas*/)
: AxisView (sess),
controls_table (2, 8),
_y_position (0),
}
bool
-TimeAxisView::name_entry_focus_in (GdkEventFocus* ev)
+TimeAxisView::name_entry_focus_in (GdkEventFocus*)
{
name_entry.select_region (0, -1);
name_entry.set_name ("EditorActiveTrackNameDisplay");
}
bool
-TimeAxisView::name_entry_focus_out (GdkEventFocus* ev)
+TimeAxisView::name_entry_focus_out (GdkEventFocus*)
{
/* clean up */
}
void
-TimeAxisView::get_selectables (nframes_t start, nframes_t end, double top, double bot, list<Selectable*>& result)
+TimeAxisView::get_selectables (nframes_t /*start*/, nframes_t /*end*/, double /*top*/, double /*bot*/, list<Selectable*>& /*result*/)
{
return;
}
void
-TimeAxisView::get_inverted_selectables (Selection& sel, list<Selectable*>& result)
+TimeAxisView::get_inverted_selectables (Selection& /*sel*/, list<Selectable*>& /*result*/)
{
return;
}
}
bool
-TimeAxisView::resizer_button_release (GdkEventButton* ev)
+TimeAxisView::resizer_button_release (GdkEventButton*)
{
_resize_drag_start = -1;
return true;
/* editing operations */
virtual bool cut_copy_clear (Selection&, Editing::CutCopyOp) { return false; }
- virtual bool paste (nframes_t, float times, Selection&, size_t nth) { return false; }
+ virtual bool paste (nframes_t, float /*times*/, Selection&, size_t /*nth*/) { return false; }
virtual void set_selected_regionviews (RegionSelection&) {}
virtual void set_selected_points (PointSelection&) {}
- virtual boost::shared_ptr<ARDOUR::Region> find_next_region (nframes_t pos, ARDOUR::RegionPoint, int32_t dir) {
+ virtual boost::shared_ptr<ARDOUR::Region> find_next_region (nframes_t /*pos*/, ARDOUR::RegionPoint, int32_t /*dir*/) {
return boost::shared_ptr<ARDOUR::Region> ();
}
/* call this on the parent */
- virtual XMLNode* get_automation_child_xml_node (Evoral::Parameter param) { return 0; }
+ virtual XMLNode* get_automation_child_xml_node (Evoral::Parameter /*param*/) { return 0; }
virtual LayerDisplay layer_display () const { return Overlaid; }
virtual StreamView* view () const { return 0; }
/** Do whatever needs to be done to dynamically reset the LHS control menu.
*/
- virtual bool handle_display_menu_map_event (GdkEventAny *ev) { return false; }
+ virtual bool handle_display_menu_map_event (GdkEventAny * /*ev*/) { return false; }
/** Build the standard LHS control size menu for the default heights options.
*/
* @param src the identity of the object that initiated the change
*/
void
-TimeAxisViewItem::set_max_duration_active(bool active, void* src)
+TimeAxisViewItem::set_max_duration_active (bool active, void* /*src*/)
{
- max_duration_active = active ;
+ max_duration_active = active;
}
/**
* @param src the identity of the object that initiated the change
*/
void
-TimeAxisViewItem::set_min_duration_active(bool active, void* src)
+TimeAxisViewItem::set_min_duration_active (bool active, void* /*src*/)
{
min_duration_active = active ;
}
}
void
-TimeAxisViewItem::reset_name_width (double pixel_width)
+TimeAxisViewItem::reset_name_width (double /*pixel_width*/)
{
set_name_text (item_name);
}
}
gint
-TimeFXDialog::delete_in_progress (GdkEventAny* ev)
+TimeFXDialog::delete_in_progress (GdkEventAny*)
{
status = -2;
request.cancel = true;
gint
-just_hide_it (GdkEventAny *ev, Gtk::Window *win)
+just_hide_it (GdkEventAny */*ev*/, Gtk::Window *win)
{
win->hide ();
return 0;
}
ArdourCanvas::Points*
-get_canvas_points (string who, uint32_t npoints)
+get_canvas_points (string /*who*/, uint32_t npoints)
{
// cerr << who << ": wants " << npoints << " canvas points" << endl;
#ifdef TRAP_EXCESSIVE_POINT_REQUESTS
}
void
-Amp::run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame, nframes_t nframes)
+Amp::run (BufferSet& bufs, sframes_t /*start_frame*/, sframes_t /*end_frame*/, nframes_t nframes)
{
gain_t mute_gain;
void can_automate(Evoral::Parameter);
- virtual void auto_state_changed (Evoral::Parameter which) {}
-
+ virtual void auto_state_changed (Evoral::Parameter /*which*/) {}
int load_automation (const std::string& path);
int old_set_automation_state(const XMLNode&);
template<typename T>
class AutomatableSequence : public Automatable, public Evoral::Sequence<T> {
public:
- AutomatableSequence(Session& s, size_t size)
+ AutomatableSequence(Session& s, size_t /*size*/)
: Evoral::ControlSet()
, Automatable(s)
, Evoral::Sequence<T>(EventTypeMap::instance())
virtual void set_record_enabled (bool yn) = 0;
bool destructive() const { return _flags & Destructive; }
- virtual int set_destructive (bool yn) { return -1; }
- virtual int set_non_layered (bool yn) { return -1; }
- virtual bool can_become_destructive (bool& requires_bounce) const { return false; }
+ virtual int set_destructive (bool /*yn*/) { return -1; }
+ virtual int set_non_layered (bool /*yn*/) { return -1; }
+ virtual bool can_become_destructive (bool& /*requires_bounce*/) const { return false; }
bool hidden() const { return _flags & Hidden; }
bool recordable() const { return _flags & Recordable; }
void set_speed (double);
void non_realtime_set_speed ();
- virtual void non_realtime_locate (nframes_t location) {};
+ virtual void non_realtime_locate (nframes_t /*location*/) {};
virtual void playlist_modified ();
boost::shared_ptr<Playlist> playlist () { return _playlist; }
public:
void read (Sample * data, nframes_t frames_to_read) const { factory.read (channel, data, frames_to_read); }
- void get_state (XMLNode * node) const {};
- void set_state (XMLNode * node, Session & session) {};
+ void get_state (XMLNode * /*node*/) const {};
+ void set_state (XMLNode * /*node*/, Session & /*session*/) {};
bool empty () const { return false; }
// Region export should never have duplicate channels, so there need not be any semantics here
bool operator< (ExportChannel const & other) const { return this < &other; }
class NullSink : public GraphSink<float>
{
public:
- nframes_t write (float * data, nframes_t frames) { return frames; }
+ nframes_t write (float * /*data*/, nframes_t frames) { return frames; }
};
double target_speed() const { return _target_speed; }
double speed() const { return _speed; }
- void add_channel_to (int input_buffer_size, int output_buffer_size) {}
+ void add_channel_to (int /*input_buffer_size*/, int /*output_buffer_size*/) {}
void remove_channel_from () {}
void reset () {}
~LibSamplerateInterpolation ();
void set_speed (double new_speed);
- void set_target_speed (double new_speed) {}
+ void set_target_speed (double /*new_speed*/) {}
double speed () const { return _speed; }
void add_channel_to (int input_buffer_size, int output_buffer_size);
_descriptor->cleanup (_handle);
}
- void set_block_size (nframes_t nframes) {}
+ void set_block_size (nframes_t /*nframes*/) {}
int connect_and_run (BufferSet& bufs,
ChanMapping in, ChanMapping out,
_instance = NULL;
}
- void set_block_size (nframes_t nframes) {}
+ void set_block_size (nframes_t /*nframes*/) {}
int connect_and_run (BufferSet& bufs,
ChanMapping in, ChanMapping out,
boost::shared_ptr<MidiSource> midi_source (uint32_t n=0) const;
/* Stub Readable interface */
- virtual nframes_t read (Sample*, sframes_t pos, nframes_t cnt, int channel) const { return 0; }
+ virtual nframes_t read (Sample*, sframes_t /*pos*/, nframes_t /*cnt*/, int /*channel*/) const { return 0; }
virtual sframes_t readable_length() const { return length(); }
nframes_t read_at (MidiRingBuffer<nframes_t>& dst,
AutoStyle automation_style() const;
bool touching() const;
- bool can_support_io_configuration (const ChanCount& in, ChanCount& out) const { return true; };
+ bool can_support_io_configuration (const ChanCount& /*in*/, ChanCount& /*out*/) const { return true; };
/// The fundamental Panner function
void run (BufferSet& src, BufferSet& dest, sframes_t start_frame, sframes_t end_frames, nframes_t nframes);
void splice_locked (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude);
void splice_unlocked (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude);
- virtual void finalize_split_region (boost::shared_ptr<Region> original, boost::shared_ptr<Region> left, boost::shared_ptr<Region> right) {}
+ virtual void finalize_split_region (boost::shared_ptr<Region> /*original*/, boost::shared_ptr<Region> /*left*/, boost::shared_ptr<Region> /*right*/) {}
- virtual void check_dependents (boost::shared_ptr<Region> region, bool norefresh) {}
- virtual void refresh_dependents (boost::shared_ptr<Region> region) {}
- virtual void remove_dependents (boost::shared_ptr<Region> region) {}
+ virtual void check_dependents (boost::shared_ptr<Region> /*region*/, bool /*norefresh*/) {}
+ virtual void refresh_dependents (boost::shared_ptr<Region> /*region*/) {}
+ virtual void remove_dependents (boost::shared_ptr<Region> /*region*/) {}
virtual XMLNode& state (bool);
virtual bool reconfigurable_io() const { return false; }
/* this is only called if reconfigurable_io() returns true */
- virtual bool configure_io (ChanCount in, ChanCount out) { return true; }
+ virtual bool configure_io (ChanCount /*in*/, ChanCount /*out*/) { return true; }
/* specific types of plugins can overload this. As of September 2008, only
AUPlugin does this.
*/
- virtual bool can_support_io_configuration (const ChanCount& in, ChanCount& out) const { return false; }
+ virtual bool can_support_io_configuration (const ChanCount& /*in*/, ChanCount& /*out*/) const { return false; }
virtual ChanCount output_streams() const;
virtual ChanCount input_streams() const;
virtual void cycle_end (nframes_t) = 0;
virtual void cycle_split () = 0;
virtual Buffer& get_buffer (nframes_t nframes, nframes_t offset = 0) = 0;
- virtual void flush_buffers (nframes_t, nframes_t offset = 0) {}
+ virtual void flush_buffers (nframes_t, nframes_t offset = 0) {
+ (void) offset;
+ }
static void set_engine (AudioEngine *);
virtual nframes_t signal_latency() const { return 0; }
- virtual void transport_stopped (sframes_t frame) {}
+ virtual void transport_stopped (sframes_t /*frame*/) {}
- virtual void set_block_size (nframes_t nframes) {}
+ virtual void set_block_size (nframes_t /*nframes*/) {}
- virtual void run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame, nframes_t nframes) {}
- virtual void silence (nframes_t nframes) {}
+ virtual void run (BufferSet& /*bufs*/, sframes_t /*start_frame*/, sframes_t /*end_frame*/, nframes_t /*nframes*/) {}
+ virtual void silence (nframes_t /*nframes*/) {}
virtual void activate () { _pending_active = true; ActiveChanged(); }
virtual void deactivate () { _pending_active = false; ActiveChanged(); }
void set_last_layer_op (uint64_t when);
virtual bool is_dependent() const { return false; }
- virtual bool depends_on (boost::shared_ptr<Region> other) const { return false; }
+ virtual bool depends_on (boost::shared_ptr<Region> /*other*/) const { return false; }
virtual int exportme (ARDOUR::Session&, ARDOUR::ExportSpecification&) = 0;
- virtual int get_transients (AnalysisFeatureList&, bool force_new = false) {
+ virtual int get_transients (AnalysisFeatureList&, bool force_new = false) {
+ (void) force_new;
// no transients, but its OK
return 0;
}
virtual void toggle_monitor_input ();
virtual bool can_record() { return false; }
- virtual void set_record_enable (bool yn, void *src) {}
+ virtual void set_record_enable (bool /*yn*/, void * /*src*/) {}
virtual bool record_enabled() const { return false; }
virtual void handle_transport_stopped (bool abort, bool did_locate, bool flush_processors);
virtual void set_pending_declick (int);
namespace ARDOUR {
template<class T> void
-RouteGroup::apply (void (Track::*func)(T, void *), T val, void *src)
+RouteGroup::apply (void (Track::*func)(T, void *), T val, void */*src*/)
{
for (std::list<Route *>::iterator i = routes.begin(); i != routes.end(); i++) {
Track *at;
return e1->before (*e2);
}
- void *operator new (size_t ignored) {
+ void *operator new (size_t) {
return pool.alloc ();
}
- void operator delete(void *ptr, size_t size) {
+ void operator delete (void *ptr, size_t /*size*/) {
pool.release (ptr);
}
uint32_t _listen_cnt;
void set_worst_io_latencies ();
- void set_worst_io_latencies_x (IOChange asifwecare, void *ignored) {
+ void set_worst_io_latencies_x (IOChange, void *) {
set_worst_io_latencies ();
}
Click (nframes_t s, nframes_t d, const Sample *b)
: start (s), duration (d), data (b) { offset = 0; }
- void *operator new(size_t ignored) {
+ void *operator new (size_t) {
return pool.alloc ();
};
- void operator delete(void *ptr, size_t size) {
+ void operator delete(void *ptr, size_t /*size*/) {
pool.release (ptr);
}
class SilentFileSource : public AudioFileSource {
public:
- int update_header (sframes_t when, struct tm&, time_t) { return 0; }
+ int update_header (sframes_t /*when*/, struct tm&, time_t) { return 0; }
int flush_header () { return 0; }
float sample_rate () const { return _sample_rate; }
_length = len;
}
- nframes_t read_unlocked (Sample *dst, sframes_t start, nframes_t cnt) const {
+ nframes_t read_unlocked (Sample *dst, sframes_t /*start*/, nframes_t cnt) const {
memset (dst, 0, sizeof (Sample) * cnt);
return cnt;
}
- nframes_t write_unlocked (Sample *dst, nframes_t cnt) { return 0; }
+ nframes_t write_unlocked (Sample */*dst*/, nframes_t /*cnt*/) { return 0; }
void set_header_timeline_position () {}
- int read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, sframes_t start, nframes_t cnt,
- double samples_per_unit, nframes_t fpp) const {
+ int read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, sframes_t /*start*/, nframes_t /*cnt*/,
+ double /*samples_per_unit*/, nframes_t /*fpp*/) const {
memset (peaks, 0, sizeof (PeakData) * npeaks);
return 0;
}
virtual nframes_t frames_since_cycle_start () const { return 0; }
virtual nframes_t frame_time () const { return 0; }
- virtual void request_locate (nframes_t frame, bool with_roll = false) {}
- virtual void request_transport_speed (double speed) {}
+ virtual void request_locate (nframes_t /*frame*/, bool with_roll = false) {
+ (void) with_roll;
+ }
+ virtual void request_transport_speed (double /*speed*/) {}
};
bool destructive() const { return (_flags & Destructive); }
bool writable () const { return _flags & Writable; }
- virtual bool set_destructive (bool yn) { return false; }
+ virtual bool set_destructive (bool /*yn*/) { return false; }
virtual bool length_mutable() const { return false; }
void use () { _in_use++; }
bool set_name (const std::string& str);
TrackMode mode () const { return _mode; }
- virtual int set_mode (TrackMode m) { return false; }
- virtual bool can_use_mode (TrackMode m, bool& bounce_required) { return false; }
+ virtual int set_mode (TrackMode /*m*/) { return false; }
+ virtual bool can_use_mode (TrackMode /*m*/, bool& /*bounce_required*/) { return false; }
sigc::signal<void> TrackModeChanged;
int no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
}
void
-AudioDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record)
+AudioDiskstream::check_record_status (nframes_t transport_frame, nframes_t /*nframes*/, bool can_record)
{
int possibly_recording;
int rolling;
}
bool
-AudioDiskstream::commit (nframes_t nframes)
+AudioDiskstream::commit (nframes_t /*nframes*/)
{
bool need_butler = false;
int
AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
- ChannelInfo* channel_info, int channel, bool reversed)
+ ChannelInfo* /*channel_info*/, int channel, bool reversed)
{
nframes_t this_read = 0;
bool reloop = false;
* written at all unless @a force_flush is true.
*/
int
-AudioDiskstream::do_flush (RunContext context, bool force_flush)
+AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
{
uint32_t to_write;
int32_t ret = 0;
}
void
-AudioDiskstream::finish_capture (bool rec_monitors_input, boost::shared_ptr<ChannelList> c)
+AudioDiskstream::finish_capture (bool /*rec_monitors_input*/, boost::shared_ptr<ChannelList> c)
{
was_recording = false;
}
void
-AudioDiskstream::reset_write_sources (bool mark_write_complete, bool force)
+AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
{
ChannelList::iterator chan;
boost::shared_ptr<ChannelList> c = channels.reader();
}
void
-AudioDiskstream::set_block_size (nframes_t nframes)
+AudioDiskstream::set_block_size (nframes_t /*nframes*/)
{
if (_session.get_block_size() > speed_buffer_size) {
speed_buffer_size = _session.get_block_size();
}
void
-AudioPlaylist::crossfade_changed (Change ignored)
+AudioPlaylist::crossfade_changed (Change)
{
if (in_flush || in_set_state) {
return;
}
int
-AudioTrack::set_diskstream (boost::shared_ptr<AudioDiskstream> ds, void *src)
+AudioTrack::set_diskstream (boost::shared_ptr<AudioDiskstream> ds, void * /*src*/)
{
_diskstream = ds;
_diskstream->set_route (*this);
}
void
-_thread_init_callback (void *arg)
+_thread_init_callback (void * /*arg*/)
{
/* make sure that anybody who needs to know about this thread
knows about it.
bool
-AudioEngine::get_sync_offset (nframes_t& offset) const
+AudioEngine::get_sync_offset (nframes_t& /*offset*/) const
{
#ifdef HAVE_JACK_VIDEO_SUPPORT
/** Constructor used for new internal-to-session files. */
AudioFileSource::AudioFileSource (Session& s, const ustring& path, bool embedded, Source::Flag flags,
- SampleFormat samp_format, HeaderFormat hdr_format)
+ SampleFormat /*samp_format*/, HeaderFormat /*hdr_format*/)
: Source (s, DataType::AUDIO, path, flags)
, AudioSource (s, path)
, FileSource (s, DataType::AUDIO, path, embedded, flags)
}
bool
-AudioFileSource::is_empty (Session& s, ustring path)
+AudioFileSource::is_empty (Session& /*s*/, ustring path)
{
SoundFileInfo info;
string err;
assert (_sources.size() == _master_sources.size());
}
-AudioRegion::AudioRegion (boost::shared_ptr<const AudioRegion> other, const SourceList& srcs,
+AudioRegion::AudioRegion (boost::shared_ptr<const AudioRegion> other, const SourceList& /*srcs*/,
nframes_t length, const string& name, layer_t layer, Flag flags)
: Region (other, length, name, layer, flags)
, _automatable (other->session())
}
nframes_t
-AudioRegion::_read_at (const SourceList& srcs, nframes_t limit,
+AudioRegion::_read_at (const SourceList& /*srcs*/, nframes_t limit,
Sample *buf, Sample *mixdown_buffer, float *gain_buffer,
sframes_t position, nframes_t cnt,
uint32_t chan_n,
- nframes_t read_frames,
- nframes_t skip_frames,
+ nframes_t /*read_frames*/,
+ nframes_t /*skip_frames*/,
ReadOps rops) const
{
nframes_t internal_offset;
}
int
-AudioRegion::separate_by_channel (Session& session, vector<boost::shared_ptr<Region> >& v) const
+AudioRegion::separate_by_channel (Session& /*session*/, vector<boost::shared_ptr<Region> >& v) const
{
SourceList srcs;
string new_name;
}
int
-AudioRegion::exportme (Session& session, ARDOUR::ExportSpecification& spec)
+AudioRegion::exportme (Session& /*session*/, ARDOUR::ExportSpecification& /*spec*/)
{
// TODO EXPORT
// const nframes_t blocksize = 4096;
}
sframes_t
-AudioSource::length (sframes_t pos) const
+AudioSource::length (sframes_t /*pos*/) const
{
return _length;
}
}
nframes_t
-AudioSource::read (Sample *dst, sframes_t start, nframes_t cnt, int channel) const
+AudioSource::read (Sample *dst, sframes_t start, nframes_t cnt, int /*channel*/) const
{
Glib::Mutex::Lock lm (_lock);
return read_unlocked (dst, start, cnt);
}
void
-Auditioner::output_changed (IOChange change, void* src)
+Auditioner::output_changed (IOChange change, void* /*src*/)
{
string phys;
}
nframes_t
-Crossfade::read_raw_internal (Sample* buf, sframes_t start, nframes_t cnt, int channel) const
+Crossfade::read_raw_internal (Sample* /*buf*/, sframes_t /*start*/, nframes_t cnt, int /*channel*/) const
{
// FIXME: Why is this disabled?
#if 0
}
void
-Delivery::cycle_start (nframes_t nframes)
+Delivery::cycle_start (nframes_t /*nframes*/)
{
_output_offset = 0;
_no_outs_cuz_we_no_monitor = false;
}
void
-Delivery::output_changed (IOChange change, void* src)
+Delivery::output_changed (IOChange change, void* /*src*/)
{
if (change & ARDOUR::ConfigurationChanged) {
reset_panner ();
init (flag);
}
-Diskstream::Diskstream (Session& sess, const XMLNode& node)
+Diskstream::Diskstream (Session& sess, const XMLNode& /*node*/)
: SessionObject(sess, "unnamed diskstream")
{
init (Recordable);
}
void
-Diskstream::handle_input_change (IOChange change, void *src)
+Diskstream::handle_input_change (IOChange change, void * /*src*/)
{
Glib::Mutex::Lock lm (state_lock);
}
void
-Diskstream::playlist_changed (Change ignored)
+Diskstream::playlist_changed (Change)
{
playlist_modified ();
}
}
void
-ExportFormatManager::select_compatibility (WeakCompatPtr const & compat)
+ExportFormatManager::select_compatibility (WeakCompatPtr const & /*compat*/)
{
/* Calculate compatibility intersection for the selection */
{
}
-FileSource::FileSource (Session& session, const XMLNode& node, bool must_exist)
+FileSource::FileSource (Session& session, const XMLNode& node, bool /*must_exist*/)
: Source(session, node)
, _file_is_new(false)
{
}
void
-Gain::fill_linear_volume_fade_in (Gain& gain, nframes_t frames)
+Gain::fill_linear_volume_fade_in (Gain& /*gain*/, nframes_t /*frames*/)
{
}
void
-Gain::fill_linear_volume_fade_out (Gain& gain, nframes_t frames)
+Gain::fill_linear_volume_fade_out (Gain& /*gain*/, nframes_t /*frames*/)
{
}
void
-Gain::fill_linear_fade_in (Gain& gain, nframes_t frames)
+Gain::fill_linear_fade_in (Gain& /*gain*/, nframes_t /*frames*/)
{
}
void
-Gain::fill_linear_fade_out (Gain& gain, nframes_t frames)
+Gain::fill_linear_fade_out (Gain& /*gain*/, nframes_t /*frames*/)
{
}
}
static bool
-map_existing_mono_sources (const vector<string>& new_paths, Session& sess,
- uint samplerate, vector<boost::shared_ptr<Source> >& newfiles, Session *session)
+map_existing_mono_sources (const vector<string>& new_paths, Session& /*sess*/,
+ uint /*samplerate*/, vector<boost::shared_ptr<Source> >& newfiles, Session *session)
{
for (vector<string>::const_iterator i = new_paths.begin();
i != new_paths.end(); ++i)
}
void
-InternalReturn::run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame, nframes_t nframes)
+InternalReturn::run (BufferSet& bufs, sframes_t /*start_frame*/, sframes_t /*end_frame*/, nframes_t nframes)
{
if (!_active && !_pending_active) {
return;
}
void
-FixedPointLinearInterpolation::add_channel_to (int input_buffer_size, int output_buffer_size)
+FixedPointLinearInterpolation::add_channel_to (int /*input_buffer_size*/, int /*output_buffer_size*/)
{
last_phase.push_back (0);
}
}
void
-LinearInterpolation::add_channel_to (int input_buffer_size, int output_buffer_size)
+LinearInterpolation::add_channel_to (int /*input_buffer_size*/, int /*output_buffer_size*/)
{
phase.push_back (0.0);
}
}
bool
-IO::ensure_ports_locked (ChanCount count, bool clear, void* src)
+IO::ensure_ports_locked (ChanCount count, bool clear, void* /*src*/)
{
Port* port = 0;
bool changed = false;
}
XMLNode&
-IO::state (bool full_state)
+IO::state (bool /*full_state*/)
{
XMLNode* node = new XMLNode (state_node_name);
char buf[64];
}
void
-IO::bundle_changed (Bundle::Change c)
+IO::bundle_changed (Bundle::Change /*c*/)
{
//XXX
// connect_input_ports_to_bundle (_input_bundle, this);
/* create an IOProcessor that proxies to an existing IO object */
IOProcessor::IOProcessor (Session& s, boost::shared_ptr<IO> in, boost::shared_ptr<IO> out,
- const string& proc_name, DataType dtype)
+ const string& proc_name, DataType /*dtype*/)
: Processor(s, proc_name)
, _input (in)
, _output (out)
}
void
-Locations::location_changed (Location* loc)
+Locations::location_changed (Location* /*loc*/)
{
changed (); /* EMIT SIGNAL */
}
* \return true on success
*/
bool
-LV2EventBuffer::append(const LV2_Event_Buffer* buf)
+LV2EventBuffer::append(const LV2_Event_Buffer* /*buf*/)
{
uint8_t** data = NULL;
bool ret = true;
}
bool
-LV2Plugin::save_preset (string name)
+LV2Plugin::save_preset (string /*name*/)
{
return false;
}
* be set to 0.
*/
void
-PeakMeter::run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame, nframes_t nframes)
+PeakMeter::run (BufferSet& bufs, sframes_t /*start_frame*/, sframes_t /*end_frame*/, nframes_t nframes)
{
if (!_active && !_pending_active) {
return;
}
void
-MidiBuffer::merge_from (const Buffer& src, nframes_t nframes, nframes_t dst_offset, nframes_t src_offset)
+MidiBuffer::merge_from (const Buffer& src, nframes_t /*nframes*/, nframes_t /*dst_offset*/, nframes_t /*src_offset*/)
{
const MidiBuffer* mbuf = dynamic_cast<const MidiBuffer*>(&src);
assert (mbuf);
void
-MidiBuffer::silence (nframes_t nframes, nframes_t offset)
+MidiBuffer::silence (nframes_t /*nframes*/, nframes_t /*offset*/)
{
/* XXX iterate over existing events, find all in range given by offset & nframes,
and delete them.
}
void
-MIDIClock_Slave::update_midi_clock (Parser& parser, nframes_t timestamp)
+MIDIClock_Slave::update_midi_clock (Parser& /*parser*/, nframes_t timestamp)
{
// some pieces of hardware send MIDI Clock all the time
if ( (!_starting) && (!_started) ) {
}
void
-MIDIClock_Slave::start (Parser& parser, nframes_t timestamp)
+MIDIClock_Slave::start (Parser& /*parser*/, nframes_t /*timestamp*/)
{
#ifdef DEBUG_MIDI_CLOCK
cerr << "MIDIClock_Slave got start message at time " << timestamp << " engine time: " << session->frame_time() << endl;
}
void
-MIDIClock_Slave::contineu (Parser& parser, nframes_t timestamp)
+MIDIClock_Slave::contineu (Parser& /*parser*/, nframes_t /*timestamp*/)
{
#ifdef DEBUG_MIDI_CLOCK
std::cerr << "MIDIClock_Slave got continue message" << endl;
void
-MIDIClock_Slave::stop (Parser& parser, nframes_t timestamp)
+MIDIClock_Slave::stop (Parser& /*parser*/, nframes_t /*timestamp*/)
{
#ifdef DEBUG_MIDI_CLOCK
std::cerr << "MIDIClock_Slave got stop message" << endl;
}
void
-MIDIClock_Slave::position (Parser& parser, byte* message, size_t size)
+MIDIClock_Slave::position (Parser& /*parser*/, byte* message, size_t size)
{
// we are note supposed to get position messages while we are running
// so lets be robust and ignore those
}
void
-MidiDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record)
+MidiDiskstream::check_record_status (nframes_t transport_frame, nframes_t /*nframes*/, bool can_record)
{
// FIXME: waaay too much code to duplicate (AudioDiskstream)
* written at all unless @a force_flush is true.
*/
int
-MidiDiskstream::do_flush (RunContext context, bool force_flush)
+MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
{
uint32_t to_write;
int32_t ret = 0;
}
void
-MidiDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
+MidiDiskstream::transport_stopped (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
{
uint32_t buffer_position;
bool more_work = true;
}
void
-MidiDiskstream::finish_capture (bool rec_monitors_input)
+MidiDiskstream::finish_capture (bool /*rec_monitors_input*/)
{
was_recording = false;
}
void
-MidiDiskstream::reset_write_sources (bool mark_write_complete, bool force)
+MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
{
if (!recordable()) {
return;
}
void
-MidiDiskstream::set_block_size (nframes_t nframes)
+MidiDiskstream::set_block_size (nframes_t /*nframes*/)
{
}
}
int
-MidiDiskstream::use_pending_capture_data (XMLNode& node)
+MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
{
return 0;
}
void
-MidiPlaylist::remove_dependents (boost::shared_ptr<Region> region)
+MidiPlaylist::remove_dependents (boost::shared_ptr<Region> /*region*/)
{
/* MIDI regions have no dependents (crossfades) */
}
void
-MidiPlaylist::refresh_dependents (boost::shared_ptr<Region> r)
+MidiPlaylist::refresh_dependents (boost::shared_ptr<Region> /*r*/)
{
/* MIDI regions have no dependents (crossfades) */
}
void
-MidiPlaylist::finalize_split_region (boost::shared_ptr<Region> original, boost::shared_ptr<Region> left, boost::shared_ptr<Region> right)
+MidiPlaylist::finalize_split_region (boost::shared_ptr<Region> /*original*/, boost::shared_ptr<Region> /*left*/, boost::shared_ptr<Region> /*right*/)
{
/* No MIDI crossfading (yet?), so nothing to do here */
}
void
-MidiPlaylist::check_dependents (boost::shared_ptr<Region> r, bool norefresh)
+MidiPlaylist::check_dependents (boost::shared_ptr<Region> /*r*/, bool /*norefresh*/)
{
/* MIDI regions have no dependents (crossfades) */
}
void
-MidiPort::cycle_end (nframes_t nframes)
+MidiPort::cycle_end (nframes_t /*nframes*/)
{
_has_been_mixed_down = false;
}
}
nframes_t
-MidiRegion::_read_at (const SourceList& srcs, MidiRingBuffer<nframes_t>& dst, nframes_t position, nframes_t dur, uint32_t chan_n, NoteMode mode) const
+MidiRegion::_read_at (const SourceList& /*srcs*/, MidiRingBuffer<nframes_t>& dst, nframes_t position, nframes_t dur, uint32_t chan_n, NoteMode mode) const
{
nframes_t internal_offset = 0;
nframes_t src_offset = 0;
}
void
-MidiSource::update_length (sframes_t pos, sframes_t cnt)
+MidiSource::update_length (sframes_t /*pos*/, sframes_t /*cnt*/)
{
// You're not the boss of me!
}
}
void
-MidiTrack::write_controller_messages(MidiBuffer& output_buf, sframes_t start, sframes_t end, nframes_t nframes)
+MidiTrack::write_controller_messages(MidiBuffer& output_buf, sframes_t /*start*/, sframes_t /*end*/, nframes_t nframes)
{
// Append immediate events (UI controls)
}
int
-MidiTrack::export_stuff (BufferSet& bufs, nframes_t nframes, sframes_t end_frame)
+MidiTrack::export_stuff (BufferSet& /*bufs*/, nframes_t /*nframes*/, sframes_t /*end_frame*/)
{
return -1;
}
}
boost::shared_ptr<Region>
-MidiTrack::bounce (InterThreadInfo& itt)
+MidiTrack::bounce (InterThreadInfo& /*itt*/)
{
throw;
// vector<MidiSource*> srcs;
boost::shared_ptr<Region>
-MidiTrack::bounce_range (nframes_t start, nframes_t end, InterThreadInfo& itt, bool enable_processing)
+MidiTrack::bounce_range (nframes_t /*start*/, nframes_t /*end*/, InterThreadInfo& /*itt*/, bool /*enable_processing*/)
{
throw;
//vector<MidiSource*> srcs;
}
void
-MidiTrack::freeze (InterThreadInfo& itt)
+MidiTrack::freeze (InterThreadInfo& /*itt*/)
{
}
}
void
-MTC_Slave::update_mtc_qtr (Parser& p)
+MTC_Slave::update_mtc_qtr (Parser& /*p*/)
{
cycles_t cnow = get_cycles ();
nframes_t now = session.engine().frame_time();
}
int
-NamedSelection::set_state (const XMLNode& node)
+NamedSelection::set_state (const XMLNode& /*node*/)
{
return 0;
}
}
XMLNode&
-EqualPowerStereoPanner::state (bool full_state)
+EqualPowerStereoPanner::state (bool /*full_state*/)
{
XMLNode* root = new XMLNode ("StreamPanner");
char buf[64];
}
void
-Multi2dPanner::distribute_automated (AudioBuffer& src, BufferSet& obufs,
- nframes_t start, nframes_t end, nframes_t nframes,
- pan_t** buffers)
+Multi2dPanner::distribute_automated (AudioBuffer& /*src*/, BufferSet& /*obufs*/,
+ nframes_t /*start*/, nframes_t /*end*/, nframes_t /*nframes*/,
+ pan_t** /*buffers*/)
{
if (_muted) {
return;
}
int
-Multi2dPanner::load (istream& in, string path, uint32_t& linecnt)
+Multi2dPanner::load (istream& /*in*/, string /*path*/, uint32_t& /*linecnt*/)
{
return 0;
}
}
XMLNode&
-Multi2dPanner::state (bool full_state)
+Multi2dPanner::state (bool /*full_state*/)
{
XMLNode* root = new XMLNode ("StreamPanner");
char buf[64];
}
void
-PluginInsert::run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame, nframes_t nframes)
+PluginInsert::run (BufferSet& bufs, sframes_t /*start_frame*/, sframes_t /*end_frame*/, nframes_t nframes)
{
if (_active || _pending_active) {
* (private helper)
*/
int32_t
-PluginInsert::count_for_configuration (ChanCount in, ChanCount out) const
+PluginInsert::count_for_configuration (ChanCount in, ChanCount /*out*/) const
{
if (_plugins.front()->reconfigurable_io()) {
/* plugin has flexible I/O, so the answer is always 1 */
return -1;
}
-static bool ladspa_filter (const string& str, void *arg)
+static bool ladspa_filter (const string& str, void */*arg*/)
{
/* Not a dotfile, has a prefix before a period, suffix is "so" */
}
int
-PluginManager::ladspa_discover_from_path (string path)
+PluginManager::ladspa_discover_from_path (string /*path*/)
{
PathScanner scanner;
vector<string *> *plugin_objects;
return ret;
}
-static bool rdf_filter (const string &str, void *arg)
+static bool rdf_filter (const string &str, void */*arg*/)
{
return str[0] != '.' &&
((str.find(".rdf") == (str.length() - 4)) ||
}
void
-Region::copy_stuff (boost::shared_ptr<const Region> other, nframes_t offset, nframes_t length, const string& name, layer_t layer, Flag flags)
+Region::copy_stuff (boost::shared_ptr<const Region> other, nframes_t /*offset*/, nframes_t length, const string& name, layer_t layer, Flag flags)
{
_frozen = 0;
_pending_changed = Change (0);
}
void
-Region::set_length (nframes_t len, void *src)
+Region::set_length (nframes_t len, void */*src*/)
{
//cerr << "Region::set_length() len = " << len << endl;
if (_flags & Locked) {
}
void
-Region::set_position (nframes_t pos, void *src)
+Region::set_position (nframes_t pos, void */*src*/)
{
if (!can_move()) {
return;
}
void
-Region::set_position_on_top (nframes_t pos, void *src)
+Region::set_position_on_top (nframes_t pos, void */*src*/)
{
if (_flags & Locked) {
return;
}
void
-Region::nudge_position (nframes64_t n, void *src)
+Region::nudge_position (nframes64_t n, void */*src*/)
{
if (_flags & Locked) {
return;
}
void
-Region::set_start (nframes_t pos, void *src)
+Region::set_start (nframes_t pos, void */*src*/)
{
if (_flags & (Locked|PositionLocked)) {
return;
}
void
-Region::trim_start (nframes_t new_position, void *src)
+Region::trim_start (nframes_t new_position, void */*src*/)
{
if (_flags & (Locked|PositionLocked)) {
return;
}
void
-Region::trim_end (nframes_t new_endpoint, void *src)
+Region::trim_end (nframes_t new_endpoint, void */*src*/)
{
if (_flags & Locked) {
return;
}
void
-Region::trim_to_internal (nframes_t position, nframes_t length, void *src)
+Region::trim_to_internal (nframes_t position, nframes_t length, void */*src*/)
{
int32_t start_shift;
nframes_t new_start;
}
XMLNode&
-Region::state (bool full_state)
+Region::state (bool /*full_state*/)
{
XMLNode *node = new XMLNode ("Region");
char buf[64];
}
void
-Region::thaw (const string& why)
+Region::thaw (const string& /*why*/)
{
Change what_changed = Change (0);
void
Route::process_output_buffers (BufferSet& bufs,
sframes_t start_frame, sframes_t end_frame, nframes_t nframes,
- bool with_processors, int declick)
+ bool /*with_processors*/, int declick)
{
bool monitor;
}
int
-Route::_set_state (const XMLNode& node, bool call_base)
+Route::_set_state (const XMLNode& node, bool /*call_base*/)
{
XMLNodeList nlist;
}
int
-Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool active, bool aux)
+Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool /*active*/, bool aux)
{
vector<string> ports;
vector<string>::const_iterator i;
}
void
-Route::handle_transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_processors)
+Route::handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
{
nframes_t now = _session.transport_frame();
}
void
-Route::input_change_handler (IOChange change, void *src)
+Route::input_change_handler (IOChange change, void * /*src*/)
{
if ((change & ConfigurationChanged)) {
configure_processors (0);
}
void
-Route::output_change_handler (IOChange change, void *src)
+Route::output_change_handler (IOChange change, void * /*src*/)
{
if ((change & ConfigurationChanged)) {
int
Route::no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
- bool session_state_changing, bool can_record, bool rec_monitors_input)
+ bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
{
if (n_outputs().n_total() == 0) {
return 0;
int
Route::roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame, int declick,
- bool can_record, bool rec_monitors_input)
+ bool /*can_record*/, bool /*rec_monitors_input*/)
{
{
// automation snapshot can also be called from the non-rt context
}
int
-Route::silent_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
- bool can_record, bool rec_monitors_input)
+Route::silent_roll (nframes_t nframes, sframes_t /*start_frame*/, sframes_t /*end_frame*/,
+ bool /*can_record*/, bool /*rec_monitors_input*/)
{
silence (nframes);
return 0;
*/
void
-Route::shift (nframes64_t pos, nframes64_t frames)
+Route::shift (nframes64_t /*pos*/, nframes64_t /*frames*/)
{
#ifdef THIS_NEEDS_FIXING_FOR_V3
}
void
-Session::locations_added (Location* ignored)
+Session::locations_added (Location *)
{
set_dirty ();
}
}
void
-Session::set_default_fade (float steepness, float fade_msecs)
+Session::set_default_fade (float /*steepness*/, float /*fade_msecs*/)
{
#if 0
nframes_t fade_frames;
}
void
-Session::route_mute_changed (void* src)
+Session::route_mute_changed (void* /*src*/)
{
set_dirty ();
}
void
-Session::route_listen_changed (void* src, boost::weak_ptr<Route> wpr)
+Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
{
boost::shared_ptr<Route> route = wpr.lock();
if (!route) {
}
void
-Session::route_solo_changed (void* src, boost::weak_ptr<Route> wpr)
+Session::route_solo_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
{
if (solo_update_disabled) {
// We know already
}
void
-Session::tempo_map_changed (Change ignored)
+Session::tempo_map_changed (Change)
{
clear_clicks ();
boost::shared_ptr<Region>
Session::write_one_track (AudioTrack& track, nframes_t start, nframes_t end,
- bool overwrite, vector<boost::shared_ptr<Source> >& srcs,
+ bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
InterThreadInfo& itt, bool enable_processing)
{
boost::shared_ptr<Region> result;
}
int
-Session::set_midi_port (string port_tag)
+Session::set_midi_port (string /*port_tag*/)
{
#if 0
if (port_tag.length() == 0) {
}
void
-Session::spp_start (Parser& ignored, nframes_t timestamp)
+Session::spp_start (Parser &, nframes_t /*timestamp*/)
{
if (Config->get_mmc_control() && (Config->get_slave_source() != MTC)) {
request_transport_speed (1.0);
}
void
-Session::spp_stop (Parser& ignored, nframes_t timestamp)
+Session::spp_stop (Parser&, nframes_t /*timestamp*/)
{
if (Config->get_mmc_control()) {
request_stop ();
*/
void
-Session::mmc_deferred_play (MIDI::MachineControl &mmc)
+Session::mmc_deferred_play (MIDI::MachineControl &/*mmc*/)
{
if (Config->get_mmc_control() && (Config->get_slave_source() != MTC)) {
request_transport_speed (1.0);
}
void
-Session::mmc_record_pause (MIDI::MachineControl &mmc)
+Session::mmc_record_pause (MIDI::MachineControl &/*mmc*/)
{
if (Config->get_mmc_control()) {
maybe_enable_record();
}
void
-Session::mmc_record_strobe (MIDI::MachineControl &mmc)
+Session::mmc_record_strobe (MIDI::MachineControl &/*mmc*/)
{
if (!Config->get_mmc_control())
return;
}
void
-Session::mmc_record_exit (MIDI::MachineControl &mmc)
+Session::mmc_record_exit (MIDI::MachineControl &/*mmc*/)
{
if (Config->get_mmc_control()) {
disable_record (false);
}
void
-Session::mmc_stop (MIDI::MachineControl &mmc)
+Session::mmc_stop (MIDI::MachineControl &/*mmc*/)
{
if (Config->get_mmc_control()) {
request_stop ();
}
void
-Session::mmc_pause (MIDI::MachineControl &mmc)
+Session::mmc_pause (MIDI::MachineControl &/*mmc*/)
{
if (Config->get_mmc_control()) {
static bool step_queued = false;
void
-Session::mmc_step (MIDI::MachineControl &mmc, int steps)
+Session::mmc_step (MIDI::MachineControl &/*mmc*/, int steps)
{
if (!Config->get_mmc_control()) {
return;
}
void
-Session::mmc_rewind (MIDI::MachineControl &mmc)
+Session::mmc_rewind (MIDI::MachineControl &/*mmc*/)
{
if (Config->get_mmc_control()) {
request_transport_speed(-8.0f);
}
void
-Session::mmc_fast_forward (MIDI::MachineControl &mmc)
+Session::mmc_fast_forward (MIDI::MachineControl &/*mmc*/)
{
if (Config->get_mmc_control()) {
request_transport_speed(8.0f);
}
void
-Session::mmc_locate (MIDI::MachineControl &mmc, const MIDI::byte* mmc_tc)
+Session::mmc_locate (MIDI::MachineControl &/*mmc*/, const MIDI::byte* mmc_tc)
{
if (!Config->get_mmc_control()) {
return;
}
void
-Session::mmc_shuttle (MIDI::MachineControl &mmc, float speed, bool forw)
+Session::mmc_shuttle (MIDI::MachineControl &/*mmc*/, float speed, bool forw)
{
if (!Config->get_mmc_control()) {
return;
* the first one with the beginning of this cycle as the new start point.
*/
int
-Session::send_full_time_code(nframes_t nframes)
+Session::send_full_time_code(nframes_t /*nframes*/)
{
/* This function could easily send at a given frame offset, but would
* that be useful? Does ardour do sub-block accurate locating? [DR] */
}
boost::shared_ptr<AudioRegion>
-Session::XMLAudioRegionFactory (const XMLNode& node, bool full)
+Session::XMLAudioRegionFactory (const XMLNode& node, bool /*full*/)
{
const XMLProperty* prop;
boost::shared_ptr<Source> source;
}
boost::shared_ptr<MidiRegion>
-Session::XMLMidiRegionFactory (const XMLNode& node, bool full)
+Session::XMLMidiRegionFactory (const XMLNode& node, bool /*full*/)
{
const XMLProperty* prop;
boost::shared_ptr<Source> source;
}
static bool
-state_file_filter (const string &str, void *arg)
+state_file_filter (const string &str, void */*arg*/)
{
return (str.length() > strlen(statefile_suffix) &&
str.find (statefile_suffix) == (str.length() - strlen (statefile_suffix)));
}
static bool
-accept_all_non_peak_files (const string& path, void *arg)
+accept_all_non_peak_files (const string& path, void */*arg*/)
{
return (path.length() > 5 && path.find (peakfile_suffix) != (path.length() - 5));
}
static bool
-accept_all_state_files (const string& path, void *arg)
+accept_all_state_files (const string& path, void */*arg*/)
{
return (path.length() > 7 && path.find (".ardour") == (path.length() - 7));
}
}
void
-Session::jack_timebase_callback (jack_transport_state_t state,
- nframes_t nframes,
+Session::jack_timebase_callback (jack_transport_state_t /*state*/,
+ nframes_t /*nframes*/,
jack_position_t* pos,
- int new_position)
+ int /*new_position*/)
{
BBT_Time bbt;
}
ARDOUR::nframes_t
-Session::convert_to_frames_at (nframes_t position, AnyTime const & any)
+Session::convert_to_frames_at (nframes_t /*position*/, AnyTime const & any)
{
double secs;
}
void
-SndFileImportableSource::seek (nframes_t pos)
+SndFileImportableSource::seek (nframes_t /*pos*/)
{
sf_seek (in.get(), 0, SEEK_SET);
}
}
int
-SndFileSource::setup_broadcast_info (sframes_t when, struct tm& now, time_t tnow)
+SndFileSource::setup_broadcast_info (sframes_t /*when*/, struct tm& now, time_t /*tnow*/)
{
if (!writable()) {
warning << string_compose (_("attempt to store broadcast info in a non-writable audio file source (%1)"), _path) << endmsg;
}
static bool
-template_filter (const string &str, void *arg)
+template_filter (const string &str, void */*arg*/)
{
cerr << "Checking into " << str << " using " << template_suffix << endl;
return (str.length() > strlen(template_suffix) &&
_last_tick = loop_location->start() - elapsed_since_last_tick;
}
-void MidiClockTicker::tick(const nframes_t& transport_frames, const BBT_Time& transport_bbt, const SMPTE::Time& transport_smpt)
+void MidiClockTicker::tick(const nframes_t& transport_frames, const BBT_Time& /*transport_bbt*/, const SMPTE::Time& /*transport_smpt*/)
{
#ifdef WITH_JACK_MIDI
if (!Config->get_send_midi_clock() || _session == 0 || _session->transport_speed() != 1.0f)
int
Track::no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
- bool session_state_changing, bool can_record, bool rec_monitors_input)
+ bool session_state_changing, bool can_record, bool /*rec_monitors_input*/)
{
if (n_outputs().n_total() == 0) {
return 0;
}
int
-Track::silent_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
+Track::silent_roll (nframes_t nframes, sframes_t /*start_frame*/, sframes_t /*end_frame*/,
bool can_record, bool rec_monitors_input)
{
if (n_outputs().n_total() == 0 && _processors.empty()) {
uint32_t
URIMap::uri_map_uri_to_id(LV2_URI_Map_Callback_Data callback_data,
- const char* map,
+ const char* /*map*/,
const char* uri)
{
// TODO: map ignored, < UINT16_MAX assumed
}
void
-ControlList::reposition_for_rt_add (double when)
+ControlList::reposition_for_rt_add (double /*when*/)
{
_rt_insertion_point = _events.end();
}
}
bool
-ControlList::paste (ControlList& alist, double pos, float times)
+ControlList::paste (ControlList& alist, double pos, float /*times*/)
{
if (alist._events.empty()) {
return false;
static int
extract_sysex_event(const unsigned char *buf, const size_t buffer_length, smf_event_t *event, uint32_t *len, int last_status)
{
+ (void) last_status;
+
int status;
int32_t vlq_length, message_length;
const unsigned char *c = buf;
static int
extract_escaped_event(const unsigned char *buf, const size_t buffer_length, smf_event_t *event, uint32_t *len, int last_status)
{
+ (void) last_status;
+
int status;
int32_t message_length, vlq_length;
const unsigned char *c = buf;
}
gint
-AutoSpin::stop_spinning (GdkEventButton *ev)
+AutoSpin::stop_spinning (GdkEventButton */*ev*/)
{
need_timer = false;
stop_timer ();
}
bool
-BarController::expose (GdkEventExpose* event)
+BarController::expose (GdkEventExpose* /*event*/)
{
Glib::RefPtr<Gdk::Window> win (darea.get_window());
Widget* parent;
}
bool
-BarController::entry_focus_out (GdkEventFocus* ev)
+BarController::entry_focus_out (GdkEventFocus* /*ev*/)
{
entry_activated ();
return true;
}
bool
-BarController::entry_input (double* v)
+BarController::entry_input (double* /*v*/)
{
return false;
}
bool
-BindingProxy::prompter_hiding (GdkEventAny *ev)
+BindingProxy::prompter_hiding (GdkEventAny */*ev*/)
{
learning_connection.disconnect ();
if (controllable) {
void
-CellRendererPixbufToggle::render_vfunc (const Glib::RefPtr<Gdk::Drawable>& window, Gtk::Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, Gtk::CellRendererState flags)
+CellRendererPixbufToggle::render_vfunc (const Glib::RefPtr<Gdk::Drawable>& window, Gtk::Widget& /*widget*/, const Gdk::Rectangle& /*background_area*/, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& /*expose_area*/, Gtk::CellRendererState /*flags*/)
{
int offset_width = 0;
int offset_height = 0;
}
void
-CellRendererPixbufToggle::get_size_vfunc (Gtk::Widget& widget, const Gdk::Rectangle* cell_area, int* x_offset, int* y_offset, int* width, int* height) const
+CellRendererPixbufToggle::get_size_vfunc (Gtk::Widget& /*widget*/, const Gdk::Rectangle* /*cell_area*/, int* /*x_offset*/, int* /*y_offset*/, int* /*width*/, int* /*height*/) const
{
//cerr << "cell_renderer_pixbuf_toggle get_size" << endl;
void
ClickBox::default_printer (char buf[32], Gtk::Adjustment &adj,
- void *ignored)
+ void *)
{
sprintf (buf, "%.2f", adj.get_value());
}
}
void
-ClickBox::style_changed (const Glib::RefPtr<Gtk::Style>& ignored)
+ClickBox::style_changed (const Glib::RefPtr<Gtk::Style>&)
{
-
layout->context_changed ();
layout->get_pixel_size (twidth, theight);
}
}
void
-FastMeter::queue_horizontal_redraw (const Glib::RefPtr<Gdk::Window>& win, float old_level)
+FastMeter::queue_horizontal_redraw (const Glib::RefPtr<Gdk::Window>& /*win*/, float /*old_level*/)
{
/* XXX OPTIMIZE (when we have some horizontal meters) */
queue_draw ();
/* END abstract_ui interfaces */
void
-UI::signal_pipe_callback (void *arg, int fd, GdkInputCondition cond)
+UI::signal_pipe_callback (void *arg, int fd, GdkInputCondition /*cond*/)
{
char buf[256];
}
void
-UI::display_message (const char *prefix, gint prefix_len, RefPtr<TextBuffer::Tag> ptag, RefPtr<TextBuffer::Tag> mtag, const char *msg)
+UI::display_message (const char *prefix, gint /*prefix_len*/, RefPtr<TextBuffer::Tag> ptag, RefPtr<TextBuffer::Tag> mtag, const char *msg)
{
RefPtr<TextBuffer> buffer (errors->text().get_buffer());
}
bool
-UI::just_hide_it (GdkEventAny *ev, Window *win)
+UI::just_hide_it (GdkEventAny */*ev*/, Window *win)
{
win->hide ();
return true;
}
bool
-UI::color_selection_deleted (GdkEventAny *ev)
+UI::color_selection_deleted (GdkEventAny */*ev*/)
{
Main::quit ();
return true;
Gtk::SpinButton spinner;
bool use_parent;
- virtual std::string get_label (int& x) {
+ virtual std::string get_label (int& /*x*/) {
return "";
}
}
gint
-PopUp::button_click (GdkEventButton *ev)
+PopUp::button_click (GdkEventButton */*ev*/)
{
remove ();
return TRUE;
}
bool
-PopUp::on_delete_event (GdkEventAny* ev)
+PopUp::on_delete_event (GdkEventAny* /*ev*/)
{
hide();
}
void
-Prompter::change_labels (string okstr, string cancelstr)
+Prompter::change_labels (string /*okstr*/, string /*cancelstr*/)
{
// dynamic_cast<Gtk::Label*>(ok.get_child())->set_text (okstr);
// dynamic_cast<Gtk::Label*>(cancel.get_child())->set_text (cancelstr);
SliderController::SliderController (Glib::RefPtr<Gdk::Pixbuf> image,
Gtk::Adjustment *adj, int orientation,
- bool with_numeric)
+ bool /*with_numeric*/)
: PixFader (image, *adj, orientation),
spin (*adj, 0, 2)
}
gint
-TearOff::tearoff_click (GdkEventButton* ev)
+TearOff::tearoff_click (GdkEventButton* /*ev*/)
{
if (_can_be_torn_off) {
remove (contents);
}
gint
-TearOff::close_click (GdkEventButton* ev)
+TearOff::close_click (GdkEventButton* /*ev*/)
{
window_box.remove (contents);
pack_start (contents);
}
gint
-TearOff::window_button_release (GdkEventButton* ev)
+TearOff::window_button_release (GdkEventButton* /*ev*/)
{
dragging = false;
own_window.remove_modal_grab();
}
gint
-TearOff::window_delete_event (GdkEventAny* ev)
+TearOff::window_delete_event (GdkEventAny* /*ev*/)
{
return close_click(0);
}
}
void
-JACK_MidiPort::set_state (const XMLNode& node)
+JACK_MidiPort::set_state (const XMLNode& /*node*/)
{
}
int _fd;
virtual void open (const Port::Descriptor&);
- virtual int write (byte *msg, size_t msglen, timestamp_t ignored) {
+ virtual int write (byte *msg, size_t msglen, timestamp_t) {
int nwritten;
if ((_mode & O_ACCMODE) == O_RDONLY) {
}
void
-Channel::reset (timestamp_t timestamp, nframes_t nframes, bool notes_off)
+Channel::reset (timestamp_t timestamp, nframes_t /*nframes*/, bool notes_off)
{
_program_number = _channel_number;
_bank_number = 0;
}
void
-Channel::process_note_off (Parser &parser, EventTwoBytes *tb)
-
+Channel::process_note_off (Parser & /*parser*/, EventTwoBytes *tb)
{
_last_note_off = tb->note_number;
_last_off_velocity = tb->velocity;
}
void
-Channel::process_note_on (Parser &parser, EventTwoBytes *tb)
-
+Channel::process_note_on (Parser & /*parser*/, EventTwoBytes *tb)
{
_last_note_on = tb->note_number;
_last_on_velocity = tb->velocity;
}
void
-Channel::process_controller (Parser &parser, EventTwoBytes *tb)
-
+Channel::process_controller (Parser & /*parser*/, EventTwoBytes *tb)
{
unsigned short cv;
}
void
-Channel::process_program_change (Parser &parser, byte val)
-
+Channel::process_program_change (Parser & /*parser*/, byte val)
{
_program_number = val;
}
void
-Channel::process_chanpress (Parser &parser, byte val)
-
+Channel::process_chanpress (Parser & /*parser*/, byte val)
{
_chanpress = val;
}
void
-Channel::process_polypress (Parser &parser, EventTwoBytes *tb)
-
+Channel::process_polypress (Parser & /*parser*/, EventTwoBytes *tb)
{
_polypress[tb->note_number] = tb->value;
}
void
-Channel::process_pitchbend (Parser &parser, pitchbend_t val)
-
+Channel::process_pitchbend (Parser & /*parser*/, pitchbend_t val)
{
_pitch_bend = val;
}
void
-Channel::process_reset (Parser &parser)
-
+Channel::process_reset (Parser & /*parser*/)
{
reset (0, 1);
}
}
int
+#if defined (WITH_ALSA) || defined (WITH_COREMIDI)
PortFactory::get_known_ports (vector<PortSet>& ports)
+#else
+PortFactory::get_known_ports (vector<PortSet>&)
+#endif
{
int n = 0;
#ifdef WITH_ALSA
}
void
-Parser::trace_event (Parser &p, byte *msg, size_t len)
+Parser::trace_event (Parser &, byte *msg, size_t len)
{
eventType type;
ostream *o;
}
void
-Port::set_state (const XMLNode& node)
+Port::set_state (const XMLNode& /*node*/)
{
// relax
}
void
-Port::gtk_read_callback (void *ptr, int fd, int cond)
+Port::gtk_read_callback (void *ptr, int /*fd*/, int /*cond*/)
{
byte buf[64];
((Port *)ptr)->read (buf, sizeof (buf));
}
-MachineControl::MachineControl (Port &p, float version,
- CommandSignature &csig,
- ResponseSignature &rsig)
+MachineControl::MachineControl (Port &p, float /*version*/,
+ CommandSignature & /*csig*/,
+ ResponseSignature & /*rsig*/)
: _port (p)
{
}
void
-MachineControl::process_mmc_message (Parser &p, byte *msg, size_t len)
+MachineControl::process_mmc_message (Parser &, byte *msg, size_t len)
{
size_t skiplen;
}
void
-MachineControl::write_track_record_ready (byte *msg, size_t len)
+MachineControl::write_track_record_ready (byte *msg, size_t /*len*/)
{
size_t n;
}
int
-MachineControl::do_locate (byte *msg, size_t msglen)
+MachineControl::do_locate (byte *msg, size_t /*msglen*/)
{
if (msg[2] == 0) {
}
int
-MachineControl::do_step (byte *msg, size_t msglen)
+MachineControl::do_step (byte *msg, size_t /*msglen*/)
{
int steps = msg[2] & 0x3f;
}
int
-MachineControl::do_shuttle (byte *msg, size_t msglen)
+MachineControl::do_shuttle (byte *msg, size_t /*msglen*/)
{
size_t forward;
string *
PathScanner::find_first (const string &dirpath,
bool (*filter)(const string &, void *),
- void *arg,
+ void * /*arg*/,
bool match_fullpath,
bool return_fullpath)
{
IgnorableControllable () : PBD::Controllable ("ignoreMe") {}
~IgnorableControllable () {}
- void set_value (float v){}
+ void set_value (float /*v*/) {}
float get_value () const { return 0.0; }
};
#else
void
-PBD::stacktrace (std::ostream& out, int levels)
+PBD::stacktrace (std::ostream& out, int /*levels*/)
{
out << "stack tracing is not enabled on this platform" << std::endl;
}
}
float
-HighFrequencyAudioCurve::process(const float *R__ mag, size_t increment)
+HighFrequencyAudioCurve::process(const float *R__ mag, size_t /*increment*/)
{
float result = 0.0;
}
float
-HighFrequencyAudioCurve::processDouble(const double *R__ mag, size_t increment)
+HighFrequencyAudioCurve::processDouble(const double *R__ mag, size_t /*increment*/)
{
float result = 0.0;
}
float
-PercussiveAudioCurve::process(const float *R__ mag, size_t increment)
+PercussiveAudioCurve::process(const float *R__ mag, size_t /*increment*/)
{
static float threshold = powf(10.f, 0.15f); // 3dB rise in square of magnitude
static float zeroThresh = powf(10.f, -8);
}
float
-PercussiveAudioCurve::processDouble(const double *R__ mag, size_t increment)
+PercussiveAudioCurve::processDouble(const double *R__ mag, size_t /*increment*/)
{
Profiler profiler("PercussiveAudioCurve::process");
}
float
-SpectralDifferenceAudioCurve::process(const float *R__ mag, size_t increment)
+SpectralDifferenceAudioCurve::process(const float *R__ mag, size_t /*increment*/)
{
float result = 0.0;
}
float
-SpectralDifferenceAudioCurve::processDouble(const double *R__ mag, size_t increment)
+SpectralDifferenceAudioCurve::processDouble(const double *R__ mag, size_t /*increment*/)
{
float result = 0.0;
}
}
-Condition::Condition(string name) :
+Condition::Condition(string /*name*/) :
m_locked(false)
#ifdef DEBUG_CONDITION
, m_name(name)
virtual int set_active (bool yn) = 0;
bool get_active() const { return _active; }
- virtual int set_feedback (bool yn) { return 0; }
+ virtual int set_feedback (bool /*yn*/) { return 0; }
virtual bool get_feedback () const { return false; }
virtual void route_list_changed () {}
}
int
-GenericMidiControlProtocol::set_active (bool yn)
+GenericMidiControlProtocol::set_active (bool /*yn*/)
{
/* start/stop delivery/outbound thread */
return 0;
using namespace ARDOUR;
ControlProtocol*
-new_generic_midi_protocol (ControlProtocolDescriptor* descriptor, Session* s)
+new_generic_midi_protocol (ControlProtocolDescriptor* /*descriptor*/, Session* s)
{
GenericMidiControlProtocol* gmcp;
}
void
-delete_generic_midi_protocol (ControlProtocolDescriptor* descriptor, ControlProtocol* cp)
+delete_generic_midi_protocol (ControlProtocolDescriptor* /*descriptor*/, ControlProtocol* cp)
{
delete cp;
}
bool
-probe_generic_midi_protocol (ControlProtocolDescriptor* descriptor)
+probe_generic_midi_protocol (ControlProtocolDescriptor* /*descriptor*/)
{
return GenericMidiControlProtocol::probe ();
}
}
void
-MIDIControllable::midi_sense_note (Parser &p, EventTwoBytes *msg, bool is_on)
+MIDIControllable::midi_sense_note (Parser &, EventTwoBytes *msg, bool is_on)
{
if (!bistate) {
controllable.set_value (msg->note_number/127.0);
}
void
-MIDIControllable::midi_sense_program_change (Parser &p, byte msg)
+MIDIControllable::midi_sense_program_change (Parser &, byte msg)
{
/* XXX program change messages make no sense for bistates */
}
void
-MIDIControllable::midi_sense_pitchbend (Parser &p, pitchbend_t pb)
+MIDIControllable::midi_sense_pitchbend (Parser &, pitchbend_t pb)
{
/* pitchbend messages make no sense for bistates */
}
void
-MIDIControllable::midi_receiver (Parser &p, byte *msg, size_t len)
+MIDIControllable::midi_receiver (Parser &, byte *msg, size_t /*len*/)
{
/* we only respond to channel messages */
}
MIDI::byte*
-MIDIControllable::write_feedback (MIDI::byte* buf, int32_t& bufsize, bool force)
+MIDIControllable::write_feedback (MIDI::byte* buf, int32_t& bufsize, bool /*force*/)
{
if (control_type != none && feedback && bufsize > 2) {
using namespace ARDOUR;
ControlProtocol*
-new_osc_protocol (ControlProtocolDescriptor* descriptor, Session* s)
+new_osc_protocol (ControlProtocolDescriptor* /*descriptor*/, Session* s)
{
OSC* osc = new OSC (*s, Config->get_osc_port());
}
void
-delete_osc_protocol (ControlProtocolDescriptor* descriptor, ControlProtocol* cp)
+delete_osc_protocol (ControlProtocolDescriptor* /*descriptor*/, ControlProtocol* cp)
{
delete cp;
}
bool
-probe_osc_protocol (ControlProtocolDescriptor* descriptor)
+probe_osc_protocol (ControlProtocolDescriptor* /*descriptor*/)
{
return true; // we can always do OSC
}
using namespace std;
+#ifdef DEBUG
static void error_callback(int num, const char *m, const char *path)
{
-#ifdef DEBUG
fprintf(stderr, "liblo server error %d in path %s: %s\n", num, path, m);
-#endif
}
+#else
+static void error_callback(int, const char *, const char *)
+{
+
+}
+#endif
OSC::OSC (Session& s, uint32_t port)
: ControlProtocol (s, "OSC")
}
void
-OSC::route_added (RouteList& rl)
+OSC::route_added (RouteList&)
{
}
/* path callbacks */
int
-OSC::current_value (const char *path, const char *types, lo_arg **argv, int argc, void *data, void* user_data)
+OSC::current_value (const char */*path*/, const char */*types*/, lo_arg **/*argv*/, int /*argc*/, void */*data*/, void* /*user_data*/)
{
#if 0
const char* returl;
static int _ ## name (const char *path, const char *types, lo_arg **argv, int argc, void *data, void *user_data) { \
return static_cast<OSC*>(user_data)->cb_ ## name (path, types, argv, argc, data); \
} \
- int cb_ ## name (const char *path, const char *types, lo_arg **argv, int argc, void *data) { \
+ int cb_ ## name (const char *, const char *, lo_arg **, int, void *) { \
name (); \
return 0; \
}
static int _ ## name (const char *path, const char *types, lo_arg **argv, int argc, void *data, void *user_data) { \
return static_cast<OSC*>(user_data)->cb_ ## name (path, types, argv, argc, data); \
} \
- int cb_ ## name (const char *path, const char *types, lo_arg **argv, int argc, void *data) { \
+ int cb_ ## name (const char *, const char *, lo_arg **argv, int argc, void *) { \
if (argc > 0) { \
name (optional argv[0]->type); \
} \
static int _ ## name (const char *path, const char *types, lo_arg **argv, int argc, void *data, void *user_data) { \
return static_cast<OSC*>(user_data)->cb_ ## name (path, types, argv, argc, data); \
} \
- int cb_ ## name (const char *path, const char *types, lo_arg **argv, int argc, void *data) { \
+ int cb_ ## name (const char *, const char *, lo_arg **argv, int argc, void *) { \
if (argc > 1) { \
name (argv[0]->arg1type, argv[1]->arg2type); \
} \
}
int
-OSCControllable::set_state (const XMLNode& node)
+OSCControllable::set_state (const XMLNode& /*node*/)
{
return 0;
}
using namespace ARDOUR;
ControlProtocol*
-new_powermate_protocol (ControlProtocolDescriptor* descriptor, Session* s)
+new_powermate_protocol (ControlProtocolDescriptor* /*descriptor*/, Session* s)
{
PowermateControlProtocol* pcp = new PowermateControlProtocol (*s);
}
void
-delete_powermate_protocol (ControlProtocolDescriptor* descriptor, ControlProtocol* cp)
+delete_powermate_protocol (ControlProtocolDescriptor* /*descriptor*/, ControlProtocol* cp)
{
delete cp;
}
bool
-probe_powermate_protocol (ControlProtocolDescriptor* descriptor)
+probe_powermate_protocol (ControlProtocolDescriptor* /*descriptor*/)
{
return PowermateControlProtocol::probe ();
}
}
int
-PowermateControlProtocol::set_state (const XMLNode& node)
+PowermateControlProtocol::set_state (const XMLNode& /*node*/)
{
return 0;
}
AmplitudeFollower::FeatureSet
AmplitudeFollower::process(const float *const *inputBuffers,
- Vamp::RealTime timestamp)
+ Vamp::RealTime /*timestamp*/)
{
if (m_stepSize == 0) {
cerr << "ERROR: AmplitudeFollower::process: "
}
void
-PluginAdapterBase::Impl::vampReleaseFeatureSet(VampFeatureList *fs)
+PluginAdapterBase::Impl::vampReleaseFeatureSet(VampFeatureList */*fs*/)
{
#ifdef DEBUG_PLUGIN_ADAPTER
std::cerr << "PluginAdapterBase::Impl::vampReleaseFeatureSet" << std::endl;
projects / ardour.git / commitdiff