}
int
-ARDOUR_UI::ask_about_saving_session (string what)
+ARDOUR_UI::ask_about_saving_session (stringcr_t what)
{
ArdourDialog window (_("ardour: save session?"));
Gtk::Label prompt_label;
}
void
-ARDOUR_UI::save_state (string name)
+ARDOUR_UI::save_state (stringcr_t name)
{
(void) save_state_canfail (name);
}
}
int
-ARDOUR_UI::load_session (string path, string snap_name, string* mix_template)
+ARDOUR_UI::load_session (stringcr_t path, stringcr_t snap_name, string* mix_template)
{
Session *new_session;
int x;
}
int
-ARDOUR_UI::build_session (string path, string snap_name,
+ARDOUR_UI::build_session (stringcr_t path, stringcr_t snap_name,
uint32_t control_channels,
uint32_t master_channels,
Session::AutoConnectOption input_connect,
}
void
-ARDOUR_UI::display_cleanup_results (Session::cleanup_report& rep, const gchar* list_title, string msg)
+ARDOUR_UI::display_cleanup_results (Session::cleanup_report& rep, const gchar* list_title, stringcr_t msg)
{
size_t removed;
void show_splash ();
void hide_splash ();
- int load_session (string path, string snapshot, string* mix_template = 0);
+ int load_session (ARDOUR::stringcr_t path, ARDOUR::stringcr_t snapshot, string* mix_template = 0);
bool session_loaded;
- int build_session (string path, string snapshot,
+ int build_session (ARDOUR::stringcr_t path, ARDOUR::stringcr_t snapshot,
uint32_t ctl_chns,
uint32_t master_chns,
ARDOUR::Session::AutoConnectOption input_connect,
}
void new_session(bool startup = false, std::string path = string());
- gint cmdline_new_session (std::string path);
+ gint cmdline_new_session (string path);
int unload_session ();
void close_session() { unload_session(); }
int save_state_canfail (string state_name = "");
- void save_state (string state_name = "");
+ void save_state (ARDOUR::stringcr_t state_name = "");
void restore_state (string state_name = "");
static double gain_to_slider_position (ARDOUR::gain_t g);
void shutdown ();
void finish();
- int ask_about_saving_session (string why);
+ int ask_about_saving_session (ARDOUR::stringcr_t why);
gint ask_about_save_deleted (GdkEventAny*);
void save_session_choice_made (int);
int save_the_session;
Gtk::MenuItem *cleanup_item;
- void display_cleanup_results (ARDOUR::Session::cleanup_report& rep, const gchar* list_title, string msg);
+ void display_cleanup_results (ARDOUR::Session::cleanup_report& rep, const gchar* list_title, ARDOUR::stringcr_t msg);
void cleanup ();
void flush_trash ();
{
if (option_editor == 0) {
option_editor = new OptionEditor (*this, *editor, *mixer);
- option_editor->signal_unmap().connect(sigc::bind (ptr_fun(&ActionManager::uncheck_toggleaction), X_("<Actions>/Common/ToggleOptionsEditor")));
+ option_editor->signal_unmap().connect(sigc::bind (sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("<Actions>/Common/ToggleOptionsEditor")));
option_editor->set_session (session);
}
if (location_ui == 0) {
location_ui = new LocationUI ();
location_ui->set_session (session);
- location_ui->signal_unmap().connect (sigc::bind (ptr_fun(&ActionManager::uncheck_toggleaction), X_("<Actions>/Common/ToggleLocations")));
+ location_ui->signal_unmap().connect (sigc::bind (sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("<Actions>/Common/ToggleLocations")));
}
return 0;
}
if (route_params == 0) {
route_params = new RouteParams_UI (*engine);
route_params->set_session (session);
- route_params->signal_unmap().connect (sigc::bind(ptr_fun(&ActionManager::uncheck_toggleaction), X_("<Actions>/Common/ToggleInspector")));
+ route_params->signal_unmap().connect (sigc::bind(sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("<Actions>/Common/ToggleInspector")));
}
return 0;
}
if (sfdb == 0) {
sfdb = new SoundFileBrowser (_("Sound File Browser"));
sfdb->set_session (session);
- sfdb->signal_unmap().connect (sigc::bind(ptr_fun(&ActionManager::uncheck_toggleaction), X_("<Actions>/Common/ToggleSoundFileBrowser")));
+ sfdb->signal_unmap().connect (sigc::bind(sigc::ptr_fun(&ActionManager::uncheck_toggleaction), X_("<Actions>/Common/ToggleSoundFileBrowser")));
}
return 0;
}
}
XMLNode*
-AudioTimeAxisView::get_child_xml_node (std::string childname)
+AudioTimeAxisView::get_child_xml_node (stringcr_t childname)
{
return RouteUI::get_child_xml_node (childname);
}
list<TimeAxisView*>get_child_list();
void set_state (const XMLNode&);
- XMLNode* get_child_xml_node (std::string childname);
+ XMLNode* get_child_xml_node (ARDOUR::stringcr_t childname);
private:
friend class StreamView;
using namespace std;
using namespace ARDOUR;
-AutomationGainLine::AutomationGainLine (string name, Session& s, TimeAxisView& tv, ArdourCanvas::Group& parent, Curve& c)
+AutomationGainLine::AutomationGainLine (stringcr_t name, Session& s, TimeAxisView& tv, ArdourCanvas::Group& parent, Curve& c)
: AutomationLine (name, tv, parent, c),
session (s)
class AutomationGainLine : public AutomationLine
{
public:
- AutomationGainLine (string name, ARDOUR::Session&, TimeAxisView&, ArdourCanvas::Group& parent, ARDOUR::Curve&);
+ AutomationGainLine (ARDOUR::stringcr_t name, ARDOUR::Session&, TimeAxisView&, ArdourCanvas::Group& parent, ARDOUR::Curve&);
void view_to_model_y (double&);
void model_to_view_y (double&);
/*****/
-AutomationLine::AutomationLine (string name, TimeAxisView& tv, ArdourCanvas::Group& parent, AutomationList& al)
+AutomationLine::AutomationLine (stringcr_t name, TimeAxisView& tv, ArdourCanvas::Group& parent, AutomationList& al)
: trackview (tv),
_name (name),
alist (al),
class AutomationLine : public sigc::trackable
{
public:
- AutomationLine (string name, TimeAxisView&, ArdourCanvas::Group&, ARDOUR::AutomationList&);
+ AutomationLine (ARDOUR::stringcr_t name, TimeAxisView&, ArdourCanvas::Group&, ARDOUR::AutomationList&);
virtual ~AutomationLine ();
void queue_reset ();
using namespace ARDOUR;
-AutomationPanLine::AutomationPanLine (string name, Session& s, TimeAxisView& tv, ArdourCanvas::Group& parent, Curve& c)
+AutomationPanLine::AutomationPanLine (stringcr_t name, Session& s, TimeAxisView& tv, ArdourCanvas::Group& parent, Curve& c)
: AutomationLine (name, tv, parent, c),
session (s)
class AutomationPanLine : public AutomationLine
{
public:
- AutomationPanLine (string name, ARDOUR::Session&, TimeAxisView&, ArdourCanvas::Group& parent, ARDOUR::Curve&);
+ AutomationPanLine (ARDOUR::stringcr_t name, ARDOUR::Session&, TimeAxisView&, ArdourCanvas::Group& parent, ARDOUR::Curve&);
void view_to_model_y (double&);
void model_to_view_y (double&);
" "};
AutomationTimeAxisView::AutomationTimeAxisView (Session& s, Route& r, PublicEditor& e, TimeAxisView& rent,
- ArdourCanvas::Canvas& canvas, std::string nom,
- std::string state_name, std::string nomparent)
+ ArdourCanvas::Canvas& canvas, stringcr_t nom,
+ stringcr_t state_name, stringcr_t nomparent)
: AxisView (s),
TimeAxisView (s, e, &rent, canvas),
PublicEditor&,
TimeAxisView& parent,
ArdourCanvas::Canvas& canvas,
- std::string name, /* translatable */
- std::string state_name, /* not translatable */
- std::string plug_name = "");
+ ARDOUR::stringcr_t name, /* translatable */
+ ARDOUR::stringcr_t state_name, /* not translatable */
+ ARDOUR::stringcr_t plug_name = "");
~AutomationTimeAxisView();
#undef SNAPTYPE
#define SNAPTYPE(s) if (!strcmp(type, #s)) {return s;}
SnapType
-str2snaptype (string str) {
+str2snaptype (ARDOUR::stringcr_t str) {
const char* type = str.c_str();
#include "editing_syms.h"
return SnapToBar;
#undef SNAPMODE
#define SNAPMODE(s) if (!strcmp(type, #s)) {return s;}
SnapMode
-str2snapmode (string str) {
+str2snapmode (ARDOUR::stringcr_t str) {
const char* type = str.c_str();
#include "editing_syms.h"
return SnapNormal;
#undef REGIONLISTSORTTYPE
#define REGIONLISTSORTTYPE(s) if (!strcmp(type, #s)) {return s;}
RegionListSortType
-str2regionlistsorttype (string str) {
+str2regionlistsorttype (ARDOUR::stringcr_t str) {
const char* type = str.c_str();
#include "editing_syms.h"
return ByName;
#undef MOUSEMODE
#define MOUSEMODE(s) if (!strcmp(type, #s)) {return s;}
MouseMode
-str2mousemode (string str) {
+str2mousemode (ARDOUR::stringcr_t str) {
const char* type = str.c_str();
#include "editing_syms.h"
return MouseObject;
#undef ZOOMFOCUS
#define ZOOMFOCUS(s) if (!strcmp(type, #s)) {return s;}
ZoomFocus
-str2zoomfocus (string str) {
+str2zoomfocus (ARDOUR::stringcr_t str) {
const char* type = str.c_str();
#include "editing_syms.h"
return ZoomFocusPlayhead;
#undef DISPLAYCONTROL
#define DISPLAYCONTROL(s) if (!strcmp(type, #s)) {return s;}
DisplayControl
-str2displaycontrol (string str) {
+str2displaycontrol (ARDOUR::stringcr_t str) {
const char* type = str.c_str();
#include "editing_syms.h"
return FollowPlayhead;
#undef COLORID
#define COLORID(s) if (!strcmp(type, #s)) {return s;}
ColorID
-str2color_id (string str) {
+str2color_id (ARDOUR::stringcr_t str) {
const char* type = str.c_str();
#include "editing_syms.h"
return cFrameHandleEndOutline;
#include <string>
#include <map>
+#include <ardour/types.h>
// This involves some cpp magic. --taybin
#include "editing_syms.h"
};
inline const char* enum2str(SnapType m) {return snaptypestrs[m];}
-SnapType str2snaptype(std::string);
+SnapType str2snaptype(ARDOUR::stringcr_t);
#undef SNAPTYPE
#define SNAPTYPE(a) /*empty*/
#include "editing_syms.h"
};
inline const char* enum2str(SnapMode m) {return snapmodestrs[m];}
-SnapMode str2snapmode(std::string);
+SnapMode str2snapmode(ARDOUR::stringcr_t);
#undef SNAPMODE
#define SNAPMODE(a) /*empty*/
#include "editing_syms.h"
};
inline const char* enum2str(RegionListSortType m) {return regionlistsorttypestrs[m];}
-RegionListSortType str2regionlistsorttype(std::string);
+RegionListSortType str2regionlistsorttype(ARDOUR::stringcr_t);
#undef REGIONLISTSORTTYPE
#define REGIONLISTSORTTYPE(a) /*empty*/
#include "editing_syms.h"
};
inline const char* enum2str(MouseMode m) {return mousemodestrs[m];}
-MouseMode str2mousemode(std::string);
+MouseMode str2mousemode(ARDOUR::stringcr_t);
#undef MOUSEMODE
#define MOUSEMODE(a) /*empty*/
#include "editing_syms.h"
};
inline const char* enum2str(ZoomFocus m) {return zoomfocusstrs[m];}
-ZoomFocus str2zoomfocus(std::string);
+ZoomFocus str2zoomfocus(ARDOUR::stringcr_t);
#undef ZOOMFOCUS
#define ZOOMFOCUS(a) /*empty*/
#include "editing_syms.h"
};
inline const char* enum2str(DisplayControl m) {return displaycontrolstrs[m];}
-DisplayControl str2displaycontrol (std::string);
+DisplayControl str2displaycontrol (ARDOUR::stringcr_t);
#undef DISPLAYCONTROL
#define DISPLAYCONTROL(a) /*empty*/
#include "editing_syms.h"
};
inline const char* enum2str(ColorID m) {return color_id_strs[m];}
-ColorID str2color_id (std::string);
+ColorID str2color_id (ARDOUR::stringcr_t);
#undef COLORID
#define COLORID(a) /*empty*/
}
void
-Editor::update_title_s (string snap_name)
+Editor::update_title_s (stringcr_t snap_name)
{
ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::update_title_s), snap_name));
}
void
-Editor::set_verbose_canvas_cursor (string txt, double x, double y)
+Editor::set_verbose_canvas_cursor (stringcr_t txt, double x, double y)
{
/* XXX get origin of canvas relative to root window,
add x and y and check compared to gdk_screen_{width,height}
}
void
-Editor::set_verbose_canvas_cursor_text (string txt)
+Editor::set_verbose_canvas_cursor_text (stringcr_t txt)
{
verbose_canvas_cursor->property_text() = txt.c_str();
}
void step_mouse_mode (bool next);
Editing::MouseMode current_mouse_mode () { return mouse_mode; }
- void add_imageframe_time_axis(std::string track_name, void*) ;
- void add_imageframe_marker_time_axis(std::string track_name, TimeAxisView* marked_track, void*) ;
+ void add_imageframe_time_axis(ARDOUR::stringcr_t track_name, void*) ;
+ void add_imageframe_marker_time_axis(ARDOUR::stringcr_t track_name, TimeAxisView* marked_track, void*) ;
void connect_to_image_compositor() ;
void scroll_timeaxis_to_imageframe_item(const TimeAxisViewItem* item) ;
- TimeAxisView* get_named_time_axis(std::string name) ;
+ TimeAxisView* get_named_time_axis(ARDOUR::stringcr_t name) ;
/* </CMT Additions> */
void consider_auditioning (ARDOUR::Region&);
bool track_canvas_motion (GdkEvent*);
- void set_verbose_canvas_cursor (string, double x, double y);
- void set_verbose_canvas_cursor_text (string);
+ void set_verbose_canvas_cursor (ARDOUR::stringcr_t, double x, double y);
+ void set_verbose_canvas_cursor_text (ARDOUR::stringcr_t);
void show_verbose_canvas_cursor();
void hide_verbose_canvas_cursor();
void name_selection();
void named_selection_name_chosen ();
- void create_named_selection (string);
+ void create_named_selection (ARDOUR::stringcr_t);
void paste_named_selection (float times);
void handle_new_named_selection ();
void temporal_zoom_selection ();
void temporal_zoom_session ();
void temporal_zoom (gdouble scale);
- void temporal_zoom_by_frame (jack_nframes_t start, jack_nframes_t end, string op);
+ void temporal_zoom_by_frame (jack_nframes_t start, jack_nframes_t end, ARDOUR::stringcr_t op);
void temporal_zoom_to_frame (bool coarser, jack_nframes_t frame);
void amplitude_zoom (gdouble scale);
void insert_sndfile (bool as_tracks);
void embed_audio (); // inserts into region list
- int reject_because_rate_differs (string path, SF_INFO& finfo, string action, bool multiple_pending);
+ int reject_because_rate_differs (ARDOUR::stringcr_t path, SF_INFO& finfo, ARDOUR::stringcr_t action, bool multiple_pending);
void do_embed_sndfiles (vector<string> paths, bool split);
void embed_sndfile (string path, bool split, bool multiple_files, bool& check_sr);
void do_insert_sndfile (vector<string> path, bool multi, jack_nframes_t frame);
void insert_paths_as_new_tracks (std::vector<std::string> paths, bool multi); // inserts files as new tracks
- void insert_sndfile_into (string path, bool multi, AudioTimeAxisView* tv, jack_nframes_t& frame, bool prompt=true);
+ void insert_sndfile_into (ARDOUR::stringcr_t path, bool multi, AudioTimeAxisView* tv, jack_nframes_t& frame, bool prompt=true);
static void* _insert_sndfile_thread (void*);
void* insert_sndfile_thread (void*);
Editing::SnapMode snap_mode;
double snap_threshold;
- void soundfile_chosen_for_insert (string selection, bool split_channels);
- void soundfile_chosen_for_embed (string selection, bool split_channels);
- void soundfile_chosen_for_import (string selection, bool split_channels);
+ void soundfile_chosen_for_insert (ARDOUR::stringcr_t selection, bool split_channels);
+ void soundfile_chosen_for_embed (ARDOUR::stringcr_t selection, bool split_channels);
+ void soundfile_chosen_for_import (ARDOUR::stringcr_t selection, bool split_channels);
- void handle_gui_changes (string, void *);
+ void handle_gui_changes (ARDOUR::stringcr_t, void *);
void hide_all_tracks (bool with_select);
UndoHistory visual_history;
UndoCommand current_visual_command;
- void begin_reversible_visual_command (string cmd_name);
+ void begin_reversible_visual_command (ARDOUR::stringcr_t cmd_name);
void commit_reversible_visual_command ();
void update_title ();
- void update_title_s (string snapshot_name);
+ void update_title_s (ARDOUR::stringcr_t snapshot_name);
struct State {
Selection* selection;
bool _xfade_visibility;
/* <CMT Additions> */
- void handle_new_imageframe_time_axis_view(std::string track_name, void* src) ;
- void handle_new_imageframe_marker_time_axis_view(std::string track_name, TimeAxisView* marked_track) ;
+ void handle_new_imageframe_time_axis_view(ARDOUR::stringcr_t track_name, void* src) ;
+ void handle_new_imageframe_marker_time_axis_view(ARDOUR::stringcr_t track_name, TimeAxisView* marked_track) ;
void start_imageframe_grab(ArdourCanvas::Item*, GdkEvent*) ;
void start_markerview_grab(ArdourCanvas::Item*, GdkEvent*) ;
/* <CMT Additions file="editor.cc"> */
void
-Editor::add_imageframe_time_axis(std::string track_name, void* src)
+Editor::add_imageframe_time_axis(ARDOUR::stringcr_t track_name, void* src)
{
// check for duplicate name
if(get_named_time_axis(track_name))
}
void
-Editor::add_imageframe_marker_time_axis(std::string track_name, TimeAxisView* marked_track, void* src)
+Editor::add_imageframe_marker_time_axis(ARDOUR::stringcr_t track_name, TimeAxisView* marked_track, void* src)
{
// Can we only bind 2 data Items?
// @todo we really want to bind the src attribute too, for the moment tracks can only be added remotely,
}
TimeAxisView*
-Editor::get_named_time_axis(std::string name)
+Editor::get_named_time_axis(ARDOUR::stringcr_t name)
{
TimeAxisView* tav = 0 ;
- for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i)
+ for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i)
{
if (((TimeAxisView*)*i)->name() == name)
{
/* <CMT Additions file="editor_route_list.cc"> */
void
-Editor::handle_new_imageframe_time_axis_view(std::string track_name, void* src)
+Editor::handle_new_imageframe_time_axis_view(ARDOUR::stringcr_t track_name, void* src)
{
ImageFrameTimeAxis* iftav ;
iftav = new ImageFrameTimeAxis(track_name, *this, *session, track_canvas) ;
}
void
-Editor::handle_new_imageframe_marker_time_axis_view(std::string track_name, TimeAxisView* marked_track)
+Editor::handle_new_imageframe_marker_time_axis_view(ARDOUR::stringcr_t track_name, TimeAxisView* marked_track)
{
MarkerTimeAxis* mta = new MarkerTimeAxis (*this, *this->current_session(), track_canvas, track_name, marked_track) ;
((ImageFrameTimeAxis*)marked_track)->add_marker_time_axis(mta, this) ;
}
void
-Editor::temporal_zoom_by_frame (jack_nframes_t start, jack_nframes_t end, string op)
+Editor::temporal_zoom_by_frame (jack_nframes_t start, jack_nframes_t end, stringcr_t op)
{
if (!session) return;
}
int
-Editor::reject_because_rate_differs (string path, SF_INFO& finfo, string action, bool multiple_pending)
+Editor::reject_because_rate_differs (stringcr_t path, SF_INFO& finfo, stringcr_t action, bool multiple_pending)
{
if (!session) {
return 1;
}
void
-Editor::insert_sndfile_into (string path, bool multi, AudioTimeAxisView* tv, jack_nframes_t& pos, bool prompt)
+Editor::insert_sndfile_into (stringcr_t path, bool multi, AudioTimeAxisView* tv, jack_nframes_t& pos, bool prompt)
{
SndFileSource *source = 0; /* keep g++ quiet */
AudioRegion::SourceList sources;
}
void
-Editor::handle_gui_changes (string what, void *src)
+Editor::handle_gui_changes (stringcr_t what, void *src)
{
ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::handle_gui_changes), what, src));
}
void
-Editor::create_named_selection (string name)
+Editor::create_named_selection (stringcr_t name)
{
if (session == 0) {
return;
using namespace ARDOUR;
using namespace Gtk;
-GainAutomationTimeAxisView::GainAutomationTimeAxisView (Session& s, Route& r, PublicEditor& e, TimeAxisView& parent, ArdourCanvas::Canvas& canvas, std::string n, ARDOUR::Curve& c)
+GainAutomationTimeAxisView::GainAutomationTimeAxisView (Session& s, Route& r, PublicEditor& e, TimeAxisView& parent, ArdourCanvas::Canvas& canvas, stringcr_t n, ARDOUR::Curve& c)
: AxisView (s),
AutomationTimeAxisView (s, r, e, parent, canvas, n, X_("gain"), ""),
PublicEditor&,
TimeAxisView& parent_axis,
ArdourCanvas::Canvas& canvas,
- std::string name,
+ ARDOUR::stringcr_t name,
ARDOUR::Curve&);
~GainAutomationTimeAxisView();
using namespace std;
using namespace ardourvis ;
using namespace sigc;
+using namespace ARDOUR;
ImageFrameSocketHandler* ImageFrameSocketHandler::_instance = 0 ;
* @param src the identity of the object that initiated the change
*/
void
-ImageFrameSocketHandler::send_imageframe_time_axis_removed(std::string track_id, void* src)
+ImageFrameSocketHandler::send_imageframe_time_axis_removed(stringcr_t track_id, void* src)
{
if(this == src || src == 0)
{
* @param time_axis the time axis that has changed
*/
void
-ImageFrameSocketHandler::send_imageframe_time_axis_renamed(std::string new_id, std::string old_id, void* src, ImageFrameTimeAxis* time_axis)
+ImageFrameSocketHandler::send_imageframe_time_axis_renamed(stringcr_t new_id, stringcr_t old_id, void* src, ImageFrameTimeAxis* time_axis)
{
// ENSURE_GUI_THREAD(SigC::bind (mem_fun(*this, &ImageFrameSocketHandler::send_imageframe_time_axis_renamed), new_id, old_id, src, time_axis));
* @param src the identity of the object that initiated the change
*/
void
-ImageFrameSocketHandler::send_marker_time_axis_removed(std::string track_id, void* src)
+ImageFrameSocketHandler::send_marker_time_axis_removed(stringcr_t track_id, void* src)
{
if(this == src || src == 0)
{
* @param time_axis the time axis that has changed
*/
void
-ImageFrameSocketHandler::send_marker_time_axis_renamed(std::string new_id, std::string old_id, void* src, MarkerTimeAxis* time_axis)
+ImageFrameSocketHandler::send_marker_time_axis_renamed(stringcr_t new_id, stringcr_t old_id, void* src, MarkerTimeAxis* time_axis)
{
// ENSURE_GUI_THREAD(bind (mem_fun(*this, &ImageFrameSocketHandler::send_marker_time_axis_renamed), new_id, old_id, src, time_axis));
* @param group the group that has changed
*/
void
-ImageFrameSocketHandler::send_imageframe_time_axis_group_removed(std::string group_id, void* src, ImageFrameTimeAxisGroup* group)
+ImageFrameSocketHandler::send_imageframe_time_axis_group_removed(stringcr_t group_id, void* src, ImageFrameTimeAxisGroup* group)
{
if(this == src || src == 0)
{
* @param group the group that has changed
*/
void
-ImageFrameSocketHandler::send_imageframe_time_axis_group_renamed(std::string new_id, std::string old_id, void* src, ImageFrameTimeAxisGroup* group)
+ImageFrameSocketHandler::send_imageframe_time_axis_group_renamed(stringcr_t new_id, stringcr_t old_id, void* src, ImageFrameTimeAxisGroup* group)
{
// ENSURE_GUI_THREAD(bind (mem_fun(*this, &ImageFrameSocketHandler::send_imageframe_time_axis_group_renamed), new_id, old_id, src, group));
* @param item the renamed item
*/
void
-ImageFrameSocketHandler::send_imageframe_view_renamed(std::string new_id, std::string old_id, void* src, ImageFrameView* item)
+ImageFrameSocketHandler::send_imageframe_view_renamed(stringcr_t new_id, stringcr_t old_id, void* src, ImageFrameView* item)
{
if(this == src || src == 0)
{
* @param item the removed item
*/
void
-ImageFrameSocketHandler::send_imageframe_view_removed(std::string item_id, void* src, ImageFrameView* item)
+ImageFrameSocketHandler::send_imageframe_view_removed(stringcr_t item_id, void* src, ImageFrameView* item)
{
if(this == src || src == 0)
{
* @param item the MarkerView which has been renamed
*/
void
-ImageFrameSocketHandler::send_marker_view_renamed(std::string new_id, std::string old_id, void* src, MarkerView* item)
+ImageFrameSocketHandler::send_marker_view_renamed(stringcr_t new_id, stringcr_t old_id, void* src, MarkerView* item)
{
if(this == src || src == 0)
{
* @param item the MarkerView which has been removed
*/
void
-ImageFrameSocketHandler::send_marker_view_removed(std::string item_id, void* src, MarkerView* item)
+ImageFrameSocketHandler::send_marker_view_removed(stringcr_t item_id, void* src, MarkerView* item)
{
if(this == src || src == 0)
{
* @return the described item on success, 0 otherwise
*/
ImageFrameView*
-ImageFrameSocketHandler::get_imageframe_view_from_desc(const std::string& track_id, const std::string& group_id, const std::string& item_id, int& errcode, std::string& errmsg)
+ImageFrameSocketHandler::get_imageframe_view_from_desc(stringcr_t track_id, stringcr_t group_id, stringcr_t item_id, int& errcode, std::string& errmsg)
{
ImageFrameView* item = 0 ;
* @return the return value of the socket call
*/
int
-ImageFrameSocketHandler::send_message(const std::string& msg)
+ImageFrameSocketHandler::send_message(stringcr_t msg)
{
//std::cout << "Sending Message [" << msg << "]\n" ;
int retcode = ::send(theArdourToCompositorSocket, msg.c_str(), msg.length(), MSG_NOSIGNAL) ;
* @param track_id the unique id of the removed image frame time axis
* @param src the identity of the object that initiated the change
*/
- void send_imageframe_time_axis_removed(std::string track_id, void* src) ;
+ void send_imageframe_time_axis_removed(ARDOUR::stringcr_t track_id, void* src) ;
/**
* Sends a message indicating that an ImageFrameTimeAxis has been renamed
* @param src the identity of the object that initiated the change
* @param time_axis the time axis that has changed
*/
- void send_imageframe_time_axis_renamed(std::string new_id, std::string old_id, void* src, ImageFrameTimeAxis* time_axis) ;
+ void send_imageframe_time_axis_renamed(ARDOUR::stringcr_t new_id, ARDOUR::stringcr_t old_id, void* src, ImageFrameTimeAxis* time_axis) ;
//------------------------
// MarkerTimeAxis Messages
* @param track_id the unique id of the removed image frame time axis
* @param src the identity of the object that initiated the change
*/
- void send_marker_time_axis_removed(std::string track_id, void* src) ;
+ void send_marker_time_axis_removed(ARDOUR::stringcr_t track_id, void* src) ;
/**
* Sends a message indicating that an MarkerTimeAxis has been renamed
* @param src the identity of the object that initiated the change
* @param time_axis the time axis that has changed
*/
- void send_marker_time_axis_renamed(std::string new_id, std::string old_id, void* src, MarkerTimeAxis* time_axis) ;
+ void send_marker_time_axis_renamed(ARDOUR::stringcr_t new_id, ARDOUR::stringcr_t old_id, void* src, MarkerTimeAxis* time_axis) ;
//---------------------------------
* @param src the identity of the object that initiated the change
* @param group the group that has changed
*/
- void send_imageframe_time_axis_group_removed(std::string group_id, void* src, ImageFrameTimeAxisGroup* group) ;
+ void send_imageframe_time_axis_group_removed(ARDOUR::stringcr_t group_id, void* src, ImageFrameTimeAxisGroup* group) ;
/**
* Send a message indicating that an ImageFrameTimeAxisGroup has been renamed
* @param src the identity of the object that initiated the change
* @param group the group that has changed
*/
- void send_imageframe_time_axis_group_renamed(std::string new_id, std::string old_id, void* src, ImageFrameTimeAxisGroup* group) ;
+ void send_imageframe_time_axis_group_renamed(ARDOUR::stringcr_t new_id, ARDOUR::stringcr_t old_id, void* src, ImageFrameTimeAxisGroup* group) ;
//---------------------------------
* @param src the identity of the object that initiated the change
* @param item the renamed item
*/
- void send_imageframe_view_renamed(std::string new_id, std::string old_id, void* src, ImageFrameView* item) ;
+ void send_imageframe_view_renamed(ARDOUR::stringcr_t new_id, ARDOUR::stringcr_t old_id, void* src, ImageFrameView* item) ;
/**
* Send a message indicating that an ImageFrameView item has been removed message
* @param src the identity of the object that initiated the change
* @param item the removed item
*/
- void send_imageframe_view_removed(std::string item_id, void* src, ImageFrameView* item) ;
+ void send_imageframe_view_removed(ARDOUR::stringcr_t item_id, void* src, ImageFrameView* item) ;
//---------------------------------
// MarkerView Messages
* @param src the identity of the object that initiated the change
* @param item the MarkerView which has been renamed
*/
- void send_marker_view_renamed(std::string new_id, std::string old_id, void* src, MarkerView* item) ;
+ void send_marker_view_renamed(ARDOUR::stringcr_t new_id, ARDOUR::stringcr_t old_id, void* src, MarkerView* item) ;
/**
* Send a message indicating that a MarkerView item has been removed message
* @param src the identity of the object that initiated the change
* @param item the MarkerView which has been removed
*/
- void send_marker_view_removed(std::string item_id, void* src, MarkerView* item) ;
+ void send_marker_view_removed(ARDOUR::stringcr_t item_id, void* src, MarkerView* item) ;
//---------------------------------------------------------------------------------------//
* @param errmsg populated with a description of the error on failure
* @return the described item on success, 0 otherwise
*/
- ImageFrameView* get_imageframe_view_from_desc(const std::string& track_id, const std::string& group_ud, const std::string& item_id, int& errcode, std::string& errmsg) ;
+ ImageFrameView* get_imageframe_view_from_desc(ARDOUR::stringcr_t track_id, ARDOUR::stringcr_t group_ud, ARDOUR::stringcr_t item_id, int& errcode, std::string& errmsg) ;
//---------------------------------------------------------------------------------------//
// Convenince Message Send Methods
* @param msg the message to send
* @return the return value of the socket call
*/
- int send_message(const std::string& msg) ;
+ int send_message(ARDOUR::stringcr_t msg) ;
/**
* Reads a message from the Socket
* @param sess the current session
* @param canvas the parent canvas item
*/
-ImageFrameTimeAxis::ImageFrameTimeAxis(std::string track_id, PublicEditor& ed, ARDOUR::Session& sess, ArdourCanvas::Canvas& canvas)
+ImageFrameTimeAxis::ImageFrameTimeAxis(stringcr_t track_id, PublicEditor& ed, ARDOUR::Session& sess, ArdourCanvas::Canvas& canvas)
: AxisView(sess),
VisualTimeAxis(track_id, ed, sess, canvas)
{
* @return the named markerTimeAxis, or 0 if the named MarkerTimeAxis is not associated with this ImageFrameTimeAxis
*/
MarkerTimeAxis*
-ImageFrameTimeAxis::get_named_marker_time_axis(std::string track_id)
+ImageFrameTimeAxis::get_named_marker_time_axis(stringcr_t track_id)
{
MarkerTimeAxis* mta = 0 ;
* @return the removed MarkerTimeAxis
*/
MarkerTimeAxis*
-ImageFrameTimeAxis::remove_named_marker_time_axis(std::string track_id, void* src)
+ImageFrameTimeAxis::remove_named_marker_time_axis(stringcr_t track_id, void* src)
{
MarkerTimeAxis* mta = 0 ;
* @param sess the current session
* @param canvas the parent canvas item
*/
- ImageFrameTimeAxis(std::string track_id, PublicEditor& ed, ARDOUR::Session& sess, ArdourCanvas::Canvas& canvas) ;
+ ImageFrameTimeAxis(ARDOUR::stringcr_t track_id, PublicEditor& ed, ARDOUR::Session& sess, ArdourCanvas::Canvas& canvas) ;
/**
* Destructor
* @param track_id the track_id of the MarkerTimeAxis to search for
* @return the named markerTimeAxis, or 0 if the named MarkerTimeAxis is not associated with this ImageFrameTimeAxis
*/
- MarkerTimeAxis* get_named_marker_time_axis(std::string track_id) ;
+ MarkerTimeAxis* get_named_marker_time_axis(ARDOUR::stringcr_t track_id) ;
/**
* Removes the named markerTimeAxis from those associated with this ImageFrameTimeAxis
* @param src the identity of the object that initiated the change
* @return the removed MarkerTimeAxis
*/
- MarkerTimeAxis* remove_named_marker_time_axis(std::string track_id, void* src) ;
+ MarkerTimeAxis* remove_named_marker_time_axis(ARDOUR::stringcr_t track_id, void* src) ;
/**
* Removes tav from the list of MarkerTimaAxis associated with this ImageFrameTimeAxis
* @param iftav the parent ImageFrameTimeAxis of this view helper
* @param group_id the unique name/id of this group
*/
-ImageFrameTimeAxisGroup::ImageFrameTimeAxisGroup(ImageFrameTimeAxisView& iftav, std::string group_id)
+ImageFrameTimeAxisGroup::ImageFrameTimeAxisGroup(ImageFrameTimeAxisView& iftav, stringcr_t group_id)
: _view_helper(iftav), _group_id(group_id)
{
selected_imageframe_item = 0 ;
* @param src the identity of the object that initiated the change
*/
void
-ImageFrameTimeAxisGroup::set_group_name(std::string new_name, void* src)
+ImageFrameTimeAxisGroup::set_group_name(stringcr_t new_name, void* src)
{
if(_group_id != new_name)
{
* @param src the identity of the object that initiated the change
*/
ImageFrameView*
-ImageFrameTimeAxisGroup::add_imageframe_item(std::string frame_id, jack_nframes_t start, jack_nframes_t duration, unsigned char* rgb_data, uint32_t width, uint32_t height, uint32_t num_channels, void* src)
+ImageFrameTimeAxisGroup::add_imageframe_item(stringcr_t frame_id, jack_nframes_t start, jack_nframes_t duration, unsigned char* rgb_data, uint32_t width, uint32_t height, uint32_t num_channels, void* src)
{
ImageFrameView* ifv = 0 ;
* @return the named ImageFrameView, or 0 if it is not held upon this view
*/
ImageFrameView*
-ImageFrameTimeAxisGroup::get_named_imageframe_item(std::string frame_id)
+ImageFrameTimeAxisGroup::get_named_imageframe_item(stringcr_t frame_id)
{
ImageFrameView* ifv = 0 ;
* @see add_imageframe_view
*/
ImageFrameView*
-ImageFrameTimeAxisGroup::remove_named_imageframe_item(std::string frame_id, void* src)
+ImageFrameTimeAxisGroup::remove_named_imageframe_item(stringcr_t frame_id, void* src)
{
ImageFrameView* removed = 0 ;
#include <libgnomecanvas/libgnomecanvas.h>
#include <jack/jack.h>
+#include <ardour/types.h>
#include "imageframe_time_axis_view.h"
class PublicEditor ;
* @param iftav the parent ImageFrameTimeAxis of this view helper
* @param group_id the unique name/id of this group
*/
- ImageFrameTimeAxisGroup(ImageFrameTimeAxisView& iftav, std::string group_id) ;
+ ImageFrameTimeAxisGroup(ImageFrameTimeAxisView& iftav, ARDOUR::stringcr_t group_id) ;
/**
* Destructor
* @param new_name the new name of this group
* @param src the identity of the object that initiated the change
*/
- void set_group_name(std::string new_name, void* src) ;
+ void set_group_name(ARDOUR::stringcr_t new_name, void* src) ;
/**
* Returns the id of this group
* @param num_channels the number of channles within the rgb_data
* @param src the identity of the object that initiated the change
*/
- ImageFrameView* add_imageframe_item(std::string item_id, jack_nframes_t start, jack_nframes_t duration, unsigned char* rgb_data, uint32_t width, uint32_t height, uint32_t num_channels, void* src) ;
+ ImageFrameView* add_imageframe_item(ARDOUR::stringcr_t item_id, jack_nframes_t start, jack_nframes_t duration, unsigned char* rgb_data, uint32_t width, uint32_t height, uint32_t num_channels, void* src) ;
/**
* Returns the named ImageFrameView or 0 if the named view does not exist on this view helper
* @param item_id the unique id of the item to search for
* @return the named ImageFrameView, or 0 if it is not held upon this view
*/
- ImageFrameView* get_named_imageframe_item(std::string item_id) ;
+ ImageFrameView* get_named_imageframe_item(ARDOUR::stringcr_t item_id) ;
/**
* Removes the currently selected ImageFrameView
* @param src the identity of the object that initiated the change
* @see add_imageframe_view
*/
- ImageFrameView* remove_named_imageframe_item(std::string item_id, void* src) ;
+ ImageFrameView* remove_named_imageframe_item(ARDOUR::stringcr_t item_id, void* src) ;
/**
* Removes ifv from the list of ImageFrameViews upon this TimeAxis.
sigc::signal<void, ImageFrameView*, void*> ImageFrameAdded ;
/** Emitted when an ImageFrameView is removed from this group */
- sigc::signal<void, std::string&, std::string&, std::string&, void*> ImageFrameRemoved ;
+ sigc::signal<void, ARDOUR::stringcr_t, ARDOUR::stringcr_t, ARDOUR::stringcr_t, void*> ImageFrameRemoved ;
protected:
* @param height the width of the origianl rgb_data image data
* @param num_channels the number of color channels within rgb_data
*/
-ImageFrameView::ImageFrameView(std::string item_id,
+ImageFrameView::ImageFrameView(stringcr_t item_id,
ArdourCanvas::Group *parent,
ImageFrameTimeAxis* tv,
ImageFrameTimeAxisGroup* item_group,
* @return the removed marker item
*/
MarkerView*
-ImageFrameView::remove_named_marker_view_item(std::string markerId, void* src)
+ImageFrameView::remove_named_marker_view_item(stringcr_t markerId, void* src)
{
MarkerView* mv = 0 ;
MarkerViewList::iterator i = marker_view_list.begin() ;
* @param markId the id/name of the item to search for
*/
bool
-ImageFrameView::has_marker_view_item(std::string mname)
+ImageFrameView::has_marker_view_item(stringcr_t mname)
{
bool result = false ;
- for (MarkerViewList::iterator ci = marker_view_list.begin(); ci != marker_view_list.end(); ++ci)
+ for (MarkerViewList::const_iterator ci = marker_view_list.begin(); ci != marker_view_list.end(); ++ci)
{
if (((MarkerView*)*ci)->get_item_name() == mname)
{
* @param height the width of the origianl rgb_data image data
* @param num_channels the number of color channels within rgb_data
*/
- ImageFrameView(std::string item_id,
+ ImageFrameView(ARDOUR::stringcr_t item_id,
ArdourCanvas::Group *parent,
ImageFrameTimeAxis *tv,
ImageFrameTimeAxisGroup* group,
* @param src the identity of the object that initiated the change
* @return the removed marker item
*/
- MarkerView* remove_named_marker_view_item(std::string markId, void* src) ;
+ MarkerView* remove_named_marker_view_item(ARDOUR::stringcr_t markId, void* src) ;
/**
* Removes item from the list of marker views assocaited with this item
*
* @param markId the id/name of the item to search for
*/
- bool has_marker_view_item(std::string markId) ;
+ bool has_marker_view_item(ARDOUR::stringcr_t markId) ;
//---------------------------------------------------------------------------------//
* @param name the name/id of this time axis
* @param tav the associated track view that this MarkerTimeAxis is marking up
*/
-MarkerTimeAxis::MarkerTimeAxis (PublicEditor& ed, ARDOUR::Session& sess, Canvas& canvas, std::string name, TimeAxisView* tav)
+MarkerTimeAxis::MarkerTimeAxis (PublicEditor& ed, ARDOUR::Session& sess, Canvas& canvas, stringcr_t name, TimeAxisView* tav)
: AxisView(sess),
VisualTimeAxis(name, ed, sess, canvas)
{
* @param name the name/id of this time axis
* @param tav the associated track view that this MarkerTimeAxis is marking up
*/
- MarkerTimeAxis(PublicEditor& ed, ARDOUR::Session& sess, ArdourCanvas::Canvas& canvas, std::string name, TimeAxisView* tav) ;
+ MarkerTimeAxis(PublicEditor& ed, ARDOUR::Session& sess, ArdourCanvas::Canvas& canvas, ARDOUR::stringcr_t name, TimeAxisView* tav) ;
/**
* Destructor
}
void
-OptionEditor::click_chosen (string path)
+OptionEditor::click_chosen (stringcr_t path)
{
click_path_entry.set_text (path);
click_sound_changed ();
}
void
-OptionEditor::click_emphasis_chosen (std::string path)
+OptionEditor::click_emphasis_chosen (stringcr_t path)
{
click_emphasis_path_entry.set_text (path);
click_emphasis_sound_changed ();
void setup_click_editor ();
void clear_click_editor ();
- void click_chosen (std::string paths);
- void click_emphasis_chosen (std::string paths);
+ void click_chosen (ARDOUR::stringcr_t paths);
+ void click_emphasis_chosen (ARDOUR::stringcr_t paths);
void click_browse_clicked ();
void click_emphasis_browse_clicked ();
virtual void set_mouse_mode (Editing::MouseMode, bool force = false) = 0;
virtual void step_mouse_mode (bool next) = 0;
virtual Editing::MouseMode current_mouse_mode () = 0;
- virtual void add_imageframe_time_axis(std::string track_name, void*) = 0;
- virtual void add_imageframe_marker_time_axis(std::string track_name, TimeAxisView* marked_track, void*) = 0;
+ virtual void add_imageframe_time_axis(ARDOUR::stringcr_t track_name, void*) = 0;
+ virtual void add_imageframe_marker_time_axis(ARDOUR::stringcr_t track_name, TimeAxisView* marked_track, void*) = 0;
virtual void connect_to_image_compositor() = 0;
virtual void scroll_timeaxis_to_imageframe_item(const TimeAxisViewItem* item) = 0;
- virtual TimeAxisView* get_named_time_axis(std::string name) = 0;
+ virtual TimeAxisView* get_named_time_axis(ARDOUR::stringcr_t name) = 0;
virtual void consider_auditioning (ARDOUR::Region&) = 0;
virtual void set_show_waveforms (bool yn) = 0;
virtual bool show_waveforms() const = 0;
using namespace std;
using namespace ARDOUR;
-RedirectAutomationLine::RedirectAutomationLine (string name, Redirect& rd, uint32_t port, Session& s,
+RedirectAutomationLine::RedirectAutomationLine (stringcr_t name, Redirect& rd, uint32_t port, Session& s,
TimeAxisView& tv, ArdourCanvas::Group& parent,
class RedirectAutomationLine : public AutomationLine
{
public:
- RedirectAutomationLine (string name, ARDOUR::Redirect&, uint32_t port, ARDOUR::Session&, TimeAxisView&,
+ RedirectAutomationLine (ARDOUR::stringcr_t name, ARDOUR::Redirect&, uint32_t port, ARDOUR::Session&, TimeAxisView&,
ArdourCanvas::Group& parent, ARDOUR::AutomationList&);
uint32_t port() const { return _port; }
using namespace std;
using namespace ARDOUR;
-AudioRegionGainLine::AudioRegionGainLine (string name, Session& s, AudioRegionView& r, ArdourCanvas::Group& parent, Curve& c)
+AudioRegionGainLine::AudioRegionGainLine (stringcr_t name, Session& s, AudioRegionView& r, ArdourCanvas::Group& parent, Curve& c)
: AutomationLine (name, r.get_time_axis_view(), parent, c),
session (s),
rv (r)
class AudioRegionGainLine : public AutomationLine
{
public:
- AudioRegionGainLine (string name, ARDOUR::Session&, AudioRegionView&, ArdourCanvas::Group& parent, ARDOUR::Curve&);
+ AudioRegionGainLine (ARDOUR::stringcr_t name, ARDOUR::Session&, AudioRegionView&, ArdourCanvas::Group& parent, ARDOUR::Curve&);
void view_to_model_y (double&);
void model_to_view_y (double&);
}
XMLNode*
-RouteUI::get_child_xml_node (string childname)
+RouteUI::get_child_xml_node (stringcr_t childname)
{
XMLNode* child;
XMLNode *xml_node;
void ensure_xml_node ();
- XMLNode* get_child_xml_node (std::string childname);
+ XMLNode* get_child_xml_node (ARDOUR::stringcr_t childname);
gint mute_press(GdkEventButton*);
gint mute_release(GdkEventButton*);
using namespace Gtkmm2ext;
using namespace ARDOUR;
-TempoDialog::TempoDialog (TempoMap& map, jack_nframes_t frame, string action)
+TempoDialog::TempoDialog (TempoMap& map, jack_nframes_t frame, stringcr_t action)
: ArdourDialog ("tempo dialog"),
bpm_frame (_("Beats per minute")),
ok_button (action),
init (when, tempo.beats_per_minute(), true);
}
-TempoDialog::TempoDialog (TempoSection& section, string action)
+TempoDialog::TempoDialog (TempoSection& section, stringcr_t action)
: ArdourDialog ("tempo dialog"),
bpm_frame (_("Beats per minute")),
ok_button (action),
}
-MeterDialog::MeterDialog (TempoMap& map, jack_nframes_t frame, string action)
+MeterDialog::MeterDialog (TempoMap& map, jack_nframes_t frame, stringcr_t action)
: ArdourDialog ("meter dialog"),
note_frame (_("Meter denominator")),
bpb_frame (_("Beats per bar")),
init (when, meter.beats_per_bar(), meter.note_divisor(), true);
}
-MeterDialog::MeterDialog (MeterSection& section, string action)
+MeterDialog::MeterDialog (MeterSection& section, stringcr_t action)
: ArdourDialog ("meter dialog"),
note_frame (_("Meter denominator")),
bpb_frame (_("Beats per bar")),
Gtk::Frame when_frame;
char buf[64];
- TempoDialog (ARDOUR::TempoMap&, jack_nframes_t, string action);
- TempoDialog (ARDOUR::TempoSection&, string action);
+ TempoDialog (ARDOUR::TempoMap&, jack_nframes_t, ARDOUR::stringcr_t action);
+ TempoDialog (ARDOUR::TempoSection&, ARDOUR::stringcr_t action);
double get_bpm ();
bool get_bbt_time (ARDOUR::BBT_Time&);
Gtk::Frame when_frame;
char buf[64];
- MeterDialog (ARDOUR::TempoMap&, jack_nframes_t, string action);
- MeterDialog (ARDOUR::MeterSection&, string action);
+ MeterDialog (ARDOUR::TempoMap&, jack_nframes_t, ARDOUR::stringcr_t action);
+ MeterDialog (ARDOUR::MeterSection&, ARDOUR::stringcr_t action);
double get_bpb ();
double get_note_type ();
/* call this on the parent */
- virtual XMLNode* get_child_xml_node (std::string childname) { return 0; }
+ virtual XMLNode* get_child_xml_node (ARDOUR::stringcr_t childname) { return 0; }
protected:
}
string
-fit_to_pixels (string str, int pixel_width, string font)
+fit_to_pixels (ARDOUR::stringcr_t str, int pixel_width, ARDOUR::stringcr_t font)
{
Label foo;
int width;
}
std::string short_version (std::string, std::string::size_type target_length);
-std::string fit_to_pixels (std::string, int pixel_width, std::string font);
+std::string fit_to_pixels (ARDOUR::stringcr_t, int pixel_width, ARDOUR::stringcr_t font);
int atoi (const std::string&);
double atof (const std::string&);
* @param sess the current session
* @param canvas the parent canvas object
*/
-VisualTimeAxis::VisualTimeAxis(std::string name, PublicEditor& ed, ARDOUR::Session& sess, Canvas& canvas)
+VisualTimeAxis::VisualTimeAxis(stringcr_t name, PublicEditor& ed, ARDOUR::Session& sess, Canvas& canvas)
: AxisView(sess),
TimeAxisView(sess,ed,(TimeAxisView*) 0, canvas),
visual_button (_("v")),
// Name/Id Accessors/Mutators
void
-VisualTimeAxis::set_time_axis_name(std::string name, void* src)
+VisualTimeAxis::set_time_axis_name(stringcr_t name, void* src)
{
std::string old_name = time_axis_name ;
bool picked ;
Gdk::Color color ;
gdouble current[4] ;
- Gdk::Color* current_color ;
+ Gdk::Color current_color ;
current[0] = _color.get_red() / 65535.0 ;
current[1] = _color.get_green() / 65535.0 ;
current[2] = _color.get_blue() / 65535.0 ;
current[3] = 1.0 ;
- current_color->set_rgb_p (current[0],current[1],current[2]);
- color = Gtkmm2ext::UI::instance()->get_color(_("ardour: color selection"),picked, current_color) ;
+ current_color.set_rgb_p (current[0],current[1],current[2]);
+ color = Gtkmm2ext::UI::instance()->get_color(_("ardour: color selection"),picked, ¤t_color) ;
if (picked)
{
* @param name the new name of this TimeAxis
* @param src the identity of the object that initiated the change
*/
- virtual void set_time_axis_name(std::string name, void* src) ;
+ virtual void set_time_axis_name(ARDOUR::stringcr_t name, void* src) ;
//---------------------------------------------------------------------------------------//
/**
* Emitted when we have changed the gui, and what we have shanged
*/
- sigc::signal<void,string,void*> gui_changed ;
+ sigc::signal<void,ARDOUR::stringcr_t,void*> gui_changed ;
/**
* Emitted when this Visual Time Axis has been removed
* the destructor, this allows us to capture the source of the deletion
* event
*/
- sigc::signal<void,std::string,void*> VisualTimeAxisRemoved ;
+ sigc::signal<void,ARDOUR::stringcr_t,void*> VisualTimeAxisRemoved ;
/**
* Emitted when we have changed the name of this TimeAxis
*/
- sigc::signal<void,std::string,std::string,void*> NameChanged ;
+ sigc::signal<void,ARDOUR::stringcr_t,ARDOUR::stringcr_t,void*> NameChanged ;
/**
* Emitted when this time axis has been selected for removal
* @param sess the current session
* @param canvas the parent canvas object
*/
- VisualTimeAxis(std::string name, PublicEditor& ed, ARDOUR::Session& sess, ArdourCanvas::Canvas& canvas) ;
+ VisualTimeAxis(ARDOUR::stringcr_t name, PublicEditor& ed, ARDOUR::Session& sess, ArdourCanvas::Canvas& canvas) ;
//---------------------------------------------------------------------------------------//