#include "public_editor.h"
#include "utils.h"
+using namespace std;
using namespace sigc;
using namespace Gtk;
if (likely_new) {
- ustring existing = Glib::build_filename (session_path, session_name);
+ Glib::ustring existing = Glib::build_filename (session_path, session_name);
if (!ask_about_loading_existing_session (existing)) {
ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
int unload_session (bool hide_stuff = false);
void close_session();
- int save_state_canfail (string state_name = "");
- void save_state (const string & state_name = "");
+ int save_state_canfail (std::string state_name = "");
+ void save_state (const std::string & state_name = "");
static double gain_to_slider_position (ARDOUR::gain_t g);
static ARDOUR::gain_t slider_position_to_gain (double pos);
static sigc::signal<void> SuperRapidScreenUpdate;
static sigc::signal<void,nframes_t, bool, nframes_t> Clock;
- void name_io_setup (ARDOUR::AudioEngine&, string&, ARDOUR::IO& io, bool in);
+ void name_io_setup (ARDOUR::AudioEngine&, std::string&, ARDOUR::IO& io, bool in);
XMLNode* editor_settings() const;
XMLNode* mixer_settings () const;
void startup ();
void shutdown ();
- int ask_about_saving_session (const string & why);
+ int ask_about_saving_session (const std::string & why);
/* periodic safety backup, to be precise */
gint autosave_session();
void recent_session_row_activated (const Gtk::TreePath& path, Gtk::TreeViewColumn* col);
struct RecentSessionsSorter {
- bool operator() (std::pair<string,string> a, std::pair<string,string> b) const {
+ bool operator() (std::pair<std::string,std::string> a, std::pair<std::string,std::string> b) const {
return cmp_nocase(a.first, b.first) == -1;
}
};
Gtk::MenuItem *cleanup_item;
- void display_cleanup_results (ARDOUR::Session::cleanup_report& rep, const gchar* list_title, const string & msg);
+ void display_cleanup_results (ARDOUR::Session::cleanup_report& rep, const gchar* list_title, const std::string & msg);
void cleanup ();
void flush_trash ();
#define MUTED_ALPHA 10
+using namespace std;
using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
WaveformLogScaled = 0x10,
};
- vector<ArdourCanvas::WaveView *> waves;
- vector<ArdourCanvas::WaveView *> tmp_waves; ///< see ::create_waves()
+
std::vector<ArdourCanvas::WaveView *> waves;
+
std::vector<ArdourCanvas::WaveView *> tmp_waves; ///< see ::create_waves()
ArdourCanvas::Polygon* sync_mark; ///< polgyon for sync position
ArdourCanvas::SimpleLine* zero_line;
ArdourCanvas::Polygon* fade_in_shape;
void color_handler ();
- vector<GnomeCanvasWaveViewCache*> wave_caches;
+ std::vector<GnomeCanvasWaveViewCache*> wave_caches;
private:
double _amplitude_above_axis;
- typedef list<CrossfadeView*> CrossfadeViewList;
+ typedef std::list<CrossfadeView*> CrossfadeViewList;
CrossfadeViewList crossfade_views;
bool crossfades_visible;
std::list<sigc::connection> rec_data_ready_connections;
nframes_t last_rec_data_frame;
- map<boost::shared_ptr<ARDOUR::Source>, bool> rec_data_ready_map;
+
std::map<boost::shared_ptr<ARDOUR::Source>, bool> rec_data_ready_map;
bool outline_region;
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
void first_idle ();
- XMLNode* get_child_xml_node (const string & childname);
+ XMLNode* get_child_xml_node (const std::string & childname);
void set_waveform_shape (Editing::WaveformShape);
void set_waveform_scale (Editing::WaveformScale);
class AutomationLine : public sigc::trackable, public PBD::StatefulThingWithGoingAway
{
public:
- AutomationLine (const string& name, TimeAxisView&, ArdourCanvas::Group&,
+ AutomationLine (const std::string& name, TimeAxisView&, ArdourCanvas::Group&,
boost::shared_ptr<ARDOUR::AutomationList>,
const Evoral::TimeConverter<double, ARDOUR::sframes_t>* converter = 0);
virtual ~AutomationLine ();
ControlPoint* nth (uint32_t);
uint32_t npoints() const { return control_points.size(); }
- string name() const { return _name; }
+ std::string name() const { return _name; }
bool visible() const { return _visible; }
guint32 height() const { return _height; }
void show_selection();
void hide_selection ();
- string get_verbose_cursor_string (double) const;
- string fraction_to_string (double) const;
- double string_to_fraction (string const &) const;
+ std::string get_verbose_cursor_string (double) const;
+ std::string fraction_to_string (double) const;
+ double string_to_fraction (std::string const &) const;
void view_to_model_coord (double& x, double& y) const;
void model_to_view_coord (double& x, double& y) const;
protected:
- string _name;
+ std::string _name;
guint32 _height;
uint32_t _line_color;
class AutomationList;
}
-struct AutomationSelection :
list< boost::shared_ptr<ARDOUR::AutomationList> > {};
+struct AutomationSelection :
std::list<boost::shared_ptr<ARDOUR::AutomationList> > {};
#endif /* __ardour_gtk_automation_selection_h__ */
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
#ifndef __ardour_gtk_automation_time_axis_h__
#define __ardour_gtk_automation_time_axis_h__
-#include <vector>
#include <list>
#include <string>
#include <utility>
#include "simplerect.h"
#include "automation_controller.h"
-using std::vector;
-using std::list;
-using std::string;
-
namespace ARDOUR {
class Session;
class Route;
TimeAxisView& parent,
bool show_regions,
ArdourCanvas::Canvas& canvas,
- const string & name, /* translatable */
- const string & plug_name = "");
+ const std::string & name, /* translatable */
+ const std::string & plug_name = "");
~AutomationTimeAxisView();
boost::shared_ptr<AutomationLine> line() { return _line; }
void set_selected_points (PointSelection&);
- void get_selectables (nframes_t start, nframes_t end, double top, double bot, list<Selectable *>&);
- void get_inverted_selectables (Selection&, list<Selectable*>& results);
+ 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 hide_timestretch () {}
guint32 show_at (double y, int& nth, Gtk::VBox *parent);
void hide ();
- static const string state_node_name;
+ static const std::string state_node_name;
XMLNode* get_state_node();
boost::shared_ptr<ARDOUR::AutomationControl> control() { return _control; }
boost::shared_ptr<AutomationLine> _line;
AutomationStreamView* _view;
- string _name;
+ std::string _name;
bool ignore_toggle;
bool first_call_to_set_height;
#include "axis_view.h"
#include "i18n.h"
+using namespace std;
using namespace Gtk;
using namespace Gtkmm2ext;
-
list<Gdk::Color> AxisView::used_colors;
AxisView::AxisView (ARDOUR::Session& sess) : _session(sess)
ARDOUR::Session& session() const { return _session; }
- virtual string name() const = 0;
+ virtual std::string name() const = 0;
virtual bool marked_for_display() const { return _marked_for_display; }
virtual void set_marked_for_display (bool yn) {
ARDOUR::Session& _session;
Gdk::Color _color;
- static list<Gdk::Color> used_colors;
+ static std::list<Gdk::Color> used_colors;
Gtk::Label name_label;
: x (a), y (b) {}
};
- struct Preset : public list<PresetPoint> {
+ struct Preset : public
std::list<PresetPoint> {
const char* name;
const char* image_name;
Preset (const char* n, const char* x) : name (n), image_name (x) {}
};
- typedef list<Preset*> Presets;
+ typedef
std::list<Preset*> Presets;
static Presets* fade_in_presets;
static Presets* fade_out_presets;
struct Half {
ArdourCanvas::Line* line;
ArdourCanvas::Polygon* shading;
- list<Point*> points;
+ std::list<Point*> points;
ARDOUR::AutomationList normative_curve; /* 0 - 1.0, linear */
ARDOUR::AutomationList gain_curve; /* 0 - 2.0, gain mapping */
- vector<ArdourCanvas::WaveView*> waves;
+
std::vector<ArdourCanvas::WaveView*> waves;
Half();
};
WhichFade current;
bool point_grabbed;
- vector<Gtk::Button*> fade_out_buttons;
- vector<Gtk::Button*> fade_in_buttons;
+ std::vector<Gtk::Button*> fade_out_buttons;
+ std::vector<Gtk::Button*> fade_in_buttons;
Gtk::VBox vpacker2;
void hide();
void show ();
- void set_name (const string&);
+ void set_name (const std::string&);
void set_position (nframes64_t start, nframes64_t end = 0);
void set_color_rgba (uint32_t);
};
void hide_marker (ArdourCanvas::Item*, GdkEvent*);
void clear_marker_display ();
void mouse_add_new_marker (nframes64_t where, bool is_cd=false, bool is_xrun=false);
- bool choose_new_marker_name(string &name);
+ bool choose_new_marker_name(std::string &name);
void update_cd_marker_display ();
void ensure_cd_marker_updated (LocationMarkers * lam, ARDOUR::Location * location);
/* functions to be passed to mapover_tracks(), possibly with sigc::bind()-supplied arguments */
- void mapped_get_equivalent_regions (RouteTimeAxisView&, uint32_t, RegionView*, vector<RegionView*>*) const;
- void mapped_use_new_playlist (RouteTimeAxisView&, uint32_t, vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
- void mapped_use_copy_playlist (RouteTimeAxisView&, uint32_t, vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
+ void mapped_get_equivalent_regions (RouteTimeAxisView&, uint32_t, RegionView*, std::vector<RegionView*>*) const;
+ void mapped_use_new_playlist (RouteTimeAxisView&, uint32_t,
std::vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
+ void mapped_use_copy_playlist (RouteTimeAxisView&, uint32_t,
std::vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
void mapped_clear_playlist (RouteTimeAxisView&, uint32_t);
/* end */
bool track_canvas_motion (GdkEvent*);
- void set_verbose_canvas_cursor (const string &, double x, double y);
- void set_verbose_canvas_cursor_text (const string &);
+ void set_verbose_canvas_cursor (const std::string &, double x, double y);
+ void set_verbose_canvas_cursor_text (const std::string &);
void show_verbose_canvas_cursor();
void hide_verbose_canvas_cursor();
boost::shared_ptr<ARDOUR::Region> find_next_region (nframes64_t, ARDOUR::RegionPoint, int32_t dir, TrackViewList&, TimeAxisView ** = 0);
nframes64_t find_next_region_boundary (nframes64_t, int32_t dir, const TrackViewList&);
- vector<nframes64_t> region_boundary_cache;
+ std::vector<nframes64_t> region_boundary_cache;
void build_region_boundary_cache ();
Gtk::HBox top_hbox;
int ensure_cursor (nframes64_t* pos);
void handle_new_region (boost::weak_ptr<ARDOUR::Region>);
- void handle_new_regions (vector<boost::weak_ptr<ARDOUR::Region> >& );
+ void handle_new_regions (
std::vector<boost::weak_ptr<ARDOUR::Region> >& );
void handle_region_removed (boost::weak_ptr<ARDOUR::Region>);
void add_region_to_region_display (boost::shared_ptr<ARDOUR::Region>);
void add_regions_to_region_display (std::vector<boost::weak_ptr<ARDOUR::Region> > & );
bool no_region_list_redisplay;
void insert_into_tmp_regionlist(boost::shared_ptr<ARDOUR::Region>);
- list<boost::shared_ptr<ARDOUR::Region> > tmp_region_list;
+
std::list<boost::shared_ptr<ARDOUR::Region> > tmp_region_list;
void cut_copy (Editing::CutCopyOp);
bool can_cut_copy () const;
bool zoomed_to_region;
void temporal_zoom_session ();
void temporal_zoom (gdouble scale);
- void temporal_zoom_by_frame (nframes64_t start, nframes64_t end, const string & op);
+ void temporal_zoom_by_frame (nframes64_t start, nframes64_t end, const std::string & op);
void temporal_zoom_to_frame (bool coarser, nframes64_t frame);
void amplitude_zoom (gdouble scale);
void external_audio_dialog ();
void session_import_dialog ();
- int check_whether_and_how_to_import(string, bool all_or_nothing = true);
+ int check_whether_and_how_to_import(std::string, bool all_or_nothing = true);
bool check_multichannel_status (const std::vector<Glib::ustring>& paths);
SoundFileOmega* sfbrowser;
bool idle_drop_paths (std::vector<Glib::ustring> paths, nframes64_t frame, double ypos);
void drop_paths_part_two (const std::vector<Glib::ustring>& paths, nframes64_t frame, double ypos);
- void do_import (vector<Glib::ustring> paths, Editing::ImportDisposition, Editing::ImportMode mode, ARDOUR::SrcQuality, nframes64_t&);
- void do_embed (vector<Glib::ustring> paths, Editing::ImportDisposition, Editing::ImportMode mode, nframes64_t&);
+ void do_import (std::vector<Glib::ustring> paths, Editing::ImportDisposition, Editing::ImportMode mode, ARDOUR::SrcQuality, nframes64_t&);
+ void do_embed (std::vector<Glib::ustring> paths, Editing::ImportDisposition, Editing::ImportMode mode, nframes64_t&);
- int import_sndfiles (vector<Glib::ustring> paths, Editing::ImportMode mode, ARDOUR::SrcQuality, nframes64_t& pos,
+ int import_sndfiles (std::vector<Glib::ustring> paths, Editing::ImportMode mode, ARDOUR::SrcQuality, nframes64_t& pos,
int target_regions, int target_tracks, boost::shared_ptr<ARDOUR::Track>, bool, uint32_t total);
- int embed_sndfiles (vector<Glib::ustring> paths, bool multiple_files, bool& check_sample_rate, Editing::ImportMode mode,
+ int embed_sndfiles (std::vector<Glib::ustring> paths, bool multiple_files, bool& check_sample_rate, Editing::ImportMode mode,
nframes64_t& pos, int target_regions, int target_tracks, boost::shared_ptr<ARDOUR::Track>&);
- int add_sources (vector<Glib::ustring> paths, ARDOUR::SourceList& sources, nframes64_t& pos, Editing::ImportMode,
+ int add_sources (std::vector<Glib::ustring> paths, ARDOUR::SourceList& sources, nframes64_t& pos, Editing::ImportMode,
int target_regions, int target_tracks, boost::shared_ptr<ARDOUR::Track>&, bool add_channel_suffix);
int finish_bringing_in_material (boost::shared_ptr<ARDOUR::Region> region, uint32_t, uint32_t, nframes64_t& pos, Editing::ImportMode mode,
boost::shared_ptr<ARDOUR::Track>& existing_track);
/* to support this ... */
void import_audio (bool as_tracks);
- void do_import (vector<Glib::ustring> paths, bool split, bool as_tracks);
+ void do_import (std::vector<Glib::ustring> paths, bool split, bool as_tracks);
void move_to_start ();
void move_to_end ();
/// Snap threshold in pixels
double snap_threshold;
- void handle_gui_changes (const string &, void *);
+ void handle_gui_changes (const std::string &, void *);
bool ignore_gui_changes;
void hide_all_tracks (bool with_select);
Gtk::Menu* cd_marker_menu;
ArdourCanvas::Item* marker_menu_item;
- typedef list<Marker*> Marks;
+ typedef std::list<Marker*> Marks;
Marks metric_marks;
void remove_metric_marks ();
/* audio export */
int write_region_selection(RegionSelection&);
- bool write_region (string path, boost::shared_ptr<ARDOUR::AudioRegion>);
+ bool write_region (st
d::string path, boost::shared_ptr<ARDOUR::AudioRegion>);
void bounce_region_selection ();
void bounce_range_selection (bool replace, bool enable_processing);
void external_edit_region ();
int write_audio_selection (TimeSelection&);
- bool write_audio_range (ARDOUR::AudioPlaylist&, const ARDOUR::ChanCount& channels, list<ARDOUR::AudioRange>&);
+ bool write_audio_range (ARDOUR::AudioPlaylist&, const ARDOUR::ChanCount& channels,
std::list<ARDOUR::AudioRange>&);
void write_selection ();
XMLNode *before; /* used in *_reversible_command */
- void begin_reversible_command (string cmd_name);
+ void begin_reversible_command (std::string cmd_name);
void commit_reversible_command ();
void update_title ();
- void update_title_s (const string & snapshot_name);
+ void update_title_s (const std::string & snapshot_name);
struct State {
Selection* selection;
bool _xfade_visibility;
#ifdef WITH_CMT
- void handle_new_imageframe_time_axis_view(const string & track_name, void* src) ;
- void handle_new_imageframe_marker_time_axis_view(const string & track_name, TimeAxisView* marked_track) ;
+ void handle_new_imageframe_time_axis_view(const std::string & track_name, void* src) ;
+ void handle_new_imageframe_marker_time_axis_view(const std::string & track_name, TimeAxisView* marked_track) ;
void start_imageframe_grab(ArdourCanvas::Item*, GdkEvent*) ;
void start_markerview_grab(ArdourCanvas::Item*, GdkEvent*) ;
/* audio filters */
- void apply_filter (ARDOUR::Filter&, string cmd);
+ void apply_filter (ARDOUR::Filter&, std::string cmd);
/* handling cleanup */
int playlist_deletion_dialog (boost::shared_ptr<ARDOUR::Playlist>);
- vector<sigc::connection> session_connections;
+ std::vector<sigc::connection> session_connections;
/* tracking step changes of track height */
bool on_key_press_event (GdkEventKey*);
bool on_key_release_event (GdkEventKey*);
- void session_state_saved (string);
+ void session_state_saved (std::string);
Glib::RefPtr<Gtk::Action> undo_action;
Glib::RefPtr<Gtk::Action> redo_action;
#include "i18n.h"
+using namespace std;
using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
#include "i18n.h"
+using namespace std;
using namespace Gtkmm2ext;
using namespace PBD;
#include "i18n.h"
+using namespace std;
using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
#include "i18n.h"
+using namespace std;
using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
#include "i18n.h"
+using namespace std;
using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
std::map<std::string,std::vector<std::string> > devices;
std::vector<std::string> backend_devs;
- void enumerate_devices (const string& driver);
+ void enumerate_devices (const std::string& driver);
#ifdef __APPLE__
std::vector<std::string> enumerate_coreaudio_devices ();
#include "i18n.h"
+using namespace std;
+using namespace Glib;
using namespace ARDOUR;
using namespace PBD;
if (!warnings->conflicting_filenames.empty()) {
list_files_hbox.show ();
for (std::list<Glib::ustring>::iterator it = warnings->conflicting_filenames.begin(); it != warnings->conflicting_filenames.end(); ++it) {
- ustring::size_type pos = it->find_last_of ("/");
+ Glib::ustring::size_type pos = it->find_last_of ("/");
list_files_string += "\n" + it->substr (0, pos + 1) + "<b>" + it->substr (pos + 1) + "</b>";
}
}
#include <gtkmm.h>
#include <boost/shared_ptr.hpp>
-using std::list;
using ARDOUR::ExportProfileManager;
class ExportMultiplicator : public Gtk::EventBox {
#include "i18n.h"
+using namespace Glib;
using namespace ARDOUR;
using namespace PBD;
#include "simplerect.h"
#include "waveview.h"
+using namespace std;
using namespace Editing;
using namespace ArdourCanvas;
using namespace ARDOUR;
#include "selection.h"
-using std::string;
-
class Keyboard : public sigc::trackable, PBD::Stateful
{
public:
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
#include "i18n.h"
+using namespace std;
using namespace Gtk;
using namespace ARDOUR_COMMAND_LINE;
using namespace ARDOUR;
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
Marker::Marker (PublicEditor& ed, ArdourCanvas::Group& parent, guint32 rgba, const string& annotation,
};
- Marker (PublicEditor& editor, ArdourCanvas::Group& parent, guint32 rgba, const string& text, Type,
+ Marker (PublicEditor& editor, ArdourCanvas::Group& parent, guint32 rgba, const std::string& text, Type,
nframes_t frame = 0, bool handle_events = true);
virtual ~Marker ();
void set_line_vpos (double y_origin, double height);
void set_position (nframes_t);
- void set_name (const string&);
+ void set_name (const std::string&);
void set_color_rgba (uint32_t rgba);
nframes64_t position() const { return frame_position; }
class TempoMarker : public Marker
{
public:
- TempoMarker (PublicEditor& editor, ArdourCanvas::Group& parent, guint32 rgba, const string& text, ARDOUR::TempoSection&);
+ TempoMarker (PublicEditor& editor, ArdourCanvas::Group& parent, guint32 rgba, const std::string& text, ARDOUR::TempoSection&);
~TempoMarker ();
ARDOUR::TempoSection& tempo() const { return _tempo; }
class MeterMarker : public Marker
{
public:
- MeterMarker (PublicEditor& editor, ArdourCanvas::Group& parent, guint32 rgba, const string& text, ARDOUR::MeterSection&);
+ MeterMarker (PublicEditor& editor, ArdourCanvas::Group& parent, guint32 rgba, const std::string& text, ARDOUR::MeterSection&);
~MeterMarker ();
ARDOUR::MeterSection& meter() const { return _meter; }
~MidiStreamView ();
void set_selected_regionviews (RegionSelection&);
- void get_selectables (jack_nframes_t start, jack_nframes_t end, list<Selectable* >&);
- void get_inverted_selectables (Selection&, list<Selectable* >& results);
+ void get_selectables (jack_nframes_t start, jack_nframes_t end, std::list<Selectable* >&);
+ void get_inverted_selectables (Selection&, std::list<Selectable* >& results);
enum VisibleNoteRange {
FullRange,
return _channel_selector.mode_changed;
}
- sigc::signal<void, string, string>& signal_midi_patch_settings_changed() {
+ sigc::signal<void, std::string, std::string>& signal_midi_patch_settings_changed() {
return _midi_patch_settings_changed;
}
private:
- sigc::signal<void, string, string> _midi_patch_settings_changed;
+ sigc::signal<void, std::string, std::string> _midi_patch_settings_changed;
void model_changed();
void custom_device_mode_changed();
Gtk::Style *passthru_style;
- void route_gui_changed (string, void*);
+ void route_gui_changed (std::string, void*);
void show_route_color ();
void show_passthru_color ();
void pane_allocation_handler (Gtk::Allocation&, Gtk::Paned*);
- list<MixerStrip *> strips;
+ std::list<MixerStrip *> strips;
bool strip_scroller_button_release (GdkEventButton*);
void setup_click_editor ();
void clear_click_editor ();
- void click_chosen (const string & paths);
- void click_emphasis_chosen (const string & paths);
+ void click_chosen (const std::string & paths);
+ void click_emphasis_chosen (const std::string & paths);
void click_browse_clicked ();
void click_emphasis_browse_clicked ();
#include <string>
#include <glibmm/ustring.h>
-using std::string;
-
namespace ARDOUR_COMMAND_LINE {
-extern string session_name;
+extern std::string session_name;
extern bool show_key_actions;
extern bool no_splash;
extern bool just_version;
-extern string jack_client_name;
+extern std::string jack_client_name;
extern bool use_vst;
extern bool new_session;
extern char* curvetest_file;
extern bool try_hw_optimization;
extern bool use_gtk_theme;
-extern string keybindings_path;
+extern std::string keybindings_path;
extern Glib::ustring menus_file;
extern bool finder_invoked_ardour;
#include <sys/types.h>
#include <map>
-#include <string>
#include <vector>
#include <glibmm/refptr.h>
#include <gtkmm/spinbutton.h>
#include <gtkmm/adjustment.h>
-using std::map;
-using std::string;
-
namespace ARDOUR {
class Panner;
}
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtkmm2ext;
void effective_pan_display ();
- void set_meter_strip_name (string name);
+ void set_meter_strip_name (std::string name);
boost::shared_ptr<PBD::Controllable> get_controllable();
private:
class Playlist;
}
-struct PlaylistSelection : list<boost::shared_ptr<ARDOUR::Playlist> > {};
+struct PlaylistSelection :
std::list<boost::shared_ptr<ARDOUR::Playlist> > {};
#endif /* __ardour_gtk_playlist_selection_h__ */
/* input */
Gtk::ComboBoxText* combo;
- std::map<string, float>* combo_map;
+ std::map<std::string, float>* combo_map;
Gtk::ToggleButton* button;
-
boost::shared_ptr<AutomationController> controller;
+ boost::shared_ptr<AutomationController> controller;
Gtkmm2ext::ClickBox* clickbox;
Gtk::Label label;
bool logarithmic;
void build ();
ControlUI* build_control_ui (guint32 port_index, boost::shared_ptr<ARDOUR::AutomationControl>);
- std::vector<string> setup_scale_values(guint32 port_index, ControlUI* cui);
+ std::vector<std::string> setup_scale_values(guint32 port_index, ControlUI* cui);
void parameter_changed (ControlUI* cui);
void toggle_parameter_changed (ControlUI* cui);
void update_control_display (ControlUI* cui);
class AUPluginUI;
#endif
+using namespace std;
using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
Gtk::Menu *processor_menu;
gint processor_menu_map_handler (GdkEventAny *ev);
Gtk::Menu * build_processor_menu ();
- void build_processor_tooltip (Gtk::EventBox&, string);
+ void build_processor_tooltip (Gtk::EventBox&, std::string);
void show_processor_menu (gint arg);
void choose_send ();
void row_deleted (const Gtk::TreeModel::Path& path);
void show_processor_active (boost::weak_ptr<ARDOUR::Processor>);
void show_processor_name (boost::weak_ptr<ARDOUR::Processor>);
- string processor_name (boost::weak_ptr<ARDOUR::Processor>);
+ st
d::string processor_name (boost::weak_ptr<ARDOUR::Processor>);
void remove_processor_gui (boost::shared_ptr<ARDOUR::Processor>);
void clear_processors ();
void rename_processors ();
- typedef vector<boost::shared_ptr<ARDOUR::Processor> > ProcSelection;
+ typedef
std::vector<boost::shared_ptr<ARDOUR::Processor> > ProcSelection;
void for_selected_processors (void (ProcessorBox::*pmf)(boost::shared_ptr<ARDOUR::Processor>));
void get_selected_processors (ProcSelection&);
class AudioRegionGainLine : public AutomationLine
{
public:
-
AudioRegionGainLine (const string & name, ARDOUR::Session&, AudioRegionView&, ArdourCanvas::Group& parent, boost::shared_ptr<ARDOUR::AutomationList>);
+
AudioRegionGainLine (const std::string & name, ARDOUR::Session&, AudioRegionView&, ArdourCanvas::Group& parent, boost::shared_ptr<ARDOUR::AutomationList>);
void start_drag (ControlPoint*, nframes_t x, float fraction);
void end_drag (ControlPoint*);
#include "region_selection.h"
#include "time_axis_view.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
using namespace sigc;
#include <sigc++/signal.h>
#include "ardour/types.h"
-using std::list;
-using std::set;
-
class RegionView;
class TimeAxisView;
nframes_t _current_start; ///< start position for the selection
nframes_t _current_end; ///< end position for the selection
- list<RegionView *> _bylayer; ///< list of regions sorted by layer
+ std::list<RegionView *> _bylayer; ///< list of regions sorted by layer
};
#endif /* __ardour_gtk_region_selection_h__ */
#include "i18n.h"
+using namespace std;
using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
#include "ardour_ui.h"
#include "gui_thread.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
mem_fun (*this, &ReturnUIWindow::return_going_away));
signal_delete_event().connect (bind (
- ptr_fun (just_hide_it),
- reinterpret_cast<Window *> (this)));
+ sigc::ptr_fun (just_hide_it),
+ reinterpret_cast<Window *> (this)));
}
ReturnUIWindow::~ReturnUIWindow ()
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
using namespace sigc;
void selection_click (GdkEventButton*);
void set_selected_points (PointSelection&);
void set_selected_regionviews (RegionSelection&);
- void get_selectables (nframes_t start, nframes_t end, double top, double bot, list<Selectable *>&);
- void get_inverted_selectables (Selection&, list<Selectable*>&);
+ void get_selectables (nframes_t start, nframes_t end, double top, double bot, std::list<Selectable *>&);
+ void get_inverted_selectables (Selection&, std::list<Selectable*>&);
bool show_automation(Evoral::Parameter param);
void set_layer_display (LayerDisplay d);
LayerDisplay layer_display () const;
TimeAxisView::Children get_child_list();
/* The editor calls these when mapping an operation across multiple tracks */
- void use_new_playlist (bool prompt, vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
- void use_copy_playlist (bool prompt, vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
+ void use_new_playlist (bool prompt,
std::vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
+ void use_copy_playlist (bool prompt,
std::vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
void clear_playlist ();
/* group playlist name resolving */
- std::string resolve_new_group_playlist_name(std::string &, vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
+ std::string resolve_new_group_playlist_name(std::string &,
std::vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
void build_playlist_menu (Gtk::Menu *);
/* This is a bit nasty to expose :/ */
struct RouteAutomationNode {
Evoral::Parameter param;
- Gtk::CheckMenuItem* menu_item;
+ Gtk::CheckMenuItem* menu_item;
boost::shared_ptr<AutomationTimeAxisView> track;
RouteAutomationNode (Evoral::Parameter par, Gtk::CheckMenuItem* mi, boost::shared_ptr<AutomationTimeAxisView> tr)
XMLNode* get_automation_child_xml_node (Evoral::Parameter param) { return RouteUI::get_automation_child_xml_node (param); }
- typedef map<Evoral::Parameter, RouteAutomationNode*> AutomationTracks;
+ typedef std::map<Evoral::Parameter, RouteAutomationNode*> AutomationTracks;
AutomationTracks automation_tracks() { return _automation_tracks; }
boost::shared_ptr<AutomationTimeAxisView> automation_child(Evoral::Parameter param);
- string name() const;
+ std::string name() const;
StreamView* view() const { return _view; }
ARDOUR::RouteGroup* edit_group() const;
boost::shared_ptr<ARDOUR::Playlist> playlist() const;
struct ProcessorAutomationNode {
Evoral::Parameter what;
- Gtk::CheckMenuItem* menu_item;
+ Gtk::CheckMenuItem* menu_item;
boost::shared_ptr<AutomationTimeAxisView> view;
- RouteTimeAxisView& parent;
+ RouteTimeAxisView& parent;
ProcessorAutomationNode (Evoral::Parameter w, Gtk::CheckMenuItem* mitem, RouteTimeAxisView& p)
: what (w), menu_item (mitem), parent (p) {}
boost::shared_ptr<ARDOUR::Processor> processor;
bool valid;
Gtk::Menu* menu;
- vector<ProcessorAutomationNode*> lines;
+
std::vector<ProcessorAutomationNode*> lines;
ProcessorAutomationInfo (boost::shared_ptr<ARDOUR::Processor> i)
: processor (i), valid (true), menu (0) {}
void _set_track_mode (ARDOUR::Track* track, ARDOUR::TrackMode mode, Gtk::RadioMenuItem* reset_item, Gtk::RadioMenuItem* reset_item_2);
void track_mode_changed ();
- list<ProcessorAutomationInfo*> processor_automation;
+
std::list<ProcessorAutomationInfo*> processor_automation;
- typedef vector<boost::shared_ptr<AutomationLine> > ProcessorAutomationCurves;
+ typedef
std::vector<boost::shared_ptr<AutomationLine> > ProcessorAutomationCurves;
ProcessorAutomationCurves processor_automation_curves;
// Set from XML so context menu automation buttons can be correctly initialized
XMLNode* underlay_xml_node;
bool set_underlay_state();
- typedef list<StreamView*> UnderlayList;
+ typedef std::list<StreamView*> UnderlayList;
UnderlayList _underlay_streams;
- typedef list<RouteTimeAxisView*> UnderlayMirrorList;
+ typedef std::list<RouteTimeAxisView*> UnderlayMirrorList;
UnderlayMirrorList _underlay_mirrors;
};
boost::shared_ptr<ARDOUR::Diskstream> get_diskstream() const;
- string name() const;
+ std::string name() const;
// protected: XXX sigh this should be here
BindableToggleButton* solo_button;
BindableToggleButton* rec_enable_button;
- virtual string solo_button_name () const { return "SoloButton"; }
- virtual string safe_solo_button_name () const { return "SafeSoloButton"; }
+ virtual std::string solo_button_name () const { return "SoloButton"; }
+ virtual std::string safe_solo_button_name () const { return "SafeSoloButton"; }
Gtk::Menu* mute_menu;
Gtk::Menu* solo_menu;
void set_remote_control_id (uint32_t id, Gtk::CheckMenuItem* item);
- void reversibly_apply_route_boolean (string name, void (ARDOUR::Route::*func)(bool, void*), bool, void *);
- void reversibly_apply_track_boolean (string name, void (ARDOUR::Track::*func)(bool, void*), bool, void *);
+ void reversibly_apply_route_boolean (std::string name, void (ARDOUR::Route::*func)(bool, void*), bool, void *);
+ void reversibly_apply_track_boolean (std::string name, void (ARDOUR::Track::*func)(bool, void*), bool, void *);
void adjust_latency ();
void save_as_template ();
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
using namespace sigc;
void remove (boost::shared_ptr<ARDOUR::AutomationList>);
void remove (boost::shared_ptr<ARDOUR::Playlist>);
void remove (const std::list<boost::shared_ptr<ARDOUR::Playlist> >&);
- void remove (const list<Selectable*>&);
+ void remove (const std::list<Selectable*>&);
void remove (Marker*);
void replace (uint32_t time_index, nframes_t start, nframes_t end);
#include "ardour_ui.h"
#include "gui_thread.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
mem_fun (*this, &SendUIWindow::send_going_away));
signal_delete_event().connect (bind (
- ptr_fun (just_hide_it),
- reinterpret_cast<Window *> (this)));
+ sigc::ptr_fun (just_hide_it),
+ reinterpret_cast<Window *> (this)));
}
SendUIWindow::~SendUIWindow ()
#include "prompter.h"
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
SessionImportDialog::SessionImportDialog (ARDOUR::Session & target) :
#include "ardour_dialog.h"
-using std::string;
-
namespace ARDOUR {
class Session;
}
private:
- void load_session (const string& filename);
+ void load_session (const std::string& filename);
void fill_list ();
void browse ();
void do_merge ();
void end_dialog ();
- void update (string path);
+ void update (std::string path);
void show_info(const Gtk::TreeModel::Path& path, Gtk::TreeViewColumn* column);
- std::pair<bool, string> open_rename_dialog (string text, string name);
- bool open_prompt_dialog (string text);
+ std::pair<bool, std::string> open_rename_dialog (std::string text, std::string name);
+ bool open_prompt_dialog (std::string text);
// Data
HandlerList handlers;
#include "ardour/session_directory.h"
#include "ardour/session_utils.h"
+using namespace std;
+using namespace Glib;
+
#define CALL_MEMBER_FN(object,ptrToMember) ((object).*(ptrToMember))
/*** MetadataField ***/
#include "ardour/session_metadata.h"
-using std::string;
-using Glib::ustring;
-
class MetadataField;
typedef boost::shared_ptr<MetadataField> MetadataPtr;
/// Wraps a metadata field to be used in a GUI
class MetadataField {
public:
- MetadataField (ustring const & field_name);
+ MetadataField (Glib::ustring const & field_name);
virtual ~MetadataField();
virtual MetadataPtr copy () = 0;
virtual void save_data (ARDOUR::SessionMetadata & data) const = 0;
virtual void load_data (ARDOUR::SessionMetadata const & data) = 0;
- virtual ustring name() { return _name; }
- virtual ustring value() { return _value; }
+ virtual Glib::ustring name() { return _name; }
+ virtual Glib::ustring value() { return _value; }
/// Get widget containing name of field
virtual Gtk::Widget & name_widget () = 0;
/// Get widget for editing value
virtual Gtk::Widget & edit_widget () = 0;
protected:
- ustring _name;
- ustring _value;
+ Glib::ustring _name;
+ Glib::ustring _value;
};
/// MetadataField that contains text
class TextMetadataField : public MetadataField {
private:
- typedef ustring (ARDOUR::SessionMetadata::*Getter) () const;
- typedef void (ARDOUR::SessionMetadata::*Setter) (ustring const &);
+ typedef Glib::ustring (ARDOUR::SessionMetadata::*Getter) () const;
+ typedef void (ARDOUR::SessionMetadata::*Setter) (Glib::ustring const &);
public:
- TextMetadataField (Getter getter, Setter setter, ustring const & field_name, guint width = 50);
+ TextMetadataField (Getter getter, Setter setter, Glib::ustring const & field_name, guint width = 50);
MetadataPtr copy ();
void save_data (ARDOUR::SessionMetadata & data) const;
typedef uint32_t (ARDOUR::SessionMetadata::*Getter) () const;
typedef void (ARDOUR::SessionMetadata::*Setter) (uint32_t);
public:
- NumberMetadataField (Getter getter, Setter setter, ustring const & field_name, guint numbers, guint width = 50);
+ NumberMetadataField (Getter getter, Setter setter, Glib::ustring const & field_name, guint numbers, guint width = 50);
MetadataPtr copy ();
void save_data (ARDOUR::SessionMetadata & data) const;
Gtk::Widget & edit_widget ();
private:
void update_value ();
- ustring uint_to_str (uint32_t i) const;
- uint32_t str_to_uint (ustring const & str) const;
+ Glib::ustring uint_to_str (uint32_t i) const;
+ uint32_t str_to_uint (Glib::ustring const & str) const;
Getter getter;
Setter setter;
/// Interface for MetadataFields
class SessionMetadataSet {
public:
- SessionMetadataSet (ustring const & name);
+ SessionMetadataSet (Glib::ustring const & name);
virtual ~SessionMetadataSet () {};
void add_data_field (MetadataPtr field);
protected:
typedef std::list<MetadataPtr> DataList;
DataList list;
- ustring name;
+ Glib::ustring name;
ARDOUR::Session *session;
};
/// Contains MetadataFields for editing
class SessionMetadataSetEditable : public SessionMetadataSet {
public:
- SessionMetadataSetEditable (ustring const & name);
+ SessionMetadataSetEditable (Glib::ustring const & name);
Gtk::Widget & get_widget () { return table; }
Gtk::Widget & get_tab_widget ();
/// Contains MetadataFields for importing
class SessionMetadataSetImportable : public SessionMetadataSet {
public:
- SessionMetadataSetImportable (ustring const & name);
+ SessionMetadataSetImportable (Glib::ustring const & name);
Gtk::Widget & get_widget () { return tree_view; }
Gtk::Widget & get_tab_widget ();
struct Columns : public Gtk::TreeModel::ColumnRecord
{
public:
- Gtk::TreeModelColumn<ustring> field;
- Gtk::TreeModelColumn<ustring> values;
+ Gtk::TreeModelColumn<Glib::ustring> field;
+ Gtk::TreeModelColumn<Glib::ustring> values;
Gtk::TreeModelColumn<bool> import;
Gtk::TreeModelColumn<MetadataPtr> data;
Gtk::CheckButton select_all_check;
void select_all ();
- void selection_changed (ustring const & path);
+ void selection_changed (Glib::ustring const & path);
};
/// Metadata dialog interface
class SessionMetadataDialog : public ArdourDialog
{
public:
- SessionMetadataDialog (ustring const & name);
+ SessionMetadataDialog (Glib::ustring const & name);
protected:
void init_data ();
virtual void save_and_close ();
virtual void end_dialog ();
- void warn_user (ustring const & string);
+ void warn_user (Glib::ustring const & string);
typedef std::list<Gtk::Widget *> WidgetList;
typedef boost::shared_ptr<WidgetList> WidgetListPtr;
using namespace Gtk;
using namespace Glib;
+using namespace PBD;
using namespace std;
using namespace ARDOUR;
#include "gui_thread.h"
#include "utils.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
using namespace Editing;
void foreach_regionview (sigc::slot<void,RegionView*> slot);
void set_selected_regionviews (RegionSelection&);
- void get_selectables (nframes_t start, nframes_t end, list<Selectable* >&);
- void get_inverted_selectables (Selection&, list<Selectable* >& results);
+ 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) {}
void add_region_view (boost::shared_ptr<ARDOUR::Region>);
ArdourCanvas::Group* canvas_group;
ArdourCanvas::SimpleRect* canvas_rect; /* frame around the whole thing */
- typedef list<RegionView* > RegionViewList;
+ typedef std::list<RegionView* > RegionViewList;
RegionViewList region_views;
double _samples_per_unit;
sigc::connection screen_update_connection;
- vector<RecBoxInfo> rec_rects;
- list< std::pair<boost::shared_ptr<ARDOUR::Region>,RegionView* > > rec_regions;
+ std::vector<RecBoxInfo> rec_rects;
+
std::list< std::pair<boost::shared_ptr<ARDOUR::Region>,RegionView* > > rec_regions;
bool rec_updating;
bool rec_active;
bool use_rec_regions;
Gdk::Color region_color; ///< Contained region color
uint32_t stream_base_color; ///< Background color
- vector<sigc::connection> playlist_connections;
+ std::vector<sigc::connection> playlist_connections;
sigc::connection playlist_change_connection;
ARDOUR::layer_t _layers;
double height;
- list<sigc::connection> rec_data_ready_connections;
+ std::list<sigc::connection> rec_data_ready_connections;
jack_nframes_t last_rec_data_frame;
private:
#include "i18n.h"
+using namespace std;
using namespace Gtk;
using namespace Gtkmm2ext;
using namespace ARDOUR;
struct TempoDialog : public ArdourDialog
{
Gtk::ComboBoxText note_types;
- vector<string> strings;
+ std::vector<std::string> strings;
Gtk::Adjustment bpm_adjustment;
Gtk::SpinButton bpm_spinner;
Gtk::Frame bpm_frame;
Gtk::Frame when_frame;
char buf[64];
- TempoDialog (ARDOUR::TempoMap&, nframes_t, const string & action);
- TempoDialog (ARDOUR::TempoSection&, const string & action);
+ TempoDialog (ARDOUR::TempoMap&, nframes_t, const std::string & action);
+ TempoDialog (ARDOUR::TempoSection&, const std::string & action);
double get_bpm ();
double get_note_type ();
{
Gtk::Entry bpb_entry;
Gtk::ComboBoxText note_types;
- vector<string> strings;
+ std::vector<std::string> strings;
Gtk::Frame bpb_frame;
Gtk::Button ok_button;
Gtk::Button cancel_button;
Gtk::Frame when_frame;
char buf[64];
- MeterDialog (ARDOUR::TempoMap&, nframes_t, const string & action);
- MeterDialog (ARDOUR::MeterSection&, const string & action);
+ MeterDialog (ARDOUR::TempoMap&, nframes_t, const std::string & action);
+ MeterDialog (ARDOUR::MeterSection&, const std::string & action);
double get_bpb ();
double get_note_type ();
#include "i18n.h"
+using namespace std;
using namespace Gtk;
using namespace Gdk;
using namespace sigc;
void order_selection_trims (ArdourCanvas::Item *item, bool put_start_on_top);
- virtual void get_selectables (nframes_t start, nframes_t end, double top, double bot, list<Selectable*>& results);
- virtual void get_inverted_selectables (Selection&, list<Selectable *>& results);
+ virtual void get_selectables (nframes_t start, nframes_t end, double top, double bot, std::list<Selectable*>& results);
+ virtual void get_inverted_selectables (Selection&, std::list<Selectable *>& results);
void add_ghost (RegionView*);
void remove_ghost (RegionView*);
uint32_t height; /* in canvas units */
- string controls_base_unselected_name;
- string controls_base_selected_name;
+ std::string controls_base_unselected_name;
+ std::string controls_base_selected_name;
bool name_entry_button_press (GdkEventButton *ev);
bool name_entry_button_release (GdkEventButton *ev);
ArdourCanvas::Group *selection_group;
- list<GhostRegion*> ghosts;
+ std::list<GhostRegion*> ghosts;
- list<SelectionRect*> free_selection_rects;
- list<SelectionRect*> used_selection_rects;
+ std::list<SelectionRect*> free_selection_rects;
+ std::list<SelectionRect*> used_selection_rects;
SelectionRect* get_selection_rect(uint32_t id);
class TimeAxisView;
-struct TrackSelection : public list<TimeAxisView*> {};
+struct TrackSelection : public std::list<TimeAxisView*> {};
#endif /* __ardour_gtk_track_selection_h__ */
class AudioDiskstream : public Diskstream
{
public:
- AudioDiskstream (Session &, const string& name, Diskstream::Flag f = Recordable);
+ AudioDiskstream (Session &, const std::string& name, Diskstream::Flag f = Recordable);
AudioDiskstream (Session &, const XMLNode&);
~AudioDiskstream();
float playback_buffer_load() const;
float capture_buffer_load() const;
- string input_source (uint32_t n=0) const {
+ std::string input_source (uint32_t n=0) const {
boost::shared_ptr<ChannelList> c = channels.reader();
if (n < c->size()) {
return (*c)[n]->source ? (*c)[n]->source->name() : "";
int use_new_write_source (uint32_t n=0);
- int find_and_use_playlist (const string&);
+ int find_and_use_playlist (const std::string &);
void allocate_temporary_buffers ();
#include <map>
#include <vector>
-using std::vector;
-using std::string;
-using std::map;
-
namespace ARDOUR {
class AudioLibrary
AudioLibrary ();
~AudioLibrary ();
- void set_tags (string member, vector<string> tags);
- vector<string> get_tags (string member);
+ void set_tags (std::string member, std::vector<std::string> tags);
+ std::vector<std::string> get_tags (std::string member);
- void search_members_and (vector<string>& results, const vector<string> tags);
+ void search_members_and (std::vector<std::string>& results, const std::vector<std::string> tags);
void save_changes();
private:
- string src;
+ std::string src;
};
extern AudioLibrary* Library;
AudioPlaylistImportHandler (XMLTree const & source, Session & session, AudioRegionImportHandler & region_handler, const char * nodename = "Playlists");
virtual ~AudioPlaylistImportHandler () {}
- virtual string get_info () const;
+ virtual std::string get_info () const;
void get_regions (XMLNode const & node, ElementList & list) const;
void update_region_id (XMLProperty* id_prop);
public:
UnusedAudioPlaylistImportHandler (XMLTree const & source, Session & session, AudioRegionImportHandler & region_handler) :
AudioPlaylistImportHandler (source, session, region_handler, X_("UnusedPlaylists")) { }
- string get_info () const { return _("Audio Playlists (unused)"); }
+ std::string get_info () const { return _("Audio Playlists (unused)"); }
};
class AudioPlaylistImporter : public ElementImporter
AudioPlaylistImporter (AudioPlaylistImporter const & other);
~AudioPlaylistImporter ();
- string get_info () const;
+ std::string get_info () const;
void set_diskstream (PBD::ID const & id);
PBD::ID const & orig_diskstream () const { return orig_diskstream_id; }
public:
// Inerface implementation
AudioRegionImportHandler (XMLTree const & source, Session & session);
- string get_info () const;
+ std::string get_info () const;
void create_regions_from_children (XMLNode const & node, ElementList & list);
// Source management
- bool check_source (string const & filename) const;
- void add_source (string const & filename, boost::shared_ptr<Source> const & source);
- boost::shared_ptr<Source> const & get_source (string const & filename) const;
+ bool check_source (std::string const & filename) const;
+ void add_source (std::string const & filename, boost::shared_ptr<Source> const & source);
+ boost::shared_ptr<Source> const & get_source (std::string const & filename) const;
// Id management
void register_id (PBD::ID & old_id, PBD::ID & new_id);
private:
// Source management
- typedef std::map<string, boost::shared_ptr<Source> > SourceMap;
- typedef std::pair<string, boost::shared_ptr<Source> > SourcePair;
+ typedef std::map<std::string, boost::shared_ptr<Source> > SourceMap;
+ typedef std::pair<std::string, boost::shared_ptr<Source> > SourcePair;
SourceMap sources;
// Id management
~AudioRegionImporter ();
// Interface implementation
- string get_info () const;
+ std::string get_info () const;
Session::ImportStatus * get_import_status () { return &status; }
// other stuff
AudioRegionImportHandler & handler;
PBD::ID old_id;
PBD::ID id;
- std::list<string> filenames;
+ std::list<std::string> filenames;
Session::ImportStatus status;
bool parse_xml_region ();
class AudioTrack : public Track
{
public:
- AudioTrack (Session&, string name, Route::Flag f = Route::Flag (0), TrackMode m = Normal);
+ AudioTrack (Session&, std::string name, Route::Flag f = Route::Flag (0), TrackMode m = Normal);
AudioTrack (Session&, const XMLNode&);
~AudioTrack ();
boost::shared_ptr<AudioDiskstream> audio_diskstream() const;
- int use_diskstream (string name);
+ int use_diskstream (std::string name);
int use_diskstream (const PBD::ID& id);
int export_stuff (BufferSet& bufs, nframes_t nframes, nframes_t end_frame, bool enable_processing = true);
public:
AudioTrackImportHandler (XMLTree const & source, Session & session, AudioPlaylistImportHandler & pl_handler);
virtual ~AudioTrackImportHandler () {}
- virtual string get_info () const;
+ virtual std::string get_info () const;
private:
AudioPlaylistImportHandler & pl_handler;
AudioPlaylistImportHandler & pl_handler);
~AudioTrackImporter ();
- string get_info () const;
+ std::string get_info () const;
protected:
bool _prepare_move ();
#include "taglib/taglib.h"
#include "taglib/xiphcomment.h"
-using std::string;
-
namespace ARDOUR
{
/* Tags file with metadata, return true on success */
- static bool tag_file (string const & filename, SessionMetadata const & metadata);
+ static bool tag_file (std::string const & filename, SessionMetadata const & metadata);
private:
public:
AudioPlaylist (Session&, const XMLNode&, bool hidden = false);
- AudioPlaylist (Session&, string name, bool hidden = false);
- AudioPlaylist (boost::shared_ptr<const AudioPlaylist>, string name, bool hidden = false);
- AudioPlaylist (boost::shared_ptr<const AudioPlaylist>, nframes_t start, nframes_t cnt, string name, bool hidden = false);
+ AudioPlaylist (Session&, std::string name, bool hidden = false);
+ AudioPlaylist (boost::shared_ptr<const AudioPlaylist>, std::string name, bool hidden = false);
+ AudioPlaylist (boost::shared_ptr<const AudioPlaylist>, nframes_t start, nframes_t cnt, std::string name, bool hidden = false);
~AudioPlaylist ();
namespace ARDOUR {
-using std::vector;
-
class Route;
class Playlist;
class Session;
void set_envelope_active (bool yn);
void set_default_envelope ();
- int separate_by_channel (ARDOUR::Session&, vector<boost::shared_ptr<Region> >&) const;
+ int separate_by_channel (ARDOUR::Session&, std::vector<boost::shared_ptr<Region> >&) const;
/* automation */
friend class Crossfade;
AudioRegion (boost::shared_ptr<AudioSource>, nframes_t start, nframes_t length);
- AudioRegion (boost::shared_ptr<AudioSource>, nframes_t start, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
- AudioRegion (const SourceList &, nframes_t start, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
- AudioRegion (boost::shared_ptr<const AudioRegion>, nframes_t start, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
- AudioRegion (boost::shared_ptr<const AudioRegion>, const SourceList&, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
+ AudioRegion (boost::shared_ptr<AudioSource>, nframes_t start, nframes_t length, const std::string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
+ AudioRegion (const SourceList &, nframes_t start, nframes_t length, const std::string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
+ AudioRegion (boost::shared_ptr<const AudioRegion>, nframes_t start, nframes_t length, const std::string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
+ AudioRegion (boost::shared_ptr<const AudioRegion>, const SourceList&, nframes_t length, const std::string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
AudioRegion (boost::shared_ptr<const AudioRegion>);
AudioRegion (boost::shared_ptr<AudioSource>, const XMLNode&);
AudioRegion (SourceList &, const XMLNode&);
#ifndef __ardour_audio_source_h__
#define __ardour_audio_source_h__
-#include <list>
-#include <vector>
-
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include "pbd/stateful.h"
#include "pbd/xml++.h"
-using std::list;
-using std::vector;
-
namespace ARDOUR {
class AudioSource : virtual public Source,
{
public:
AutomationControl(ARDOUR::Session&,
- const Evoral::Parameter& parameter,
- boost::shared_ptr<ARDOUR::AutomationList> l=boost::shared_ptr<ARDOUR::AutomationList>(),
- const string& name="");
+ const Evoral::Parameter& parameter,
+
boost::shared_ptr<ARDOUR::AutomationList> l=boost::shared_ptr<ARDOUR::AutomationList>(),
+ const std::string& name="");
boost::shared_ptr<AutomationList> alist() const {
return boost::dynamic_pointer_cast<AutomationList>(_list);
#include "ardour/types.h"
-using std::string;
-
namespace ARDOUR
{
~BroadcastInfo ();
/// Returns last error sring from libsndfile
- string get_error () const { return error; }
+ std::string get_error () const { return error; }
/* Convenience functions */
/* Reading */
- bool load_from_file (string const & filename);
+ bool load_from_file (std::string const & filename);
bool load_from_file (SNDFILE* sf);
- string get_description () const;
+ std::string get_description () const;
int64_t get_time_reference () const;
struct tm get_origination_time () const;
- string get_originator () const;
- string get_originator_ref () const;
+ std::string get_originator () const;
+ std::string get_originator_ref () const;
/* Writing */
- bool write_to_file (string const & filename);
+ bool write_to_file (std::string const & filename);
bool write_to_file (SNDFILE* sf);
- void set_description (string const & desc);
+ void set_description (std::string const & desc);
void set_time_reference (int64_t when);
void set_origination_time (struct tm * now = 0); // if 0, use time generated at construction
- void set_originator (string const & str = "");
- void set_originator_ref (string const & str = "");
+ void set_originator (std::string const & str = "");
+ void set_originator_ref (std::string const & str = "");
/* State info */
struct tm _time;
void update_error ();
- string error;
+ std::string error;
bool _has_info;
};
class ClickIO : public IO
{
public:
- ClickIO (Session& s, const string& name) : IO (s, name) {}
+ ClickIO (Session& s, const std::string& name) : IO (s, name) {}
~ClickIO() {}
protected:
/* BWAV */
-CONFIG_VARIABLE (string, bwf_country_code, "bwf-country-code", "US")
-CONFIG_VARIABLE (string, bwf_organization_code, "bwf-organization-code", "US")
+CONFIG_VARIABLE (std::string, bwf_country_code, "bwf-country-code", "US")
+CONFIG_VARIABLE (std::string, bwf_organization_code, "bwf-organization-code", "US")
/* these variables have custom set() methods (e.g. path globbing) */
namespace ARDOUR {
- using PBD::SearchPath;
-
/**
* return a SearchPath containing directories in which to look for
* control surface plugins.
* contain the user and system directories which may contain control
* surface plugins.
*/
- SearchPath control_protocol_search_path ();
+ PBD::SearchPath control_protocol_search_path ();
} // namespace ARDOUR
}
~CycleTimer() {
_exit = get_cycles();
- std::cerr << _name << ": " << (float) (_exit - _entry) / cycles_per_usec << " (" << _entry << ", " << _exit << ')' << endl;
+ std::cerr << _name << ": " << (float) (_exit - _entry) / cycles_per_usec << " (" << _entry << ", " << _exit << ')' << std::endl;
}
static float get_mhz ();
NonLayered = 0x8
};
- Diskstream (Session &, const string& name, Flag f = Recordable);
+ Diskstream (Session &, const std::string& name, Flag f = Recordable);
Diskstream (Session &, const XMLNode&);
virtual ~Diskstream();
- bool set_name (const string& str);
+ bool set_name (const std::string& str);
ARDOUR::IO* io() const { return _io; }
void set_io (ARDOUR::IO& io);
void remove_region_from_last_capture (boost::weak_ptr<Region> wregion);
void move_processor_automation (boost::weak_ptr<Processor>,
- list< Evoral::RangeMove<nframes_t> > const &);
+ std::list< Evoral::RangeMove<nframes_t> > const &);
sigc::signal<void> RecordEnableChanged;
sigc::signal<void> SpeedChanged;
virtual void playlist_changed (Change);
virtual void playlist_deleted (boost::weak_ptr<Playlist>);
- virtual void playlist_ranges_moved (list< Evoral::RangeMove<nframes_t> > const &);
+ virtual void playlist_ranges_moved (std::list< Evoral::RangeMove<nframes_t> > const &);
virtual void transport_stopped (struct tm&, time_t, bool abort) = 0;
virtual void transport_looped (nframes_t transport_frame) = 0;
virtual int use_new_write_source (uint32_t n=0) = 0;
- virtual int find_and_use_playlist (const string&) = 0;
+ virtual int find_and_use_playlist (const std::string&) = 0;
virtual void allocate_temporary_buffers () = 0;
#include <boost/shared_ptr.hpp>
-using std::string;
class XMLTree;
namespace ARDOUR {
/** Gets a textual representation of the element type
* @return textual representation of element type
*/
- virtual string get_info () const = 0;
+ virtual std::string get_info () const = 0;
/// Elements this handler handles
ElementList elements;
* @param name name to check
* @return true if name is not used
*/
- bool check_name (const string & name) const;
+ bool check_name (const std::string & name) const;
/// Adds name to the list of used names
- void add_name (string name);
+ void add_name (std::string name);
/// Removes name from the list of used names
- void remove_name (const string & name);
+ void remove_name (const std::string & name);
/// Checks wheter or not all elements can be imported cleanly
static bool dirty () { return _dirty; }
private:
/// Set of names for duplicate checking
- std::set<string> names;
+ std::set<std::string> names;
};
} // namespace ARDOUR
#include "ardour/types.h"
#include "ardour/session.h"
-using std::string;
-
class XMLTree;
namespace ARDOUR {
/** Returns the element name
* @return the name of the element
*/
- virtual string get_name () const { return name; };
+ virtual std::string get_name () const { return name; };
/** Gets a textual representation of the element
* @return a textual representation on this specific element
*/
- virtual string get_info () const = 0;
+ virtual std::string get_info () const = 0;
/** Gets import status, if applicable. */
virtual Session::ImportStatus * get_import_status () { return 0; }
bool broken () { return _broken; }
/// Signal that requests for anew name
- static sigc::signal <std::pair<bool, string>, string, string> Rename;
+ static sigc::signal <std::pair<bool, std::string>, std::string, std::string> Rename;
/// Signal for ok/cancel prompting
- static sigc::signal <bool, string> Prompt;
+ static sigc::signal <bool, std::string> Prompt;
protected:
bool queued () { return _queued; }
/// Name of element
- string name;
+ std::string name;
/// The sample rate of the session from which we are importing
nframes_t sample_rate;
/// Converts smpte time to a string
- string smpte_to_string(SMPTE::Time & time) const;
+ std::string smpte_to_string (SMPTE::Time & time) const;
/// Converts samples so that times match the sessions sample rate
nframes_t rate_convert_samples (nframes_t samples) const;
/// Converts samples so that times match the sessions sample rate (for straight use in XML)
- string rate_convert_samples (string const & samples) const;
+ std::string rate_convert_samples (std::string const & samples) const;
/// Set element broken
void set_broken () { _broken = true; }
#include "ardour/ardour.h"
#include "ardour/gdither.h"
-using std::map;
-using std::vector;
-using std::string;
-using std::pair;
-
namespace ARDOUR
{
class Port;
- typedef pair<Port *, uint32_t> PortChannelPair;
- typedef
map<uint32_t, vector<PortChannelPair> > ExportPortMap;
+ typedef
std::pair<Port *, uint32_t> PortChannelPair;
+ typedef
std::map<uint32_t, std::vector<PortChannelPair> > ExportPortMap;
struct ExportSpecification : public SF_INFO, public sigc::trackable {
void init ();
void clear ();
-
int prepare (nframes_t blocksize, nframes_t frame_rate);
int process (nframes_t nframes);
/* set by the user */
- string path;
+ std::string path;
nframes_t sample_rate;
int src_quality;
#include "pbd/xml++.h"
-using Glib::ustring;
-
namespace ARDOUR
{
ChannelList const & get_channels () const { return channels; }
bool all_channels_have_ports () const;
- ustring name () const { return _name; }
- void set_name (ustring name) { _name = name; }
+ Glib::ustring name () const { return _name; }
+ void set_name (Glib::ustring name) { _name = name; }
void set_split (bool value) { split = value; }
bool get_split () const { return split; }
FileConfigList file_configs;
bool split; // Split to mono files
- ustring _name;
+ Glib::ustring _name;
};
} // namespace ARDOUR
#include "i18n.h"
-using namespace PBD;
-
namespace ARDOUR
{
ExportFailed (std::string const & reason) :
reason (reason.c_str())
{
- error << string_compose (_("Export failed: %1"), reason) << endmsg;
+ PBD::error << string_compose (_("Export failed: %1"), reason) << endmsg;
}
~ExportFailed () throw() { }
#include "ardour/export_format_specification.h"
#include "ardour/export_utilities.h"
-using Glib::ustring;
-
namespace ARDOUR
{
public:
virtual ~ExportFileWriter () {}
- string filename () const { return _filename; }
+ std::string filename () const { return _filename; }
nframes_t position () const { return _position; }
void set_position (nframes_t position) { _position = position; }
protected:
- ExportFileWriter (string filename) : _filename (filename) {}
+ ExportFileWriter (std::string filename) : _filename (filename) {}
- string _filename;
+ std::string _filename;
nframes_t _position;
};
SNDFILE * get_sndfile () const { return sndfile; }
protected:
- SndfileWriterBase (int channels, nframes_t samplerate, int format, string const & path);
+ SndfileWriterBase (int channels, nframes_t samplerate, int format, std::string const & path);
virtual ~SndfileWriterBase ();
SF_INFO sf_info;
// Should only be created vie ExportFileFactory and derived classes
public: // protected
friend class ExportFileFactory;
- SndfileWriter (int channels, nframes_t samplerate, int format, string const & path);
+ SndfileWriter (int channels, nframes_t samplerate, int format, std::string const & path);
public:
nframes_t write (T * data, nframes_t frames);
typedef std::pair<FloatSinkPtr, FileWriterPtr> FilePair;
- static FilePair create (FormatPtr format, uint32_t channels, ustring const & filename);
+ static FilePair create (FormatPtr format, uint32_t channels, Glib::ustring const & filename);
static bool check (FormatPtr format, uint32_t channels);
private:
- static FilePair create_sndfile (FormatPtr format, unsigned int channels, ustring const & filename);
+ static FilePair create_sndfile (FormatPtr format, unsigned int channels, Glib::ustring const & filename);
static bool check_sndfile (FormatPtr format, unsigned int channels);
};
#include <glibmm/ustring.h>
#include "pbd/statefuldestructible.h"
-using Glib::ustring;
-
namespace ARDOUR
{
/* data access */
- ustring get_path (FormatPtr format) const;
- ustring get_folder () const { return folder; }
+ Glib::ustring get_path (FormatPtr format) const;
+ Glib::ustring get_folder () const { return folder; }
TimeFormat get_time_format () const { return time_format; }
DateFormat get_date_format () const { return date_format; }
- ustring get_time_format_str (TimeFormat format) const;
- ustring get_date_format_str (DateFormat format) const;
+ Glib::ustring get_time_format_str (TimeFormat format) const;
+ Glib::ustring get_date_format_str (DateFormat format) const;
- ustring get_label () const { return label; }
+ Glib::ustring get_label () const { return label; }
uint32_t get_revision () const { return revision; }
/* data modification */
void set_time_format (TimeFormat format);
void set_date_format (DateFormat format);
- void set_label (ustring value);
+ void set_label (Glib::ustring value);
void set_revision (uint32_t value) { revision = value; }
void set_channel (uint32_t value) { channel = value; }
- bool set_folder (ustring path);
+ bool set_folder (Glib::ustring path);
void set_timespan (TimespanPtr ts) { timespan = ts; }
void set_channel_config (ChannelConfigPtr cc) { channel_config = cc; }
Session & session;
- ustring label;
+ Glib::ustring label;
uint32_t revision;
uint32_t channel;
- ustring folder;
+ Glib::ustring folder;
DateFormat date_format;
TimeFormat time_format;
- ustring get_formatted_time (ustring const & format) const;
+ Glib::ustring get_formatted_time (Glib::ustring const & format) const;
struct tm * time_struct; // Due to static allocation no destructor or copy-ctor is needed because of this
TimespanPtr timespan;
/* Serialization helpers */
- typedef std::pair<bool, ustring> FieldPair;
+ typedef std::pair<bool, Glib::ustring> FieldPair;
- void add_field (XMLNode * node, ustring const & name, bool enabled, ustring const & value = "");
- FieldPair get_field (XMLNode const & node, ustring const & name);
+ void add_field (XMLNode * node, Glib::ustring const & name, bool enabled, Glib::ustring const & value = "");
+ FieldPair get_field (XMLNode const & node, Glib::ustring const & name);
FieldPair analyse_folder ();
-
};
#define __ardour_export_format_base_h__
#include <set>
-#include <string>
#include <algorithm>
#include <boost/shared_ptr.hpp>
#include <glibmm/ustring.h>
#include "ardour/gdither_types.h"
#include "ardour/ardour.h"
-using std::string;
-
namespace ARDOUR
{
#include "ardour/export_formats.h"
-using std::string;
-
namespace ARDOUR
{
#include "ardour/types.h"
#include "ardour/export_format_base.h"
-using std::string;
-
class XMLNode;
namespace ARDOUR
sigc::signal<void, bool, WeakDitherTypePtr> DitherTypeSelectChanged;
sigc::signal<void, bool, WeakDitherTypePtr> DitherTypeCompatibleChanged;
- static string get_sample_format_name (ExportFormatBase::SampleFormat format);
+ static std::string get_sample_format_name (ExportFormatBase::SampleFormat format);
protected:
/* State lists */
/* CD Marker stuff */
struct CDMarkerStatus {
- CDMarkerStatus (string out_file, TimespanPtr timespan, FormatPtr format, string filename) :
+ CDMarkerStatus (std::string out_file, TimespanPtr timespan, FormatPtr format, std::string filename) :
out (out_file.c_str()), timespan (timespan), format (format), filename (filename),
track_number (1), track_position (0), track_duration (0), track_start_frame (0),
index_number (1), index_position (0)
std::ofstream out;
TimespanPtr timespan;
FormatPtr format;
- string filename;
+ std::string filename;
Location * marker;
/* Track info */
#include "pbd/uuid.h"
#include "pbd/xml++.h"
-using std::string;
-
namespace ARDOUR
{
class ExportPreset {
public:
- ExportPreset (string filename, Session & s);
+ ExportPreset (std::string filename, Session & s);
~ExportPreset ();
PBD::UUID const & id () const { return _id; }
- string name () const { return _name; }
+ std::string name () const { return _name; }
- void set_name (string const & name);
+ void set_name (std::string const & name);
// Note: The set_..._state functions take ownership of the XMLNode
void set_global_state (XMLNode & state);
private:
- void set_id (string const & id);
+ void set_id (std::string const & id);
XMLNode * get_instant_xml () const;
void save_instant_xml () const;
void remove_instant_xml () const;
PBD::UUID _id;
- string _name;
+ std::string _name;
Session & session;
XMLTree global;
#include "ardour/export_file_io.h"
#include "ardour/export_utilities.h"
-using Glib::ustring;
-using std::list;
-
namespace ARDOUR
{
#include <list>
#include <vector>
#include <map>
-#include <set>
#include <stdexcept>
#include <boost/shared_ptr.hpp>
#include "ardour/location.h"
#include "ardour/types.h"
-using std::string;
-using std::list;
-using std::set;
-
namespace ARDOUR
{
PresetList const & get_presets () { return preset_list; }
bool load_preset (PresetPtr preset);
- PresetPtr save_preset (string const & name);
+ PresetPtr save_preset (std::string const & name);
void remove_preset ();
private:
#include "ardour/export_channel.h"
#include "ardour/ardour.h"
-using Glib::ustring;
-
namespace ARDOUR
{
public:
~ExportTimespan ();
- ustring name () const { return _name; }
- void set_name (ustring name) { _name = name; }
+ Glib::ustring name () const { return _name; }
+ void set_name (Glib::ustring name) { _name = name; }
- ustring range_id () const { return _range_id; }
- void set_range_id (ustring range_id) { _range_id = range_id; }
+ Glib::ustring range_id () const { return _range_id; }
+ void set_range_id (Glib::ustring range_id) { _range_id = range_id; }
/// Registers a channel to be read when export starts rolling
void register_channel (ExportChannelPtr channel);
TempFileMap filemap;
- ustring _name;
- ustring _range_id;
+ Glib::ustring _name;
+ Glib::ustring _range_id;
};
uint16_t _channel;
bool _is_embedded;
- static map<DataType, Glib::ustring> search_paths;
+ static std::map<DataType, Glib::ustring> search_paths;
};
} // namespace ARDOUR
namespace ARDOUR {
- using namespace PBD;
-
/**
* @return the path to the directory used to store user specific ardour
* configuration files.
*/
- sys::path user_config_directory ();
+ PBD::sys::path user_config_directory ();
/**
* @return the path to the directory that contains the system wide ardour
* modules.
*/
- sys::path ardour_module_directory ();
+ PBD::sys::path ardour_module_directory ();
- SearchPath ardour_search_path ();
+ PBD::SearchPath ardour_search_path ();
- SearchPath system_config_search_path ();
+ PBD::SearchPath system_config_search_path ();
- SearchPath system_data_search_path ();
+ PBD::SearchPath system_data_search_path ();
} // namespace ARDOUR
#include "ardour/types.h"
#include "ardour/utils.h"
-using std::string;
-using std::vector;
-
class XMLNode;
namespace ARDOUR {
class IO : public SessionObject, public AutomatableControls, public Latent
{
public:
- static const string state_node_name;
+ static const std::string state_node_name;
- IO (Session&, const string& name, DataType default_type = DataType::AUDIO,
+ IO (Session&, const std::string& name, DataType default_type = DataType::AUDIO,
ChanCount in_min=ChanCount::ZERO, ChanCount in_max=ChanCount::INFINITE,
ChanCount out_min=ChanCount::ZERO, ChanCount out_max=ChanCount::INFINITE);
DataType default_type() const { return _default_type; }
void set_default_type(DataType t) { _default_type = t; }
- bool set_name (const string& str);
+ bool set_name (const std::string& str);
virtual void silence (nframes_t);
boost::shared_ptr<Bundle> bundle_for_inputs () { return _bundle_for_inputs; }
boost::shared_ptr<Bundle> bundle_for_outputs () { return _bundle_for_outputs; }
- int add_input_port (string source, void *src, DataType type = DataType::NIL);
- int add_output_port (string destination, void *src, DataType type = DataType::NIL);
+ int add_input_port (std::string source, void *src, DataType type = DataType::NIL);
+ int add_output_port (std::string destination, void *src, DataType type = DataType::NIL);
int remove_input_port (Port *, void *src);
int remove_output_port (Port *, void *src);
int set_input (Port *, void *src);
- int connect_input (Port *our_port, string other_port, void *src);
- int connect_output (Port *our_port, string other_port, void *src);
+ int connect_input (Port *our_port, std::string other_port, void *src);
+ int connect_output (Port *our_port, std::string other_port, void *src);
- int disconnect_input (Port *our_port, string other_port, void *src);
- int disconnect_output (Port *our_port, string other_port, void *src);
+ int disconnect_input (Port *our_port, std::string other_port, void *src);
+ int disconnect_output (Port *our_port, std::string other_port, void *src);
int disconnect_inputs (void *src);
int disconnect_outputs (void *src);
/* AudioTrack::deprecated_use_diskstream_connections() needs these */
- int set_inputs (const string& str);
- int set_outputs (const string& str);
+ int set_inputs (const std::string& str);
+ int set_outputs (const std::string& str);
void increment_output_offset (nframes_t);
void cycle_start (nframes_t);
std::vector<UserBundleInfo> _bundles_connected_to_outputs; ///< user bundles connected to our outputs
std::vector<UserBundleInfo> _bundles_connected_to_inputs; ///< user bundles connected to our inputs
- static int parse_io_string (const string&, vector<string>& chns);
+ static int parse_io_string (const std::string&, std::vector<std::string>& chns);
- static int parse_gain_string (const string&, vector<string>& chns);
+ static int parse_gain_string (const std::string&, std::vector<std::string>& chns);
- int set_sources (vector<string>&, void *src, bool add);
- int set_destinations (vector<string>&, void *src, bool add);
+ int set_sources (std::vector<std::string>&, void *src, bool add);
+ int set_destinations (std::vector<std::string>&, void *src, bool add);
int ensure_inputs (ChanCount, bool clear, bool lockit, void *src);
int ensure_outputs (ChanCount, bool clear, bool lockit, void *src);
int get_port_counts (const XMLNode& node);
int create_ports (const XMLNode&);
int make_connections (const XMLNode&);
- boost::shared_ptr<Bundle> find_possible_bundle (const string &desired_name, const string &default_name, const string &connection_type_name);
+ boost::shared_ptr<Bundle> find_possible_bundle (const std::string &desired_name, const std::string &default_name, const std::string &connection_type_name);
virtual void setup_peak_meters ();
void meter ();
#include "ardour/ardour.h"
#include "ardour/processor.h"
-using std::string;
-
class XMLNode;
namespace ARDOUR {
class IOProcessor : public Processor
{
public:
- IOProcessor (Session&, const string& proc_name, const string io_name="",
+ IOProcessor (Session&, const std::string& proc_name, const std::string io_name="",
ARDOUR::DataType default_type = DataType::AUDIO);
- IOProcessor (Session&, IO* io, const string& proc_name,
+ IOProcessor (Session&, IO* io, const std::string& proc_name,
ARDOUR::DataType default_type = DataType::AUDIO);
virtual ~IOProcessor ();
#include "ardour/ardour.h"
-using std::string;
-
namespace ARDOUR {
class Location : public PBD::StatefulDestructible
Location (nframes_t sample_start,
nframes_t sample_end,
- const string &name,
+ const std::string &name,
Flags bits = Flags(0))
: _name (name),
int move_to (nframes_t pos);
- const string& name() const { return _name; }
- void set_name (const string &str) { _name = str; name_changed(this); }
+ const std::string& name() const { return _name; }
+ void set_name (const std::string &str) { _name = str; name_changed(this); }
void set_auto_punch (bool yn, void *src);
void set_auto_loop (bool yn, void *src);
/* CD Track / CD-Text info */
- std::map<string, string> cd_info;
- XMLNode& cd_info_node (const string &, const string &);
+ std::map<std::string, std::string> cd_info;
+ XMLNode& cd_info_node (const std::string &, const std::string &);
XMLNode& get_state (void);
int set_state (const XMLNode&);
private:
- string _name;
+ std::string _name;
nframes_t _start;
nframes_t _end;
Flags _flags;
Location* end_location() const;
Location* start_location() const;
- int next_available_name(string& result,string base);
+ int next_available_name(std::string& result,std::string base);
uint32_t num_range_markers() const;
int set_current (Location *, bool want_lock = true);
{
public:
LocationImportHandler (XMLTree const & source, Session & session);
- string get_info () const;
+ std::string get_info () const;
};
class LocationImporter : public ElementImporter
LocationImporter (XMLTree const & source, Session & session, LocationImportHandler & handler, XMLNode const & node);
~LocationImporter ();
- string get_info () const;
+ std::string get_info () const;
protected:
bool _prepare_move ();
{ return _master_devices_by_model[model_name]; }
boost::shared_ptr<ChannelNameSet> find_channel_name_set(
- string model,
- string custom_device_mode,
+ std::string model,
+ std::string custom_device_mode,
uint8_t channel) {
boost::shared_ptr<MIDI::Name::MasterDeviceNames> master_device = master_device_by_model(model);
boost::shared_ptr<Patch> find_patch(
- string model,
- string custom_device_mode,
+ std::string model,
+ std::string custom_device_mode,
uint8_t channel,
PatchPrimaryKey patch_key) {
}
boost::shared_ptr<Patch> previous_patch(
- string model,
- string custom_device_mode,
+ std::string model,
+ std::string custom_device_mode,
uint8_t channel,
PatchPrimaryKey patch_key) {
}
boost::shared_ptr<Patch> next_patch(
- string model,
- string custom_device_mode,
+ std::string model,
+ std::string custom_device_mode,
uint8_t channel,
PatchPrimaryKey patch_key) {
}
}
- std::list<string> custom_device_mode_names_by_model(std::string model_name) {
+ std::list<std::string> custom_device_mode_names_by_model(std::string model_name) {
if (model_name != "") {
return master_device_by_model(model_name)->custom_device_mode_names();
} else {
- return std::list<string>();
+ return std::list<std::string>();
}
}
{
public:
MidiPlaylist (Session&, const XMLNode&, bool hidden = false);
- MidiPlaylist (Session&, string name, bool hidden = false);
- MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, string name, bool hidden = false);
+ MidiPlaylist (Session&, std::string name, bool hidden = false);
+ MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, std::string name, bool hidden = false);
MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, nframes_t start, nframes_t cnt,
- string name, bool hidden = false);
+ std::string name, bool hidden = false);
~MidiPlaylist ();
class XMLNode;
-using std::vector;
-
namespace ARDOUR {
class Route;
XMLNode& state (bool);
int set_state (const XMLNode&);
- int separate_by_channel (ARDOUR::Session&, vector< boost::shared_ptr<Region> >&) const;
+ int separate_by_channel (ARDOUR::Session&, std::vector< boost::shared_ptr<Region> >&) const;
/* automation */
#include "ardour/automation_control.h"
#include "ardour/processor.h"
-using std::istream;
-using std::ostream;
-
namespace ARDOUR {
class Route;
/* old school automation loading */
- virtual int load (istream&, string path, uint32_t&) = 0;
+ virtual int load (std::istream&, std::string path, uint32_t&) = 0;
protected:
friend class Panner;
/* old school automation loading */
- int load (istream&, string path, uint32_t&);
+ int load (std::istream&, std::string path, uint32_t&);
protected:
float left;
void get_desired_coefficients (pan_t*) const;
static StreamPanner* factory (Panner&, Evoral::Parameter param);
- static string name;
+ static std::string name;
XMLNode& state (bool full_state);
XMLNode& get_state (void);
nframes_t start, nframes_t end, nframes_t nframes, pan_t** buffers);
static StreamPanner* factory (Panner&, Evoral::Parameter);
- static string name;
+ static std::string name;
XMLNode& state (bool full_state);
XMLNode& get_state (void);
/* old school automation loading */
- int load (istream&, string path, uint32_t&);
+ int load (std::istream&, std::string path, uint32_t&);
private:
void update ();
};
//Panner (std::string name, Session&, int _num_bufs);
- Panner (string name, Session&);
+ Panner (std::string name, Session&);
virtual ~Panner ();
void clear_panners ();
public boost::noncopyable,
public boost::enable_shared_from_this<Playlist> {
public:
- typedef list<boost::shared_ptr<Region> > RegionList;
+ typedef std::list<boost::shared_ptr<Region> > RegionList;
Playlist (Session&, const XMLNode&, DataType type, bool hidden = false);
- Playlist (Session&, string name, DataType type, bool hidden = false);
- Playlist (boost::shared_ptr<const Playlist>, string name, bool hidden = false);
- Playlist (boost::shared_ptr<const Playlist>, nframes_t start, nframes_t cnt, string name, bool hidden = false);
+ Playlist (Session&, std::string name, DataType type, bool hidden = false);
+ Playlist (boost::shared_ptr<const Playlist>, std::string name, bool hidden = false);
+ Playlist (boost::shared_ptr<const Playlist>, nframes_t start, nframes_t cnt, std::string name, bool hidden = false);
virtual ~Playlist ();
void release();
bool used () const { return _refcnt != 0; }
- bool set_name (const string& str);
+ bool set_name (const std::string& str);
const DataType& data_type() const { return _type; }
void shuffle (boost::shared_ptr<Region>, int dir);
void update_after_tempo_map_change ();
- boost::shared_ptr<Playlist> cut (list<AudioRange>&, bool result_is_hidden = true);
- boost::shared_ptr<Playlist> copy (list<AudioRange>&, bool result_is_hidden = true);
+ boost::shared_ptr<Playlist> cut (
std::list<AudioRange>&, bool result_is_hidden = true);
+ boost::shared_ptr<Playlist> copy (
std::list<AudioRange>&, bool result_is_hidden = true);
int paste (boost::shared_ptr<Playlist>, nframes_t position, float times);
RegionList* regions_at (nframes_t frame);
sigc::signal<void> Modified;
sigc::signal<void> NameChanged;
sigc::signal<void> LengthChanged;
- sigc::signal<void, list< Evoral::RangeMove<nframes_t> > const &> RangesMoved;
+ sigc::signal<void, std::list< Evoral::RangeMove<nframes_t> > const &> RangesMoved;
- static string bump_name (string old_name, Session&);
+ static std::string bump_name (std::string old_name, Session&);
void freeze ();
void thaw ();
RegionList pending_bounds;
bool pending_modified;
bool pending_length;
- list< Evoral::RangeMove<nframes_t> > pending_range_moves;
+ std::list< Evoral::RangeMove<nframes_t> > pending_range_moves;
bool save_on_thaw;
- string last_save_reason;
+ std::string last_save_reason;
uint32_t in_set_state;
bool first_set_state;
bool _hidden;
nframes_t _get_maximum_extent() const;
boost::shared_ptr<Playlist> cut_copy (boost::shared_ptr<Playlist> (Playlist::*pmf)(nframes_t, nframes_t, bool),
- list<AudioRange>& ranges, bool result_is_hidden);
+
std::list<AudioRange>& ranges, bool result_is_hidden);
boost::shared_ptr<Playlist> cut (nframes_t start, nframes_t cnt, bool result_is_hidden);
boost::shared_ptr<Playlist> copy (nframes_t start, nframes_t cnt, bool result_is_hidden);
static sigc::signal<void,boost::shared_ptr<Playlist>, bool> PlaylistCreated;
static boost::shared_ptr<Playlist> create (Session&, const XMLNode&, bool hidden = false, bool unused = false);
- static boost::shared_ptr<Playlist> create (DataType type, Session&, string name, bool hidden = false);
- static boost::shared_ptr<Playlist> create (boost::shared_ptr<const Playlist>, string name, bool hidden = false);
- static boost::shared_ptr<Playlist> create (boost::shared_ptr<const Playlist>, nframes_t start, nframes_t cnt, string name, bool hidden = false);
+ static boost::shared_ptr<Playlist> create (DataType type, Session&, std::string name, bool hidden = false);
+ static boost::shared_ptr<Playlist> create (boost::shared_ptr<const Playlist>, std::string name, bool hidden = false);
+ static boost::shared_ptr<Playlist> create (boost::shared_ptr<const Playlist>, nframes_t start, nframes_t cnt, std::string name, bool hidden = false);
};
}
#include <set>
#include <map>
-using std::string;
-using std::vector;
-using std::set;
-using std::map;
-
namespace ARDOUR {
class AudioEngine;
index(o.index) {}
virtual ~PluginInfo () { }
- string name;
- string category;
+ std::string name;
+ std::string category;
Glib::ustring creator;
Glib::ustring path;
ChanCount n_inputs;
bool toggled;
bool logarithmic;
bool sr_dependent;
- string label;
+ std::string label;
float lower;
float upper;
float step;
nframes_t nframes, nframes_t offset) = 0;
virtual std::set<Evoral::Parameter> automatable() const = 0;
- virtual string describe_parameter (Evoral::Parameter) = 0;
- virtual string state_node_name() const = 0;
+ virtual std::string describe_parameter (Evoral::Parameter) = 0;
+ virtual std::string state_node_name() const = 0;
virtual void print_parameter (uint32_t, char*, uint32_t len) const = 0;
virtual bool parameter_is_audio(uint32_t) const = 0;
virtual bool parameter_is_input(uint32_t) const = 0;
virtual bool parameter_is_output(uint32_t) const = 0;
- virtual bool save_preset(string uri) = 0;
- virtual bool load_preset (const string uri);
+ virtual bool save_preset (std::string uri) = 0;
+ virtual bool load_preset (const std::string uri);
struct PresetRecord {
PresetRecord(const std::string& u, const std::string& l) : uri(u), label(l) {}
- string uri;
- string label;
+ std::string uri;
+ std::string label;
};
virtual std::vector<PresetRecord> get_presets();
- const PresetRecord* preset_by_label(const string& label);
- const PresetRecord* preset_by_uri(const string& uri);
+ const PresetRecord* preset_by_label(const std::string& label);
+ const PresetRecord* preset_by_uri(const std::string& uri);
virtual bool has_editor() const = 0;
virtual void set_parameter (uint32_t which, float val) = 0;
- bool save_preset (string uri, string domain /* vst, ladspa etc. */);
+ bool save_preset (std::string uri, std::string domain /* vst, ladspa etc. */);
ARDOUR::AudioEngine& _engine;
ARDOUR::Session& _session;
PluginInfoPtr _info;
uint32_t _cycles;
- map<string,PresetRecord> presets;
+ std::map<std::string,PresetRecord> presets;
};
-PluginPtr find_plugin(ARDOUR::Session&, string unique_id, ARDOUR::PluginType);
+PluginPtr find_plugin(ARDOUR::Session&, std::string unique_id, ARDOUR::PluginType);
} // namespace ARDOUR
PluginInsert (Session&, const XMLNode&);
~PluginInsert ();
- static const string port_automation_node_name;
+ static const std::string port_automation_node_name;
XMLNode& state(bool);
XMLNode& get_state(void);
PluginType type ();
- string describe_parameter (Evoral::Parameter param);
+ std::string describe_parameter (Evoral::Parameter param);
nframes_t signal_latency() const;
class Processor : public SessionObject, public AutomatableControls, public Latent
{
public:
- static const string state_node_name;
+ static const std::string state_node_name;
- Processor(Session&, const string& name);
+ Processor(Session&, const std::string& name);
virtual ~Processor() { }
#include <utility>
#include <string>
-using std::deque;
-using std::pair;
-using std::string;
-
namespace ARDOUR {
- typedef deque<pair<string,string> > RecentSessions;
+ typedef std::deque<std::pair<std::string,std::string> > RecentSessions;
int read_recent_sessions (RecentSessions& rs);
- int store_recent_sessions (string name, string path);
+ int store_recent_sessions (std::string name, std::string path);
int write_recent_sessions (RecentSessions& rs);
}; // namespace ARDOUR
virtual bool should_save_state () const { return !(_flags & DoNotSaveState); };
void freeze ();
- void thaw (const string& why);
+ void thaw (const std::string& why);
bool covers (nframes_t frame) const {
return first_frame() <= frame && frame <= last_frame();
const SourceList& sources() const { return _sources; }
const SourceList& master_sources() const { return _master_sources; }
- std::vector<string> master_source_names();
+ std::vector<std::string> master_source_names();
void set_master_sources (const SourceList&);
/* automation */
friend class RegionFactory;
Region (boost::shared_ptr<Source> src, nframes_t start, nframes_t length,
- const string& name, DataType type, layer_t = 0, Flag flags = DefaultFlags);
+ const std::string& name, DataType type, layer_t = 0, Flag flags = DefaultFlags);
Region (const SourceList& srcs, nframes_t start, nframes_t length,
- const string& name, DataType type, layer_t = 0, Flag flags = DefaultFlags);
+ const std::string& name, DataType type, layer_t = 0, Flag flags = DefaultFlags);
- Region (boost::shared_ptr<const Region>, nframes_t start, nframes_t length, const string& name, layer_t = 0, Flag flags = DefaultFlags);
- Region (boost::shared_ptr<const Region>, nframes_t length, const string& name, layer_t = 0, Flag flags = DefaultFlags);
+ Region (boost::shared_ptr<const Region>, nframes_t start, nframes_t length, const std::string& name, layer_t = 0, Flag flags = DefaultFlags);
+ Region (boost::shared_ptr<const Region>, nframes_t length, const std::string& name, layer_t = 0, Flag flags = DefaultFlags);
Region (boost::shared_ptr<const Region>);
Region (boost::shared_ptr<Source> src, const XMLNode&);
Region (const SourceList& srcs, const XMLNode&);
- Region (Session& s, nframes_t start, nframes_t length, const string& name, DataType, layer_t = 0, Flag flags = DefaultFlags);
+ Region (Session& s, nframes_t start, nframes_t length, const std::string& name, DataType, layer_t = 0, Flag flags = DefaultFlags);
protected:
- void copy_stuff (boost::shared_ptr<const Region>, nframes_t start, nframes_t length, const string& name, layer_t, Flag flags);
+ void copy_stuff (boost::shared_ptr<const Region>, nframes_t start, nframes_t length, const std::string& name, layer_t, Flag flags);
XMLNode& get_short_state (); /* used only by Session */
static boost::shared_ptr<Region> create (boost::shared_ptr<AudioRegion>, nframes_t start,
nframes_t length, const std::string& name,
layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
- static boost::shared_ptr<Region> create (boost::shared_ptr<Region>, const SourceList&, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
- static boost::shared_ptr<Region> create (boost::shared_ptr<Source>, nframes_t start, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
- static boost::shared_ptr<Region> create (const SourceList &, nframes_t start, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
+ static boost::shared_ptr<Region> create (boost::shared_ptr<Region>, const SourceList&, const std::string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
+ static boost::shared_ptr<Region> create (boost::shared_ptr<Source>, nframes_t start, nframes_t length, const std::string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
+ static boost::shared_ptr<Region> create (const SourceList &, nframes_t start, nframes_t length, const std::string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
static boost::shared_ptr<Region> create (Session&, XMLNode&, bool);
static boost::shared_ptr<Region> create (SourceList &, const XMLNode&);
};
{
protected:
- typedef list<boost::shared_ptr<Processor> > ProcessorList;
+ typedef
std::list<boost::shared_ptr<Processor> > ProcessorList;
public:
sigc::signal<void,void*> SelectedChanged;
- int set_control_outs (const vector<std::string>& ports);
+ int set_control_outs (const std::vector<std::string>& ports);
boost::shared_ptr<ControlOutputs> control_outs() { return _control_outs; }
bool feeds (boost::shared_ptr<Route>);
#include "pbd/stateful.h"
#include "ardour/types.h"
-using std::string;
-using std::list;
-
namespace ARDOUR {
class Route;
Hidden = 0x4
};
- RouteGroup (Session& s, const string &n, Flag f = Flag(0));
+ RouteGroup (Session& s, const std::string &n, Flag f = Flag(0));
- const string& name() { return _name; }
+ const std::string& name() { return _name; }
void set_name (std::string str);
bool is_active () const { return _flags & Active; }
int remove (Route *);
void apply (void (Route::*func)(void *), void *src) {
- for (list<Route *>::iterator i = routes.begin(); i != routes.end(); i++) {
+ for (std::list<Route *>::iterator i = routes.begin(); i != routes.end(); i++) {
((*i)->*func)(src);
}
}
template<class T> void apply (void (Route::*func)(T, void *), T val, void *src) {
- for (list<Route *>::iterator i = routes.begin(); i != routes.end(); i++) {
+ for (std::list<Route *>::iterator i = routes.begin(); i != routes.end(); i++) {
((*i)->*func)(val, src);
}
}
template<class T> void foreach_route (T *obj, void (T::*func)(Route&)) {
- for (list<Route *>::iterator i = routes.begin(); i != routes.end(); i++) {
+ for (std::list<Route *>::iterator i = routes.begin(); i != routes.end(); i++) {
(obj->*func)(**i);
}
}
changed();
}
- const list<Route*>& route_list() { return routes; }
+ const std::list<Route*>& route_list() { return routes; }
sigc::signal<void> changed;
sigc::signal<void,void*> FlagsChanged;
private:
Session& _session;
- list<Route *> routes;
- string _name;
+ std::list<Route *> routes;
+ std::string _name;
Flag _flags;
void remove_when_going_away (Route*);
template<class T> void
RouteGroup::apply (void (Track::*func)(T, void *), T val, void *src)
{
- for (list<Route *>::iterator i = routes.begin(); i != routes.end(); i++) {
+ for (std::list<Route *>::iterator i = routes.begin(); i != routes.end(); i++) {
Track *at;
if ((at = dynamic_cast<Track*>(*i)) != 0) {
(at->*func)(val, this);
class TempoMap;
class VSTPlugin;
-using std::vector;
-using std::string;
-using std::map;
-using std::set;
-
class Session : public PBD::StatefulDestructible, public boost::noncopyable
{
private:
typedef std::pair<boost::weak_ptr<Route>,bool> RouteBooleanState;
- typedef vector<RouteBooleanState> GlobalRouteBooleanState;
+ typedef std::vector<RouteBooleanState> GlobalRouteBooleanState;
typedef std::pair<boost::weak_ptr<Route>,MeterPoint> RouteMeterState;
- typedef vector<RouteMeterState> GlobalRouteMeterState;
+ typedef std::vector<RouteMeterState> GlobalRouteMeterState;
public:
enum RecordState {
Route* route;
};
- list<AudioRange> audio_range;
- list<MusicRange> music_range;
+
std::list<AudioRange> audio_range;
+ std::list<MusicRange> music_range;
boost::shared_ptr<Region> region;
/* creating from an XML file */
Session (AudioEngine&,
- const string& fullpath,
- const string& snapshot_name,
- string mix_template = "");
+ const std::string& fullpath,
+ const std::string& snapshot_name,
+ std::string mix_template = "");
/* creating a new Session */
Session (AudioEngine&,
- string fullpath,
- string snapshot_name,
+ std::string fullpath,
+ std::string snapshot_name,
AutoConnectOption input_auto_connect,
AutoConnectOption output_auto_connect,
uint32_t control_out_channels,
virtual ~Session ();
- string path() const { return _path; }
- string name() const { return _name; }
- string snap_name() const { return _current_snapshot_name; }
- string raid_path () const;
+ std::string path() const { return _path; }
+ std::string name() const { return _name; }
+ std::string snap_name() const { return _current_snapshot_name; }
+ std::string raid_path () const;
void set_snap_name ();
Glib::ustring peak_path (Glib::ustring) const;
- static string change_source_path_by_name (string oldpath, string oldname, string newname, bool destructive);
+ static std::string change_source_path_by_name (std::string oldpath, std::string oldname, std::string newname, bool destructive);
- string peak_path_from_audio_path (string) const;
- string new_audio_source_name (const string&, uint32_t nchans, uint32_t chan, bool destructive);
- string new_midi_source_name (const string&);
- string new_source_path_from_name (DataType type, const string&);
+ std::string peak_path_from_audio_path (std::string) const;
+ std::string new_audio_source_name (const std::string&, uint32_t nchans, uint32_t chan, bool destructive);
+ std::string new_midi_source_name (const std::string&);
+ std::string new_source_path_from_name (DataType type, const std::string&);
RouteList new_route_from_template (uint32_t how_many, const std::string& template_path);
void process (nframes_t nframes);
void add_diskstream (boost::shared_ptr<Diskstream>);
boost::shared_ptr<Diskstream> diskstream_by_id (const PBD::ID& id);
- boost::shared_ptr<Diskstream> diskstream_by_name (string name);
+ boost::shared_ptr<Diskstream> diskstream_by_name (std::string name);
bool have_rec_enabled_diskstream () const;
bool have_captured() const { return _have_captured; }
template<class T> void foreach_route (T *obj, void (T::*func)(boost::shared_ptr<Route>));
template<class T, class A> void foreach_route (T *obj, void (T::*func)(Route&, A), A arg);
- boost::shared_ptr<Route> route_by_name (string);
+ boost::shared_ptr<Route> route_by_name (std::string);
boost::shared_ptr<Route> route_by_id (PBD::ID);
boost::shared_ptr<Route> route_by_remote_id (uint32_t id);
- bool route_name_unique (string) const;
- bool route_name_internal (string) const;
+ bool route_name_unique (std::string) const;
+ bool route_name_internal (std::string) const;
bool get_record_enabled() const {
return (record_status () >= Enabled);
void set_auto_punch_location (Location *);
void set_auto_loop_location (Location *);
- int location_name(string& result, string base = string(""));
+ int location_name(std::string& result, std::string base = std::string(""));
void reset_input_monitor_state ();
static int rename_template (std::string old_name, std::string new_name);
static int delete_template (std::string name);
- sigc::signal<void,string> StateSaved;
+ sigc::signal<void,std::string> StateSaved;
sigc::signal<void> StateReady;
- vector<string*>* possible_states() const;
- static vector<string*>* possible_states(string path);
+ std::vector<std::string*>* possible_states() const;
+ static std::vector<std::string*>* possible_states (std::string path);
XMLNode& get_state();
int set_state(const XMLNode& node); // not idempotent
StateOfTheState state_of_the_state() const { return _state_of_the_state; }
- RouteGroup* add_edit_group (string);
- RouteGroup* add_mix_group (string);
+ RouteGroup* add_edit_group (std::string);
+ RouteGroup* add_mix_group (std::string);
void remove_edit_group (RouteGroup&);
void remove_mix_group (RouteGroup&);
- RouteGroup *mix_group_by_name (string);
- RouteGroup *edit_group_by_name (string);
+ RouteGroup *mix_group_by_name (std::string);
+ RouteGroup *edit_group_by_name (std::string);
sigc::signal<void,RouteGroup*> edit_group_added;
sigc::signal<void,RouteGroup*> mix_group_added;
sigc::signal<void> mix_group_removed;
void foreach_edit_group (sigc::slot<void,RouteGroup*> sl) {
- for (list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); i++) {
+ for (std::list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); i++) {
sl (*i);
}
}
void foreach_mix_group (sigc::slot<void,RouteGroup*> sl) {
- for (list<RouteGroup *>::iterator i = mix_groups.begin(); i != mix_groups.end(); i++) {
+ for (std::list<RouteGroup *>::iterator i = mix_groups.begin(); i != mix_groups.end(); i++) {
sl (*i);
}
}
sigc::signal<void,std::vector<boost::weak_ptr<Region> >& > RegionsAdded;
sigc::signal<void,boost::weak_ptr<Region> > RegionRemoved;
- int region_name (string& result, string base = string(""), bool newlevel = false);
- string new_region_name (string);
- string path_from_region_name (DataType type, string name, string identifier);
+ int region_name (std::string& result, std::string base = std::string(""), bool newlevel = false);
+ std::string new_region_name (std::string);
+ std::string path_from_region_name (DataType type, std::string name, std::string identifier);
boost::shared_ptr<Region> find_whole_file_parent (boost::shared_ptr<Region const>);
/* source management */
struct ImportStatus : public InterThreadInfo {
- string doing_what;
+ std::string doing_what;
/* control info */
uint32_t total;
};
void import_audiofiles (ImportStatus&);
- bool sample_rate_convert (ImportStatus&, string infile, string& outfile);
- string build_tmp_convert_name (string file);
+ bool sample_rate_convert (ImportStatus&, std::string infile, std::string& outfile);
+ std::string build_tmp_convert_name (std::string file);
boost::shared_ptr<ExportHandler> get_export_handler ();
boost::shared_ptr<ExportStatus> get_export_status ();
void remove_source (boost::weak_ptr<Source>);
struct cleanup_report {
- vector<string> paths;
+ std::vector<std::string> paths;
int64_t space;
};
/* playlist management */
- boost::shared_ptr<Playlist> playlist_by_name (string name);
+ boost::shared_ptr<Playlist> playlist_by_name (std::string name);
void unassigned_playlists (std::list<boost::shared_ptr<Playlist> > & list);
void add_playlist (boost::shared_ptr<Playlist>, bool unused = false);
sigc::signal<void,boost::shared_ptr<Playlist> > PlaylistAdded;
/* named selections */
- NamedSelection* named_selection_by_name (string name);
+ NamedSelection* named_selection_by_name (std::string name);
void add_named_selection (NamedSelection *);
void remove_named_selection (NamedSelection *);
/* flattening stuff */
boost::shared_ptr<Region> write_one_track (AudioTrack&, nframes_t start, nframes_t end,
- bool overwrite, vector<boost::shared_ptr<Source> >&, InterThreadInfo& wot,
- bool enable_processing = true);
+ bool overwrite, std::vector<boost::shared_ptr<Source> >&, InterThreadInfo& wot,
+ bool enable_processing = true);
int freeze (InterThreadInfo&);
/* session-wide solo/mute/rec-enable */
void add_bundle (boost::shared_ptr<Bundle>);
void remove_bundle (boost::shared_ptr<Bundle>);
- boost::shared_ptr<Bundle> bundle_by_name (string) const;
+ boost::shared_ptr<Bundle> bundle_by_name (std::string) const;
sigc::signal<void,boost::shared_ptr<Bundle> > BundleAdded;
sigc::signal<void,boost::shared_ptr<Bundle> > BundleRemoved;
/* MIDI control */
void midi_panic(void);
- int set_mtc_port (string port_tag);
- int set_mmc_port (string port_tag);
- int set_midi_port (string port_tag);
- int set_midi_clock_port (string port_tag);
+ int set_mtc_port (std::string port_tag);
+ int set_mmc_port (std::string port_tag);
+ int set_midi_port (std::string port_tag);
+ int set_midi_clock_port (std::string port_tag);
MIDI::Port *mtc_port() const { return _mtc_port; }
MIDI::Port *mmc_port() const { return _mmc_port; }
MIDI::Port *midi_port() const { return _midi_port; }
uint32_t undo_depth() const { return _history.undo_depth(); }
uint32_t redo_depth() const { return _history.redo_depth(); }
- string next_undo() const { return _history.next_undo(); }
- string next_redo() const { return _history.next_redo(); }
+ std::string next_undo() const { return _history.next_undo(); }
+ std::string next_redo() const { return _history.next_redo(); }
- void begin_reversible_command (const string& cmd_name);
+ void begin_reversible_command (const std::string& cmd_name);
void commit_reversible_command (Command* cmd = 0);
void add_command (Command *const cmd) {
/* ranges */
- void set_audio_range (list<AudioRange>&);
- void set_music_range (list<MusicRange>&);
+ void set_audio_range (
std::list<AudioRange>&);
+ void set_music_range (std::list<MusicRange>&);
void request_play_range (bool yn);
bool get_play_range () const { return _play_range; }
void update_latency_compensation (bool, bool);
private:
- int create (bool& new_session, const string& mix_template, nframes_t initial_length);
+ int create (bool& new_session, const std::string& mix_template, nframes_t initial_length);
void destroy ();
nframes_t compute_initial_length ();
MIDI::Port* _mtc_port;
MIDI::Port* _midi_port;
MIDI::Port* _midi_clock_port;
- string _path;
- string _name;
+ std::string _path;
+ std::string _name;
bool session_send_mmc;
bool session_send_mtc;
bool session_midi_feedback;
void when_engine_running ();
void graph_reordered ();
- string _current_snapshot_name;
+ std::string _current_snapshot_name;
XMLTree* state_tree;
bool state_was_pending;
void auto_save();
int load_options (const XMLNode&);
XMLNode& get_options () const;
- int load_state (string snapshot_name);
+ int load_state (std::string snapshot_name);
bool save_config_options_predicate (ConfigVariableBase::Owner owner) const;
nframes_t _last_roll_location;
sigc::connection auto_loop_changed_connection;
void auto_loop_changed (Location *);
- typedef list<Event *> Events;
+ typedef std::list<Event *> Events;
Events events;
Events immediate_events;
Events::iterator next_event;
bool _remove_event (Event *);
void _clear_event_type (Event::Type);
- void first_stage_init (string path, string snapshot_name);
+ void first_stage_init (std::string path, std::string snapshot_name);
int second_stage_init (bool new_tracks);
void find_current_end ();
void remove_empty_sounds ();
double step_speed;
typedef sigc::slot<bool> MidiTimeoutCallback;
- typedef list<MidiTimeoutCallback> MidiTimeoutList;
+ typedef std::list<MidiTimeoutCallback> MidiTimeoutList;
MidiTimeoutList midi_timeouts;
bool mmc_step_timeout ();
int load_mix_groups (const XMLNode&);
- list<RouteGroup *> edit_groups;
- list<RouteGroup *> mix_groups;
+ std::list<RouteGroup *> edit_groups;
+ std::list<RouteGroup *> mix_groups;
/* disk-streams */
void catch_up_on_solo_mute_override ();
void update_route_solo_state ();
void modify_solo_mute (bool, bool);
- void strip_portname_for_solo (string& portname);
+ void strip_portname_for_solo (std::string& portname);
/* REGION MANAGEMENT */
void update_region_name_map (boost::shared_ptr<Region>);
mutable Glib::Mutex region_lock;
- typedef map<PBD::ID,boost::shared_ptr<Region> > RegionList;
+ typedef
std::map<PBD::ID,boost::shared_ptr<Region> > RegionList;
RegionList regions;
void add_region (boost::shared_ptr<Region>);
/* PLAYLISTS */
mutable Glib::Mutex playlist_lock;
- typedef set<boost::shared_ptr<Playlist> > PlaylistList;
+ typedef s
td::set<boost::shared_ptr<Playlist> > PlaylistList;
PlaylistList playlists;
PlaylistList unused_playlists;
void remove_playlist (boost::weak_ptr<Playlist>);
void track_playlist (bool, boost::weak_ptr<Playlist>);
- boost::shared_ptr<Playlist> playlist_factory (string name);
+ boost::shared_ptr<Playlist> playlist_factory (std::string name);
boost::shared_ptr<Playlist> XMLPlaylistFactory (const XMLNode&);
void playlist_length_changed ();
/* NAMED SELECTIONS */
mutable Glib::Mutex named_selection_lock;
- typedef set<NamedSelection *> NamedSelectionList;
+ typedef std::set<NamedSelection *> NamedSelectionList;
NamedSelectionList named_selections;
int load_named_selections (const XMLNode&);
- NamedSelection *named_selection_factory (string name);
+ NamedSelection *named_selection_factory (std::string name);
NamedSelection *XMLNamedSelectionFactory (const XMLNode&);
/* CURVES and AUTOMATION LISTS */
/* INSERT AND SEND MANAGEMENT */
- list<PortInsert *> _port_inserts;
- list<PluginInsert *> _plugin_inserts;
- list<Send *> _sends;
- list<Return *> _returns;
+
std::list<PortInsert *> _port_inserts;
+
std::list<PluginInsert *> _plugin_inserts;
+ std::list<Send *> _sends;
+ std::list<Return *> _returns;
boost::dynamic_bitset<uint32_t> send_bitset;
boost::dynamic_bitset<uint32_t> return_bitset;
boost::dynamic_bitset<uint32_t> insert_bitset;
struct space_and_path {
uint32_t blocks; /* 4kB blocks */
- string path;
+ std::string path;
space_and_path() {
blocks = 0;
}
};
- void setup_raid_path (string path);
+ void setup_raid_path (std::string path);
- vector<space_and_path> session_dirs;
- vector<space_and_path>::iterator last_rr_session_dir;
+ std::vector<space_and_path> session_dirs;
+ std::vector<space_and_path>::iterator last_rr_session_dir;
uint32_t _total_free_4k_blocks;
Glib::Mutex space_lock;
- string get_best_session_directory_for_new_source ();
+ std::string get_best_session_directory_for_new_source ();
void refresh_disk_space ();
mutable gint _playback_load;
static Pool pool;
};
- typedef list<Click*> Clicks;
+ typedef std::list<Click*> Clicks;
Clicks clicks;
bool _clicking;
void clear_clicks ();
void click (nframes_t start, nframes_t nframes);
- vector<Route*> master_outs;
+ std::vector<Route*> master_outs;
/* range playback */
- list<AudioRange> current_audio_range;
+
std::list<AudioRange> current_audio_range;
bool _play_range;
void set_play_range (bool yn);
void setup_auto_play ();
namespace ARDOUR {
-using std::string;
-using std::vector;
-using PBD::sys::path;
-
class SessionDirectory
{
public:
/**
* @param session_path An absolute path to a session directory.
*/
- SessionDirectory (const path& session_path);
+ SessionDirectory (const PBD::sys::path& session_path);
/**
* @return the absolute path to the root directory of the session
*/
- const path root_path() const { return m_root_path; }
+ const PBD::sys::path root_path() const { return m_root_path; }
/**
* @return the absolute path to the directory in which
* directory otherwise it will return the new location
* of root_path()/interchange/session_name/audiofiles
*/
- const path sound_path () const;
+ const PBD::sys::path sound_path () const;
/**
* @return the absolute path to the directory in which
* the session stores MIDI files, ie
* root_path()/interchange/session_name/midifiles
*/
- const path midi_path () const;
+ const PBD::sys::path midi_path () const;
/**
* @return the absolute path to the directory in which
* the session stores MIDNAM patch files, ie
* root_path()/interchange/session_name/patchfiles
*/
- const path midi_patch_path () const;
+ const PBD::sys::path midi_patch_path () const;
/**
* @return The absolute path to the directory in which all
* peak files are stored for a session.
*/
- const path peak_path () const;
+ const PBD::sys::path peak_path () const;
/**
* @return The absolute path to the directory that audio
* files are moved to when they are no longer part of the
* session.
*/
- const path dead_sound_path () const;
+ const PBD::sys::path dead_sound_path () const;
/**
* @return The absolute path to the directory that midi
* files are moved to when they are no longer part of the
* session.
*/
- const path dead_midi_path () const;
+ const PBD::sys::path dead_midi_path () const;
/**
* @return The absolute path to the directory that audio
* files are created in by default when exporting.
*/
- const path export_path () const;
+ const PBD::sys::path export_path () const;
/**
* @return true if session directory and all the required
* @return The path to the old style sound directory.
* It isn't created by create().
*/
- const path old_sound_path () const;
+ const PBD::sys::path old_sound_path () const;
/**
* @return The path to the directory under which source directories
* are created for different source types.
* i.e root_path()/interchange/session_name
*/
- const path sources_root() const;
+ const PBD::sys::path sources_root() const;
/**
* @return a vector containing the fullpath of all subdirectories.
*/
- const vector<PBD::sys::path> sub_directories () const;
+ const
std::vector<PBD::sys::path> sub_directories () const;
/// The path to the root of the session directory.
- const path m_root_path;
+ const PBD::sys::path m_root_path;
};
} // namespace ARDOUR
namespace ARDOUR {
-using std::string;
-using Glib::ustring;
-
/** Represents metadata associated to a Session
* Metadata can be accessed and edited via this class.
* Exported files can also be tagged with this data.
~SessionMetadata ();
/*** Accessing ***/
- ustring comment () const;
- ustring copyright () const;
- ustring isrc () const;
+ Glib::ustring comment () const;
+ Glib::ustring copyright () const;
+ Glib::ustring isrc () const;
uint32_t year () const;
- ustring grouping () const;
- ustring title () const;
- ustring subtitle () const;
+ Glib::ustring grouping () const;
+ Glib::ustring title () const;
+ Glib::ustring subtitle () const;
- ustring artist () const;
- ustring album_artist () const;
- ustring lyricist () const;
- ustring composer () const;
- ustring conductor () const;
- ustring remixer () const;
- ustring arranger () const;
- ustring engineer () const;
- ustring producer () const;
- ustring dj_mixer () const;
- ustring mixer () const;
+ Glib::ustring artist () const;
+ Glib::ustring album_artist () const;
+ Glib::ustring lyricist () const;
+ Glib::ustring composer () const;
+ Glib::ustring conductor () const;
+ Glib::ustring remixer () const;
+ Glib::ustring arranger () const;
+ Glib::ustring engineer () const;
+ Glib::ustring producer () const;
+ Glib::ustring dj_mixer () const;
+ Glib::ustring mixer () const;
- ustring album () const;
- ustring compilation () const;
- ustring disc_subtitle () const;
+ Glib::ustring album () const;
+ Glib::ustring compilation () const;
+ Glib::ustring disc_subtitle () const;
uint32_t disc_number () const;
uint32_t total_discs () const;
uint32_t track_number () const;
uint32_t total_tracks () const;
- ustring genre () const;
+ Glib::ustring genre () const;
/*** Editing ***/
- void set_comment (const ustring &);
- void set_copyright (const ustring &);
- void set_isrc (const ustring &);
+ void set_comment (const Glib::ustring &);
+ void set_copyright (const Glib::ustring &);
+ void set_isrc (const Glib::ustring &);
void set_year (uint32_t);
- void set_grouping (const ustring &);
- void set_title (const ustring &);
- void set_subtitle (const ustring &);
+ void set_grouping (const Glib::ustring &);
+ void set_title (const Glib::ustring &);
+ void set_subtitle (const Glib::ustring &);
- void set_artist (const ustring &);
- void set_album_artist (const ustring &);
- void set_lyricist (const ustring &);
- void set_composer (const ustring &);
- void set_conductor (const ustring &);
- void set_remixer (const ustring &);
- void set_arranger (const ustring &);
- void set_engineer (const ustring &);
- void set_producer (const ustring &);
- void set_dj_mixer (const ustring &);
- void set_mixer (const ustring &);
+ void set_artist (const Glib::ustring &);
+ void set_album_artist (const Glib::ustring &);
+ void set_lyricist (const Glib::ustring &);
+ void set_composer (const Glib::ustring &);
+ void set_conductor (const Glib::ustring &);
+ void set_remixer (const Glib::ustring &);
+ void set_arranger (const Glib::ustring &);
+ void set_engineer (const Glib::ustring &);
+ void set_producer (const Glib::ustring &);
+ void set_dj_mixer (const Glib::ustring &);
+ void set_mixer (const Glib::ustring &);
- void set_album (const ustring &);
- void set_compilation (const ustring &);
- void set_disc_subtitle (const ustring &);
+ void set_album (const Glib::ustring &);
+ void set_compilation (const Glib::ustring &);
+ void set_disc_subtitle (const Glib::ustring &);
void set_disc_number (uint32_t);
void set_total_discs (uint32_t);
void set_track_number (uint32_t);
void set_total_tracks (uint32_t);
- void set_genre (const ustring &);
+ void set_genre (const Glib::ustring &);
/*** Serialization ***/
XMLNode & get_state ();
private:
- typedef std::pair<ustring, ustring> Property;
- typedef std::map<ustring, ustring> PropertyMap;
+ typedef std::pair<Glib::ustring, Glib::ustring> Property;
+ typedef std::map<Glib::ustring, Glib::ustring> PropertyMap;
PropertyMap map;
- XMLNode * get_xml (const ustring & name);
+ XMLNode * get_xml (const Glib::ustring & name);
- ustring get_value (const ustring & name) const;
- uint32_t get_uint_value (const ustring & name) const;
+ Glib::ustring get_value (const Glib::ustring & name) const;
+ uint32_t get_uint_value (const Glib::ustring & name) const;
- void set_value (const ustring & name, const ustring & value);
- void set_value (const ustring & name, uint32_t value);
+ void set_value (const Glib::ustring & name, const Glib::ustring & value);
+ void set_value (const Glib::ustring & name, uint32_t value);
};
} // namespace ARDOUR
namespace ARDOUR {
-using std::string;
-using std::vector;
-using namespace PBD;
-
/**
* Attempt to create a backup copy of a file.
*
*
* @return true if successful, false otherwise.
*/
-bool create_backup_file (const sys::path & file_path);
+bool create_backup_file (const PBD::sys::path & file_path);
/**
* Get the absolute paths to all state files in the directory
* @param directory_path The absolute path to a directory.
* @param result vector to contain resulting state files.
*/
-void get_state_files_in_directory (const sys::path & directory_path,
- vector<sys::path>& result);
+void get_state_files_in_directory (const PBD::sys::path & directory_path,
+ std::vector<PBD::sys::path>& result);
/**
* Given a vector of paths to files, return a vector containing
* @return a vector containing a list of file names without any
* filename extension.
*/
-vector<string> get_file_names_no_extension (const vector<sys::path> & file_paths);
+std::vector<std::string> get_file_names_no_extension (const std::vector<PBD::sys::path> & file_paths);
} // namespace ARDOUR
namespace ARDOUR {
-using std::string;
-
-int find_session (string str, string& path, string& snapshot, bool& isnew);
+int find_session (std::string str, std::string& path, std::string& snapshot, bool& isnew);
/**
* Create a SessionDirectory at the path specified by
*
* @see SessionDirectory
*/
-bool create_session_directory (const string& session_directory_path);
+bool create_session_directory (const std::string& session_directory_path);
};
#include <string>
#include <stdint.h>
-using std::string;
-
// Use this define when initializing arrarys for use in sndfile_*_format()
#define SNDFILE_STR_LENGTH 32
extern int sndfile_endian_formats[SNDFILE_ENDIAN_FORMATS];
-int sndfile_bitdepth_format_from_string(string);
-int sndfile_header_format_from_string(string);
-int sndfile_endian_format_from_string(string);
-string sndfile_file_ending_from_string(string);
+int sndfile_bitdepth_format_from_string (std::string);
+int sndfile_header_format_from_string (std::string);
+int sndfile_endian_format_from_string (std::string);
+std::string sndfile_file_ending_from_string (std::string);
int sndfile_data_width (int format);
// It'd be nice if libsndfile did this for us
-string sndfile_major_format(int);
-string sndfile_minor_format(int);
+std::string sndfile_major_format (int);
+std::string sndfile_minor_format (int);
#endif /* __sndfile_helpers_h__ */
static void setup_standard_crossfades (nframes_t sample_rate);
static const Source::Flag default_writable_flags;
- static int get_soundfile_info (const Glib::ustring& path, SoundFileInfo& _info, string& error_msg);
+ static int get_soundfile_info (const Glib::ustring& path, SoundFileInfo& _info, std::string& error_msg);
protected:
void set_header_timeline_position ();
namespace ARDOUR {
-using std::string;
-
class TapeFileMatcher
{
public:
TapeFileMatcher();
- bool matches (const string& filename) const;
+ bool matches (const std::string& filename) const;
private:
namespace ARDOUR {
- using std::vector;
- using namespace PBD;
+ PBD::sys::path system_template_directory ();
+ PBD::sys::path system_route_template_directory ();
- sys::path system_template_directory ();
- sys::path system_route_template_directory ();
-
- sys::path user_template_directory ();
- sys::path user_route_template_directory ();
+ PBD::sys::path user_template_directory ();
+ PBD::sys::path user_route_template_directory ();
struct TemplateInfo {
std::string name;
class XMLNode;
-using std::list;
-using std::vector;
-
namespace ARDOUR {
class Meter;
class Tempo {
: MetricSection (start), Meter (bpb, note_type) {}
MeterSection (const XMLNode&);
- static const string xml_state_node_name;
+ static const std::string xml_state_node_name;
XMLNode& get_state() const;
};
: MetricSection (start), Tempo (qpm, note_type) {}
TempoSection (const XMLNode&);
- static const string xml_state_node_name;
+ static const std::string xml_state_node_name;
XMLNode& get_state() const;
};
-typedef list<MetricSection*> Metrics;
+typedef std::list<MetricSection*> Metrics;
class TempoMap : public PBD::StatefulDestructible
{
: type (ty), frame (f), meter (&m), tempo (&t), bar (b), beat (e) {}
};
- typedef vector<BBTPoint> BBTPointList;
+ typedef std::vector<BBTPoint> BBTPointList;
template<class T> void apply_with_metrics (T& obj, void (T::*method)(const Metrics&)) {
Glib::RWLock::ReaderLock lm (lock);
{
public:
TempoMapImportHandler (XMLTree const & source, Session & session);
- string get_info () const;
+ std::string get_info () const;
};
class TempoMapImporter : public ElementImporter
public:
TempoMapImporter (XMLTree const & source, Session & session, XMLNode const & node);
- virtual string get_info () const;
+ virtual std::string get_info () const;
protected:
bool _prepare_move ();
class Track : public Route
{
public:
- Track (Session&, string name, Route::Flag f = Route::Flag (0), TrackMode m = Normal, DataType default_type = DataType::AUDIO);
+ Track (Session&, std::string name, Route::Flag f = Route::Flag (0), TrackMode m = Normal, DataType default_type = DataType::AUDIO);
virtual ~Track ();
boost::shared_ptr<Diskstream> diskstream() const { return _diskstream; }
- virtual int use_diskstream (string name) = 0;
+ virtual int use_diskstream (std::string name) = 0;
virtual int use_diskstream (const PBD::ID& id) = 0;
nframes_t update_total_latency();
~FreezeRecord();
boost::shared_ptr<Playlist> playlist;
- vector<FreezeRecordProcessorInfo*> processor_info;
+ std::vector<FreezeRecordProcessorInfo*> processor_info;
bool have_mementos;
FreezeState state;
gain_t gain;
#include <jack/types.h>
#include "ardour/plugin.h"
-using std::string;
-using std::vector;
-using std::list;
-using std::map;
-
struct _FSTHandle;
struct _FST;
typedef struct _FSTHandle FSTHandle;
ChanMapping in, ChanMapping out,
nframes_t nframes, nframes_t offset);
- string describe_parameter (Evoral::Parameter);
- string state_node_name() const { return "vst"; }
+ std::string describe_parameter (Evoral::Parameter);
+ std::string state_node_name() const { return "vst"; }
void print_parameter (uint32_t, char*, uint32_t len) const;
bool parameter_is_audio(uint32_t i) const { return false; }
bool parameter_is_input(uint32_t i) const { return true; }
bool parameter_is_output(uint32_t i) const { return false; }
- bool load_preset (const string preset_label );
- bool save_preset(string name);
+ bool load_preset (const std::string preset_label );
+ bool save_preset (std::string name);
bool has_editor () const;
#include "i18n.h"
using namespace std;
+using namespace PBD;
using namespace ARDOUR;
namespace {
#include "ardour/playlist.h"
#include "ardour/playlist_factory.h"
+using namespace std;
using namespace PBD;
using namespace ARDOUR;
#include "i18n.h"
+using namespace std;
using namespace PBD;
using namespace ARDOUR;
#include "i18n.h"
+using namespace std;
using namespace PBD;
using namespace ARDOUR;
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
using namespace Glib;
}
bool
-BroadcastInfo::load_from_file (string const & filename)
+BroadcastInfo::load_from_file (std::string const & filename)
{
SNDFILE * file = 0;
SF_INFO info;
return true;
}
-string
+std::string
BroadcastInfo::get_description () const
{
return info->description;
{
struct tm ret;
- string date = info->origination_date;
+ std::string date = info->origination_date;
ret.tm_year = atoi (date.substr (0, 4)) - 1900;
ret.tm_mon = atoi (date.substr (5, 2));
ret.tm_mday = atoi (date.substr (8, 2));
- string time = info->origination_time;
+ std::string time = info->origination_time;
ret.tm_hour = atoi (time.substr (0,2));
ret.tm_min = atoi (time.substr (3,2));
ret.tm_sec = atoi (time.substr (6,2));
return ret;
}
-string
+std::string
BroadcastInfo::get_originator () const
{
return info->originator;
}
-string
+std::string
BroadcastInfo::get_originator_ref () const
{
return info->originator_reference;
}
bool
-BroadcastInfo::write_to_file (string const & filename)
+BroadcastInfo::write_to_file (std::string const & filename)
{
SNDFILE * file = 0;
SF_INFO info;
}
void
-BroadcastInfo::set_description (string const & desc)
+BroadcastInfo::set_description (std::string const & desc)
{
_has_info = true;
}
void
-BroadcastInfo::set_originator (string const & str)
+BroadcastInfo::set_originator (std::string const & str)
{
_has_info = true;
}
void
-BroadcastInfo::set_originator_ref (string const & str)
+BroadcastInfo::set_originator_ref (std::string const & str)
{
_has_info = true;
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
static const char* state_node_name = "Channels";
+using namespace std;
+
namespace ARDOUR {
// infinite/zero chan count stuff, for setting minimums and maximums, etc.
const char * const surfaces_env_variable_name = "ARDOUR_SURFACES_PATH";
} // anonymous
+using namespace PBD;
+
namespace ARDOUR {
SearchPath
#include <algorithm>
+using namespace std;
using namespace ARDOUR;
bool ElementImportHandler::_dirty = false;
#include "i18n.h"
+using namespace std;
using namespace PBD;
using namespace ARDOUR;
#include "pbd/convert.h"
#include "pbd/pthread_utils.h"
+using namespace PBD;
+
namespace ARDOUR
{
#include "i18n.h"
+using namespace std;
+using namespace Glib;
using namespace PBD;
namespace ARDOUR
#include "i18n.h"
using namespace PBD;
+using namespace Glib;
namespace ARDOUR
{
#include "i18n.h"
+using namespace std;
+
namespace ARDOUR
{
#include "ardour/export_processor.h"
#include "ardour/export_failed.h"
+using namespace std;
using namespace PBD;
-using std::ofstream;
namespace ARDOUR
{
#include "ardour/session.h"
+using namespace std;
using namespace ARDOUR;
ExportPreset::ExportPreset (string filename, Session & s) :
#include "i18n.h"
+using namespace std;
+using namespace Glib;
using namespace PBD;
namespace ARDOUR
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
using namespace Glib;
#define WITH_STATIC_PATHS 1
+using namespace PBD;
+
namespace ARDOUR {
using std::string;
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
#include "i18n.h"
+using namespace std;
using namespace PBD;
int
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
-
static boost::shared_ptr<ImportableSource>
open_importable_source (const string& path, nframes_t samplerate, ARDOUR::SrcQuality quality)
{
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace sigc;
#include "i18n.h"
+using namespace std;
using namespace PBD;
using namespace ARDOUR;
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace sigc;
using namespace MIDI;
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace sigc;
using namespace MIDI;
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
#include "i18n.h"
#include <locale.h>
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
namespace ARDOUR {
+using namespace std;
using namespace PBD::sys;
SessionDirectory::SessionDirectory (const path& session_path)
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
#include <iostream>
#include <sstream>
+using namespace std;
+using namespace Glib;
using namespace ARDOUR;
-
SessionMetadata::SessionMetadata ()
{
/*** General ***/
#include "i18n.h"
+using namespace std;
+using namespace PBD;
+
namespace ARDOUR {
bool
void
get_state_files_in_directory (const sys::path & directory_path,
- vector<sys::path> & result)
+ vector<sys::path> & result)
{
Glib::PatternSpec state_file_pattern('*' + string(statefile_suffix));
#include "i18n.h"
+using namespace std;
using namespace ARDOUR;
using namespace PBD;
namespace ARDOUR {
+using namespace std;
using namespace PBD;
bool
#include "i18n.h"
+using namespace std;
+
namespace {
const char* const tape_file_regex_string = X_("/T[0-9][0-9][0-9][0-9]-");
#include "ardour/filename_extensions.h"
#include "ardour/io.h"
+using namespace std;
+using namespace PBD;
+
namespace ARDOUR {
sys::path
#include "i18n.h"
+using namespace std;
using namespace PBD;
using namespace ARDOUR;
#define __pbd_gtk_ui_h__
#include <string>
-#include <queue>
#include <map>
#include <stdint.h>
#include <pbd/error.h>
#include <pbd/receiver.h>
-using std::string;
-using std::queue;
-
class Touchable;
namespace Gtkmm2ext {
class UI : public Receiver, public AbstractUI<UIRequest>
{
public:
- UI (string name, int *argc, char **argv[]);
+ UI (std::string name, int *argc, char **argv[]);
virtual ~UI ();
static UI *instance() { return theGtkUI; }
bool running ();
void quit ();
void kill ();
- int load_rcfile (string, bool themechange = false);
+ int load_rcfile (std::string, bool themechange = false);
void run (Receiver &old_receiver);
void set_state (Gtk::Widget *w, Gtk::StateType state);
Glib::signal_idle().connect (bind (slot (&UI::idle_delete<T>), obj));
}
- Gdk::Color get_color (const string& prompt, bool& picked, const Gdk::Color *initial = 0);
+ Gdk::Color get_color (const std::string& prompt, bool& picked, const Gdk::Color *initial = 0);
/* starting is sent just before we enter the main loop,
stopping just after we return from it (at the top level)
#include <pbd/transmitter.h>
-using std::string;
-
namespace Gtkmm2ext {
class TextViewer : public Gtk::Window, public Transmitter
Gtk::TextView& text() { return etext; }
Gtk::Button& dismiss_button() { return dismiss; }
- void insert_file (const string &);
+ void insert_file (const std::string &);
void scroll_to_bottom ();
void deliver ();
namespace Gtkmm2ext {
-using std::string;
-
/**
* \class The WindowTitle class can be used to maintain the
* consistancy of window titles between windows and dialogs.
* which will may be the application name or the document
* name in a document based application.
*/
- WindowTitle(const string& title);
+ WindowTitle(const std::string& title);
/**
* Add an string element to the window title.
*/
- void operator+= (const string&);
+ void operator+= (const std::string&);
/// @return The window title string.
- const string& get_string () { return m_title;}
+ const std::string& get_string () { return m_title;}
private:
- string m_title;
+ std::string m_title;
};
#include "i18n.h"
+using namespace std;
+
namespace {
// I don't know if this should be translated.
public:
Patch(PatchBank* a_bank = 0) : _bank(a_bank) {};
- Patch(string a_number, string a_name, PatchBank* a_bank = 0)
+ Patch(std::string a_number, std::string a_name, PatchBank* a_bank = 0)
: _number(a_number), _name(a_name), _bank(a_bank) {};
virtual ~Patch() {};
- const string& name() const { return _name; }
- void set_name(const string a_name) { _name = a_name; }
+ const std::string& name() const { return _name; }
+ void set_name(const std::string a_name) { _name = a_name; }
- const string& number() const { return _number; }
- void set_number(const string a_number) { _number = a_number; }
+ const std::string& number() const { return _number; }
+ void set_number(const std::string a_number) { _number = a_number; }
const PatchPrimaryKey& patch_primary_key() const { return _id; }
int set_state (const XMLNode& a_node);
private:
- string _number;
- string _name;
+ std::string _number;
+ std::string _name;
// cannot use a boost::shared_ptr here in order to avoid retain cycles
PatchBank* _bank;
PatchPrimaryKey _id;
public:
typedef std::list<boost::shared_ptr<Patch> > PatchNameList;
- PatchBank() : _id(0) {};
- PatchBank(string a_name, PatchPrimaryKey* an_id = 0) : _name(a_name), _id(an_id) {};
+ PatchBank () : _id(0) {};
+ PatchBank (std::string a_name, PatchPrimaryKey* an_id = 0) : _name(a_name), _id(an_id) {};
virtual ~PatchBank() { delete _id; };
- const string& name() const { return _name; }
- void set_name(const string a_name) { _name = a_name; }
+ const std::string& name() const { return _name; }
+ void set_name(const std::string a_name) { _name = a_name; }
const PatchNameList& patch_name_list() const { return _patch_name_list; }
int set_state (const XMLNode& a_node);
private:
- string _name;
+ std::string _name;
PatchNameList _patch_name_list;
PatchPrimaryKey* _id;
};
ChannelNameSet() {};
virtual ~ChannelNameSet() {};
- ChannelNameSet(string a_name) : _name(a_name) {};
+ ChannelNameSet(std::string a_name) : _name(a_name) {};
- const string& name() const { return _name; }
- void set_name(const string a_name) { _name = a_name; }
+ const std::string& name() const { return _name; }
+ void set_name(const std::string a_name) { _name = a_name; }
const PatchBanks& patch_banks() const { return _patch_banks; }
int set_state (const XMLNode& a_node);
private:
- string _name;
+ std::string _name;
AvailableForChannels _available_for_channels;
PatchBanks _patch_banks;
PatchMap _patch_map;
{
public:
Note() {};
- Note(string a_number, string a_name) : _number(a_number), _name(a_name) {};
+ Note(std::string a_number, std::string a_name) : _number(a_number), _name(a_name) {};
~Note() {};
- const string& name() const { return _name; }
- void set_name(const string a_name) { _name = a_name; }
+ const std::string& name() const { return _name; }
+ void set_name(const std::string a_name) { _name = a_name; }
- const string& number() const { return _number; }
- void set_number(const string a_number) { _number = a_number; }
+ const std::string& number() const { return _number; }
+ void set_number(const std::string a_number) { _number = a_number; }
XMLNode& get_state (void);
int set_state (const XMLNode& a_node);
private:
- string _number;
- string _name;
+ std::string _number;
+ std::string _name;
};
class NoteNameList : public PBD::Stateful
public:
typedef std::list<boost::shared_ptr<Note> > Notes;
NoteNameList() {};
- NoteNameList(string a_name) : _name(a_name) {};
+ NoteNameList (std::string a_name) : _name(a_name) {};
~NoteNameList() {};
- const string& name() const { return _name; }
- void set_name(const string a_name) { _name = a_name; }
+ const std::string& name() const { return _name; }
+ void set_name(const std::string a_name) { _name = a_name; }
const Notes& notes() const { return _notes; }
int set_state (const XMLNode& a_node);
private:
- string _name;
+ std::string _name;
Notes _notes;
};
CustomDeviceMode() {};
virtual ~CustomDeviceMode() {};
- const string& name() const { return _name; }
- void set_name(const string a_name) { _name = a_name; }
+ const std::string& name() const { return _name; }
+ void set_name(const std::string a_name) { _name = a_name; }
XMLNode& get_state (void);
int set_state (const XMLNode& a_node);
- string channel_name_set_name_by_channel(uint8_t channel) {
+ std::string channel_name_set_name_by_channel(uint8_t channel) {
assert(channel <= 15);
return _channel_name_set_assignments[channel];
}
private:
/// array index = channel number
/// string contents = name of channel name set
- string _name;
- string _channel_name_set_assignments[16];
+ std::string _name;
+ std::string _channel_name_set_assignments[16];
};
class MasterDeviceNames : public PBD::Stateful
MasterDeviceNames() {};
virtual ~MasterDeviceNames() {};
- const string& manufacturer() const { return _manufacturer; }
- void set_manufacturer(const string a_manufacturer) { _manufacturer = a_manufacturer; }
+ const std::string& manufacturer() const { return _manufacturer; }
+ void set_manufacturer(const std::string a_manufacturer) { _manufacturer = a_manufacturer; }
const Models& models() const { return _models; }
void set_models(const Models some_models) { _models = some_models; }
const CustomDeviceModeNames& custom_device_mode_names() const { return _custom_device_mode_names; }
- boost::shared_ptr<CustomDeviceMode> custom_device_mode_by_name(string mode_name) {
+ boost::shared_ptr<CustomDeviceMode> custom_device_mode_by_name(std::string mode_name) {
assert(mode_name != "");
return _custom_device_modes[mode_name];
}
- boost::shared_ptr<ChannelNameSet> channel_name_set_by_device_mode_and_channel(string mode, uint8_t channel) {
+ boost::shared_ptr<ChannelNameSet> channel_name_set_by_device_mode_and_channel(std::string mode, uint8_t channel) {
return _channel_name_sets[custom_device_mode_by_name(mode)->channel_name_set_name_by_channel(channel)];
}
- boost::shared_ptr<Patch> find_patch(string mode, uint8_t channel, PatchPrimaryKey& key) {
+ boost::shared_ptr<Patch> find_patch(std::string mode, uint8_t channel, PatchPrimaryKey& key) {
return channel_name_set_by_device_mode_and_channel(mode, channel)->find_patch(key);
}
int set_state (const XMLNode& a_node);
private:
- string _manufacturer;
+ std::string _manufacturer;
Models _models;
CustomDeviceModes _custom_device_modes;
CustomDeviceModeNames _custom_device_mode_names;
typedef std::map<std::string, boost::shared_ptr<MasterDeviceNames> > MasterDeviceNamesList;
MIDINameDocument() {};
- MIDINameDocument(const string &filename) : _document(XMLTree(filename)) { set_state(*_document.root()); };
+ MIDINameDocument(const std::string &filename) : _document(XMLTree(filename)) { set_state(*_document.root()); };
virtual ~MIDINameDocument() {};
- const string& author() const { return _author; }
- void set_author(const string an_author) { _author = an_author; }
+ const std::string& author() const { return _author; }
+ void set_author(const std::string an_author) { _author = an_author; }
const MasterDeviceNamesList& master_device_names_by_model() const { return _master_device_names_list; }
int set_state (const XMLNode& a_node);
private:
- string _author;
+ std::string _author;
MasterDeviceNamesList _master_device_names_list;
XMLTree _document;
MasterDeviceNames::Models _all_models;
#include "pbd/error.h"
+using namespace std;
+
namespace PBD {
void
#include "i18n.h"
+using namespace std;
+
namespace PBD {
namespace sys {
namespace PBD {
-vector<sys::path>
+std::vector<sys::path>
system_data_directories ()
{
- vector<sys::path> tmp;
+ std::vector<sys::path> tmp;
const char * const * dirs;
dirs = g_get_system_data_dirs ();
return tmp;
}
-vector<sys::path>
+std::vector<sys::path>
system_config_directories ()
{
- vector<sys::path> tmp;
+ std::vector<sys::path> tmp;
const char * const * dirs;
dirs = g_get_system_config_dirs ();
#include "pbd/pathscanner.h"
#include "pbd/stl_delete.h"
+using namespace std;
using namespace PBD;
vector<string *> *
namespace PBD {
-using std::string;
-using std::vector;
-
/**
* Get a list of files in a directory.
* @note You must join path with result to get the absolute path
*/
void
get_files_in_directory (const sys::path& path,
- vector<string>& result);
+ std::vector<std::string>& result);
/**
* Takes a directory path and returns all the files in the directory
void
find_matching_files_in_directory (const sys::path& directory,
const Glib::PatternSpec& pattern,
- vector<sys::path>& result);
+ std::vector<sys::path>& result);
/**
* Takes a number of directory paths and returns all the files matching
* @param result A vector in which to place the resulting matches.
*/
void
-find_matching_files_in_directories (const vector<sys::path>& directory_paths,
+find_matching_files_in_directories (const std::vector<sys::path>& directory_paths,
const Glib::PatternSpec& pattern,
- vector<sys::path>& result);
+ std::vector<sys::path>& result);
/**
* Takes a SearchPath and puts a list of all the files in the search path
void
find_matching_files_in_search_path (const SearchPath& search_path,
const Glib::PatternSpec& pattern,
- vector<sys::path>& result);
+ std::vector<sys::path>& result);
/**
* Takes a search path and a file name and place the full path
*/
bool
find_file_in_search_path (const SearchPath& search_path,
- const string& filename,
+ const std::string& filename,
sys::path& result);
} // namespace PBD
namespace sys {
-using std::string;
-
class path
{
public:
path() : m_path("") { }
path(const path & p) : m_path(p.m_path) { }
- path(const string & s) : m_path(s) { }
+ path(const std::string & s) : m_path(s) { }
path(const char* s) : m_path(s) { }
path& operator=(const path& p) { m_path = p.m_path; return *this;}
- path& operator=(const string& s) { m_path = s; return *this; }
+ path& operator=(const std::string& s) { m_path = s; return *this; }
path& operator=(const char* s) { m_path = s; return *this; }
path& operator/=(const path& rhs);
- path& operator/=(const string& s);
+ path& operator/=(const std::string& s);
path& operator/=(const char* s);
- const string to_string() const { return m_path; }
+ const std::string to_string() const { return m_path; }
/**
* @return the last component of the path, if the path refers to
* a file then it will be the entire filename including any extension.
*/
- string leaf() const;
+ std::string leaf () const;
/**
* @returns the directory component of a path without any trailing
private:
- string m_path;
+ std::string m_path;
};
class filesystem_error : public std::runtime_error
* ::basename and most other forms of basename in that it removes the
* extension from the filename if the filename has one.
*/
-string basename (const path& p);
+std::string basename (const path& p);
/**
* @return If the filename contains a dot, return a substring of the
*
* @param p a file path.
*/
-string extension (const path& p);
+std::string extension (const path& p);
} // namespace sys
namespace PBD {
- using std::vector;
+ std::vector<sys::path> system_data_directories ();
- vector<sys::path> system_data_directories ();
-
- vector<sys::path> system_config_directories ();
+ std::vector<sys::path> system_config_directories ();
} // namespace PBD
}
virtual XMLNode &get_state() {
- string name;
+ std::string name;
if (before && after) {
name = "MementoCommand";
} else if (before) {
#include <string>
#include <regex.h>
-using std::string;
-using std::vector;
-
class PathScanner
{
public:
- vector<string *> *operator() (const string &dirpath,
- bool (*filter)(const string &, void *arg),
- void *arg,
- bool match_fullpath = true,
- bool return_fullpath = true,
- long limit = -1,
- bool recurse = false) {
+ std::vector<std::string *> *operator() (const std::string &dirpath,
+ bool (*filter)(const std::string &, void *arg),
+ void *arg,
+ bool match_fullpath = true,
+ bool return_fullpath = true,
+ long limit = -1,
+ bool recurse = false) {
return run_scan (dirpath,
- (bool (PathScanner::*)(const string &)) 0,
+ (bool (PathScanner::*)(const std::string &)) 0,
filter,
arg,
match_fullpath,
limit, recurse);
}
- vector<string *> *operator() (const string &dirpath,
- const string ®exp,
- bool match_fullpath = true,
- bool return_fullpath = true,
- long limit = -1,
- bool recurse = false);
-
- string *find_first (const string &dirpath,
- const string ®exp,
- bool match_fullpath = true,
- bool return_fullpath = true);
+ std::vector<std::string *> *operator() (const std::string &dirpath,
+ const std::string ®exp,
+ bool match_fullpath = true,
+ bool return_fullpath = true,
+ long limit = -1,
+ bool recurse = false);
+
+ std::string *find_first (const std::string &dirpath,
+ const std::string ®exp,
+ bool match_fullpath = true,
+ bool return_fullpath = true);
- string *find_first (const string &dirpath,
- bool (*filter)(const string &, void *),
- void *arg,
- bool match_fullpath = true,
- bool return_fullpath = true);
+ std::string *find_first (const std::string &dirpath,
+ bool (*filter)(const std::string &, void *),
+ void *arg,
+ bool match_fullpath = true,
+ bool return_fullpath = true);
private:
regex_t compiled_pattern;
- bool regexp_filter (const string &str) {
+ bool regexp_filter (const std::string &str) {
return regexec (&compiled_pattern, str.c_str(), 0, 0, 0) == 0;
}
- vector<string *> *run_scan (const string &dirpath,
- bool (PathScanner::*mfilter) (const string &),
- bool (*filter)(const string &, void *),
- void *arg,
- bool match_fullpath,
- bool return_fullpath,
- long limit,
- bool recurse = false);
+ std::vector<std::string *> *run_scan (const std::string &dirpath,
+ bool (PathScanner::*mfilter) (const std::string &),
+ bool (*filter)(const std::string &, void *),
+ void *arg,
+ bool match_fullpath,
+ bool return_fullpath,
+ long limit,
+ bool recurse = false);
- vector<string *> *run_scan_internal (vector<string*>*,
- const string &dirpath,
- bool (PathScanner::*mfilter) (const string &),
- bool (*filter)(const string &, void *),
- void *arg,
- bool match_fullpath,
- bool return_fullpath,
- long limit,
- bool recurse = false);
+ std::vector<std::string *> *run_scan_internal (std::vector<std::string*>*,
+ const std::string &dirpath,
+ bool (PathScanner::*mfilter) (const std::string &),
+ bool (*filter)(const std::string &, void *),
+ void *arg,
+ bool match_fullpath,
+ bool return_fullpath,
+ long limit,
+ bool recurse = false);
};
#endif // __libmisc_pathscanner_h__
#include "transmitter.h"
-using std::vector;
-
class strstream;
class Receiver : virtual public sigc::trackable
virtual void receive (Transmitter::Channel, const char *) = 0;
private:
- vector<sigc::connection *> connections;
+ std::vector<sigc::connection *> connections;
};
#endif // __libmisc_receiver_h__
namespace PBD {
-using std::string;
-using std::vector;
-
/**
* @class The SearchPath class is a helper class for getting a
* vector of paths contained in a search path string where a
* The SearchPath class does not test whether the paths exist
* or are directories. It is basically just a container.
*/
-class SearchPath : public vector<sys::path>
+class SearchPath : public std::vector<sys::path>
{
public:
/**
*
* @param search_path A path string.
*/
- SearchPath (const string& search_path);
+ SearchPath (const std::string& search_path);
/**
* Initialize SearchPath from a sys::path.
*
* @param directory_path A directory path.
*/
- SearchPath (const sys::path& directory_path);
+ SearchPath (const PBD::sys::path& directory_path);
/**
* Initialize SearchPath from a vector of paths that may or may
*
* @param path A path.
*/
- SearchPath (const vector<sys::path>& paths);
+ SearchPath (const std::vector<PBD::sys::path>& paths);
/**
* @return a search path string.
* The string that is returned contains the platform specific
* path separator.
*/
- const string to_string () const;
+ const std::string to_string () const;
/**
* Add all the directories in path to this.
/**
* Add another directory path to the search path.
*/
- SearchPath& operator+= (const sys::path& directory_path);
+ SearchPath& operator+= (const PBD::sys::path& directory_path);
/**
* Concatenate another SearchPath onto this.
/**
* Add another path to the search path.
*/
- SearchPath& operator+ (const sys::path& directory_path);
+ SearchPath& operator+ (const PBD::sys::path& directory_path);
/**
* Add a sub-directory to each path in the search path.
* @param subdir The directory name, it should not contain
* any path separating tokens.
*/
- SearchPath& add_subdirectory_to_paths (const string& subdir);
+ SearchPath& add_subdirectory_to_paths (const std::string& subdir);
protected:
void add_directory (const sys::path& directory_path);
- void add_directories (const vector<sys::path>& paths);
+ void add_directories (const std::vector<PBD::sys::path>& paths);
};
} // namespace PBD
#include "receiver.h"
-using std::string;
-using std::cout;
-using std::endl;
-
class TextReceiver : public Receiver
{
public:
- TextReceiver (const string &n);
+ TextReceiver (const std::string &n);
protected:
void receive (Transmitter::Channel, const char *);
private:
- string name;
+ std::string name;
};
#endif //__libmisc_textreceiver_h__
#include <sigc++/sigc++.h>
-using std::cout;
-using std::cerr;
-using std::endl;
-
class Transmitter : public std::stringstream
{
see if ostr == cout, and handle it specially.
*/
- if (&ostr == &cout) {
- cout << endl;
+ if (&ostr == &std::cout) {
+ std::cout << std::endl;
return ostr;
- } else if (&ostr == &cerr) {
- cerr << endl;
+ } else if (&ostr == &std::cerr) {
+ std::cerr << std::endl;
return ostr;
}
it and assume that that will be enough.
*/
- ostr << endl;
+ ostr << std::endl;
}
return ostr;
#ifndef __XML_H
#define __XML_H
-using std::string;
-using std::map;
-using std::list;
-
class XMLTree;
class XMLNode;
class XMLProperty;
-typedef list<XMLNode *> XMLNodeList;
-typedef list<boost::shared_ptr<XMLNode> > XMLSharedNodeList;
-typedef XMLNodeList::iterator XMLNodeIterator;
-typedef XMLNodeList::const_iterator XMLNodeConstIterator;
-typedef list<XMLProperty*> XMLPropertyList;
-typedef XMLPropertyList::iterator XMLPropertyIterator;
-typedef XMLPropertyList::const_iterator XMLPropertyConstIterator;
-typedef map<string, XMLProperty*> XMLPropertyMap;
+typedef std::list<XMLNode *> XMLNodeList;
+typedef std::list<boost::shared_ptr<XMLNode> > XMLSharedNodeList;
+typedef XMLNodeList::iterator XMLNodeIterator;
+typedef XMLNodeList::const_iterator XMLNodeConstIterator;
+typedef std::list<XMLProperty*> XMLPropertyList;
+typedef XMLPropertyList::iterator XMLPropertyIterator;
+typedef XMLPropertyList::const_iterator XMLPropertyConstIterator;
+typedef std::map<std::string, XMLProperty*> XMLPropertyMap;
class XMLTree {
public:
XMLTree();
- XMLTree(const string& fn, bool validate = false);
+ XMLTree(const std::string& fn, bool validate = false);
XMLTree(const XMLTree*);
~XMLTree();
XMLNode* root() const { return _root; }
XMLNode* set_root(XMLNode* n) { return _root = n; }
- const string& filename() const { return _filename; }
- const string& set_filename(const string& fn) { return _filename = fn; }
+ const std::string& filename() const { return _filename; }
+ const std::string& set_filename(const std::string& fn) { return _filename = fn; }
int compression() const { return _compression; }
int set_compression(int);
bool read() { return read_internal(false); }
- bool read(const string& fn) { set_filename(fn); return read_internal(false); }
+ bool read(const std::string& fn) { set_filename(fn); return read_internal(false); }
bool read_and_validate() { return read_internal(true); }
- bool read_and_validate(const string& fn) { set_filename(fn); return read_internal(true); }
- bool read_buffer(const string&);
+ bool read_and_validate(const std::string& fn) { set_filename(fn); return read_internal(true); }
+ bool read_buffer(const std::string&);
bool write() const;
- bool write(const string& fn) { set_filename(fn); return write(); }
+ bool write(const std::string& fn) { set_filename(fn); return write(); }
void debug (FILE*) const;
- const string& write_buffer() const;
+ const std::string& write_buffer() const;
private:
bool read_internal(bool validate);
- string _filename;
- XMLNode* _root;
- int _compression;
+ std::string _filename;
+ XMLNode* _root;
+ int _compression;
};
class XMLNode {
public:
- XMLNode(const string& name);
- XMLNode(const string& name, const string& content);
+ XMLNode(const std::string& name);
+ XMLNode(const std::string& name, const std::string& content);
XMLNode(const XMLNode& other);
~XMLNode();
- const string& name() const { return _name; }
+ const std::string& name() const { return _name; }
bool is_content() const { return _is_content; }
- const string& content() const { return _content; }
- const string& set_content(const string&);
- XMLNode* add_content(const string& s = string());
+ const std::string& content() const { return _content; }
+ const std::string& set_content(const std::string&);
+ XMLNode* add_content(const std::string& s = std::string());
- const XMLNodeList& children(const string& str = string()) const;
+ const XMLNodeList& children(const std::string& str = std::string()) const;
XMLNode* child(const char*) const;
XMLNode* add_child(const char *);
XMLNode* add_child_copy(const XMLNode&);
const XMLPropertyList& properties() const { return _proplist; }
XMLProperty* property(const char*);
- XMLProperty* property(const string&);
+ XMLProperty* property(const std::string&);
const XMLProperty* property(const char* n) const { return ((XMLNode*)this)->property(n); }
- const XMLProperty* property(const string& n) const { return ((XMLNode*)this)->property(n); }
+ const XMLProperty* property(const std::string& n) const { return ((XMLNode*)this)->property(n); }
- XMLProperty* add_property(const char* name, const string& value);
+ XMLProperty* add_property(const char* name, const std::string& value);
XMLProperty* add_property(const char* name, const char* value = "");
XMLProperty* add_property(const char* name, const long value);
- void remove_property(const string&);
+ void remove_property(const std::string&);
/** Remove all nodes with the name passed to remove_nodes */
- void remove_nodes(const string&);
+ void remove_nodes(const std::string&);
/** Remove and delete all nodes with the name passed to remove_nodes */
- void remove_nodes_and_delete(const string&);
+ void remove_nodes_and_delete(const std::string&);
/** Remove and delete all nodes with property prop matching val */
- void remove_nodes_and_delete(const string& propname, const string& val);
+ void remove_nodes_and_delete(const std::string& propname, const std::string& val);
private:
- string _name;
+ std::string _name;
bool _is_content;
- string _content;
+ std::string _content;
XMLNodeList _children;
XMLPropertyList _proplist;
XMLPropertyMap _propmap;
class XMLProperty {
public:
- XMLProperty(const string& n, const string& v = string());
+ XMLProperty(const std::string& n, const std::string& v = std::string());
~XMLProperty();
- const string& name() const { return _name; }
- const string& value() const { return _value; }
- const string& set_value(const string& v) { return _value = v; }
+ const std::string& name() const { return _name; }
+ const std::string& value() const { return _value; }
+ const std::string& set_value(const std::string& v) { return _value = v; }
private:
- string _name;
- string _value;
+ std::string _name;
+ std::string _value;
};
class XMLException: public std::exception {
public:
- explicit XMLException(const string msg) : _message(msg) {}
+ explicit XMLException(const std::string msg) : _message(msg) {}
virtual ~XMLException() throw() {}
virtual const char* what() const throw() { return _message.c_str(); }
private:
- string _message;
+ std::string _message;
};
#endif /* __XML_H */
#include "pbd/receiver.h"
#include "pbd/transmitter.h"
+using namespace std;
using namespace sigc;
Receiver::Receiver () {}
#include "pbd/search_path.h"
#include "pbd/error.h"
+using namespace std;
+
namespace {
#ifdef WIN32
#include "i18n.h"
+using namespace std;
+
namespace PBD {
Stateful::Stateful ()
#include "pbd/textreceiver.h"
+using namespace std;
+
TextReceiver::TextReceiver (const string &n)
{
#define XML_VERSION "1.0"
+using namespace std;
+
static XMLNode* readnode(xmlNodePtr);
static void writenode(xmlDocPtr, XMLNode*, xmlNodePtr, int);
static XMLSharedNodeList* find_impl(xmlXPathContext* ctxt, const string& xpath);
projects / ardour.git / commitdiff