bool
CanvasNoteEvent::on_event(GdkEvent* ev)
{
+ PublicEditor& editor (_region.get_time_axis_view().editor());
+
+ if (!editor.internal_editing()) {
+ return false;
+ }
+
MidiStreamView *streamview = _region.midi_stream_view();
static uint8_t drag_delta_note = 0;
static double drag_delta_x = 0;
bool select_mod;
uint8_t d_velocity = 10;
- if (_region.get_time_axis_view().editor().current_mouse_mode() != Editing::MouseNote) {
- return false;
- }
-
- const Editing::MidiEditMode midi_edit_mode
- = _region.midi_view()->editor().current_midi_edit_mode();
-
switch (ev->type) {
case GDK_SCROLL:
if (Keyboard::modifier_state_equals (ev->scroll.state, Keyboard::Level4Modifier)) {
switch (_state) {
case Pressed: // Drag begin
- if (midi_edit_mode == Editing::MidiEditSelect
- && _region.mouse_state() != MidiRegionView::SelectTouchDragging) {
+ if (editor.current_mouse_mode() == Editing::MouseRange && _region.mouse_state() != MidiRegionView::SelectTouchDragging) {
_item->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
Gdk::Cursor(Gdk::FLEUR), ev->motion.time);
_state = Dragging;
switch (_state) {
case Pressed: // Clicked
- if (midi_edit_mode == Editing::MidiEditSelect) {
+ if (editor.current_mouse_mode() == Editing::MouseRange) {
_state = None;
if (_selected && !select_mod && _region.selection_size() > 1) {
_region.unique_select(this);
} else {
_region.note_selected(this, select_mod);
}
+#if 0
} else if (midi_edit_mode == Editing::MidiEditErase) {
_region.start_delta_command();
_region.command_remove_note(this);
_region.apply_command();
+#endif
}
return true;
bool
CanvasNote::on_event(GdkEvent* ev)
{
+ PublicEditor& editor (_region.get_trackview().editor());
+
+ if (!editor.internal_editing()) {
+ return false;
+ }
+
double event_x;
static double middle_point, last_x;
Gdk::Cursor cursor;
static NoteEnd note_end;
- Editing::MidiEditMode edit_mode = _region.get_trackview().editor().current_midi_edit_mode();
switch (ev->type) {
case GDK_BUTTON_PRESS:
if (ev->button.button == 2 ||
- (ev->button.button == 1 && edit_mode == Editing::MidiEditResize)) {
+ (ev->button.button == 1 && editor.current_mouse_mode() == Editing::MouseTimeFX)) {
double region_start = _region.get_position_pixels();
event_x = ev->button.x;
middle_point = region_start + x1() + (x2() - x1()) / 2.0L;
#undef MOUSEMODE
#define MOUSEMODE(a) /*empty*/
-// MIDIEDITMODE
-#undef MIDIEDITMODE
-#define MIDIEDITMODE(s) if (!strcmp(type, #s)) {return s;}
-MidiEditMode
-str2midieditmode (const string & str) {
- const char* type = str.c_str();
- #include "editing_syms.h"
- return MidiEditSelect;
-}
-
-#undef MIDIEDITMODE
-#define MIDIEDITMODE(s) N_(#s),
-const char *midieditmodestrs[] = {
- #include "editing_syms.h"
- 0
-};
-#undef MIDIEDITMODE
-#define MIDIEDITMODE(a) /*empty*/
-
// ZOOMFOCUS
#undef ZOOMFOCUS
#define ZOOMFOCUS(s) if (!strcmp(type, #s)) {return s;}
MOUSEMODE(MouseTimeFX)
MOUSEMODE(MouseZoom)
MOUSEMODE(MouseAudition)
-MOUSEMODE(MouseNote)
-
-MIDIEDITMODE(MidiEditPencil)
-MIDIEDITMODE(MidiEditSelect)
-MIDIEDITMODE(MidiEditResize)
-MIDIEDITMODE(MidiEditErase)
/* Changing this order will break the menu */
ZOOMFOCUS(ZoomFocusLeft)
}
Editor::Editor ()
- :
/* time display buttons */
-
- minsec_label (_("Mins:Secs")),
- bbt_label (_("Bars:Beats")),
- smpte_label (_("Timecode")),
- frame_label (_("Samples")),
- tempo_label (_("Tempo")),
- meter_label (_("Meter")),
- mark_label (_("Location Markers")),
- range_mark_label (_("Range Markers")),
- transport_mark_label (_("Loop/Punch Ranges")),
- cd_mark_label (_("CD Markers")),
- edit_packer (4, 4, true),
+ : minsec_label (_("Mins:Secs"))
+ , bbt_label (_("Bars:Beats"))
+ , smpte_label (_("Timecode"))
+ , frame_label (_("Samples"))
+ , tempo_label (_("Tempo"))
+ , meter_label (_("Meter"))
+ , mark_label (_("Location Markers"))
+ , range_mark_label (_("Range Markers"))
+ , transport_mark_label (_("Loop/Punch Ranges"))
+ , cd_mark_label (_("CD Markers"))
+ , edit_packer (4, 4, true)
/* the values here don't matter: layout widgets
reset them as needed.
*/
-
- vertical_adjustment (0.0, 0.0, 10.0, 400.0),
- horizontal_adjustment (0.0, 0.0, 20.0, 1200.0),
-
+
+ , vertical_adjustment (0.0, 0.0, 10.0, 400.0)
+ , horizontal_adjustment (0.0, 0.0, 20.0, 1200.0)
+
/* tool bar related */
- edit_point_clock (X_("editpoint"), false, X_("EditPointClock"), true),
- zoom_range_clock (X_("zoomrange"), false, X_("ZoomRangeClock"), true, true),
+ , edit_point_clock (X_("editpoint"), false, X_("EditPointClock"), true)
+ , zoom_range_clock (X_("zoomrange"), false, X_("ZoomRangeClock"), true, true)
- toolbar_selection_clock_table (2,3),
+ , toolbar_selection_clock_table (2,3)
+
+ , automation_mode_button (_("mode"))
+ , global_automation_button (_("automation"))
+
+ , midi_panic_button (_("Panic"))
- automation_mode_button (_("mode")),
- global_automation_button (_("automation")),
-
- midi_panic_button (_("Panic")),
- midi_tools_tearoff (0),
-
#ifdef WITH_CMT
- image_socket_listener(0),
+ , image_socket_listener(0)
#endif
-
+
/* nudge */
-
- nudge_clock (X_("nudge"), false, X_("NudgeClock"), true, true),
- meters_running(false),
- _pending_locate_request (false)
+
+ , nudge_clock (X_("nudge"), false, X_("NudgeClock"), true, true)
+ , meters_running(false)
+ , _pending_locate_request (false)
{
constructed = false;
region_edit_menu_split_item = 0;
temp_location = 0;
leftmost_frame = 0;
- ignore_mouse_mode_toggle = false;
- ignore_midi_edit_mode_toggle = false;
current_stepping_trackview = 0;
entered_track = 0;
entered_regionview = 0;
location_loop_color = ARDOUR_UI::config()->canvasvar_LocationLoop.get();
location_punch_color = ARDOUR_UI::config()->canvasvar_LocationPunch.get();
- set_midi_edit_mode (MidiEditPencil, true);
_edit_point = EditAtMouse;
- set_mouse_mode (MouseObject, true);
+ _internal_editing = false;
+ current_canvas_cursor = 0;
frames_per_unit = 2048; /* too early to use reset_zoom () */
reset_hscrollbar_stepping ();
edit_pane.signal_size_allocate().connect (bind (mem_fun(*this, &Editor::pane_allocation_handler), static_cast<Paned*> (&edit_pane)));
top_hbox.pack_start (toolbar_frame, false, true);
- top_hbox.pack_start (midi_toolbar_frame, false, true);
HBox *hbox = manage (new HBox);
hbox->pack_start (edit_pane, true, true);
snap_mode = SnapOff;
set_snap_mode (snap_mode);
set_edit_point_preference (EditAtMouse, true);
+ set_mouse_mode (MouseObject, true);
XMLNode* node = ARDOUR_UI::instance()->editor_settings();
set_state (*node);
/* Mode Buttons (tool selection) */
- vector<ToggleButton *> mouse_mode_buttons;
-
- mouse_move_button.add (*(manage (new Image (::get_icon("tool_object")))));
mouse_move_button.set_relief(Gtk::RELIEF_NONE);
- mouse_mode_buttons.push_back (&mouse_move_button);
-
- if (!Profile->get_sae()) {
- mouse_select_button.add (*(manage (new Image (get_xpm("tool_range.xpm")))));
- mouse_select_button.set_relief(Gtk::RELIEF_NONE);
- mouse_mode_buttons.push_back (&mouse_select_button);
-
- mouse_gain_button.add (*(manage (new Image (::get_icon("tool_gain")))));
- mouse_gain_button.set_relief(Gtk::RELIEF_NONE);
- mouse_mode_buttons.push_back (&mouse_gain_button);
- }
-
- mouse_zoom_button.add (*(manage (new Image (::get_icon("tool_zoom")))));
+ mouse_select_button.set_relief(Gtk::RELIEF_NONE);
+ mouse_gain_button.set_relief(Gtk::RELIEF_NONE);
mouse_zoom_button.set_relief(Gtk::RELIEF_NONE);
- mouse_mode_buttons.push_back (&mouse_zoom_button);
- mouse_timefx_button.add (*(manage (new Image (::get_icon("tool_stretch")))));
mouse_timefx_button.set_relief(Gtk::RELIEF_NONE);
- mouse_mode_buttons.push_back (&mouse_timefx_button);
- mouse_audition_button.add (*(manage (new Image (::get_icon("tool_audition")))));
mouse_audition_button.set_relief(Gtk::RELIEF_NONE);
- mouse_note_button.add (*(manage (new Image (::get_icon("tool_note")))));
- mouse_note_button.set_relief(Gtk::RELIEF_NONE);
- mouse_mode_buttons.push_back (&mouse_note_button);
- mouse_mode_buttons.push_back (&mouse_audition_button);
-
- mouse_mode_button_set = new GroupedButtons (mouse_mode_buttons);
+ // internal_edit_button.set_relief(Gtk::RELIEF_NONE);
HBox* mode_box = manage(new HBox);
mode_box->set_border_width (2);
}
mouse_mode_button_box.pack_start(mouse_timefx_button, true, true);
mouse_mode_button_box.pack_start(mouse_audition_button, true, true);
- mouse_mode_button_box.pack_start(mouse_note_button, true, true);
+ mouse_mode_button_box.pack_start(internal_edit_button, true, true);
mouse_mode_button_box.set_homogeneous(true);
vector<string> edit_mode_strings;
mouse_mode_tearoff->Visible.connect (bind (mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&toolbar_hbox),
&mouse_mode_tearoff->tearoff_window(), 1));
+ mouse_move_button.set_mode (false);
+ mouse_select_button.set_mode (false);
+ mouse_gain_button.set_mode (false);
+ mouse_zoom_button.set_mode (false);
+ mouse_timefx_button.set_mode (false);
+ mouse_audition_button.set_mode (false);
+
mouse_move_button.set_name ("MouseModeButton");
mouse_select_button.set_name ("MouseModeButton");
mouse_gain_button.set_name ("MouseModeButton");
mouse_zoom_button.set_name ("MouseModeButton");
mouse_timefx_button.set_name ("MouseModeButton");
mouse_audition_button.set_name ("MouseModeButton");
- mouse_note_button.set_name ("MouseModeButton");
- ARDOUR_UI::instance()->tooltips().set_tip (mouse_move_button, _("Select/Move Objects"));
- ARDOUR_UI::instance()->tooltips().set_tip (mouse_select_button, _("Select/Move Ranges"));
- ARDOUR_UI::instance()->tooltips().set_tip (mouse_gain_button, _("Draw Gain Automation"));
- ARDOUR_UI::instance()->tooltips().set_tip (mouse_zoom_button, _("Select Zoom Range"));
- ARDOUR_UI::instance()->tooltips().set_tip (mouse_timefx_button, _("Stretch/Shrink Regions"));
- ARDOUR_UI::instance()->tooltips().set_tip (mouse_audition_button, _("Listen to Specific Regions"));
- ARDOUR_UI::instance()->tooltips().set_tip (mouse_note_button, _("Edit MIDI Notes"));
+ internal_edit_button.set_name ("MouseModeButton");
mouse_move_button.unset_flags (CAN_FOCUS);
mouse_select_button.unset_flags (CAN_FOCUS);
mouse_zoom_button.unset_flags (CAN_FOCUS);
mouse_timefx_button.unset_flags (CAN_FOCUS);
mouse_audition_button.unset_flags (CAN_FOCUS);
- mouse_note_button.unset_flags (CAN_FOCUS);
-
- mouse_select_button.signal_toggled().connect (bind (mem_fun(*this, &Editor::mouse_mode_toggled), Editing::MouseRange));
- mouse_select_button.signal_button_release_event().connect (mem_fun(*this, &Editor::mouse_select_button_release));
-
- mouse_move_button.signal_toggled().connect (bind (mem_fun(*this, &Editor::mouse_mode_toggled), Editing::MouseObject));
- mouse_gain_button.signal_toggled().connect (bind (mem_fun(*this, &Editor::mouse_mode_toggled), Editing::MouseGain));
- mouse_zoom_button.signal_toggled().connect (bind (mem_fun(*this, &Editor::mouse_mode_toggled), Editing::MouseZoom));
- mouse_timefx_button.signal_toggled().connect (bind (mem_fun(*this, &Editor::mouse_mode_toggled), Editing::MouseTimeFX));
- mouse_audition_button.signal_toggled().connect (bind (mem_fun(*this, &Editor::mouse_mode_toggled), Editing::MouseAudition));
- mouse_note_button.signal_toggled().connect (bind (mem_fun(*this, &Editor::mouse_mode_toggled), Editing::MouseNote));
-
- // mouse_move_button.set_active (true);
-
+ internal_edit_button.unset_flags (CAN_FOCUS);
/* Zoom */
toolbar_hbox.pack_start (*mouse_mode_tearoff, false, false);
toolbar_hbox.pack_start (*tools_tearoff, false, false);
-
hbox->pack_start (snap_box, false, false);
- // hbox->pack_start (zoom_box, false, false);
hbox->pack_start (*nudge_box, false, false);
+ hbox->pack_start (panic_box, false, false);
hbox->show_all ();
void
Editor::setup_midi_toolbar ()
{
- string pixmap_path;
-
- /* Mode Buttons (tool selection) */
-
- vector<ToggleButton *> midi_tool_buttons;
-
+#if 0
midi_tool_pencil_button.add (*(manage (new Image (::get_icon("midi_tool_pencil")))));
midi_tool_pencil_button.set_relief(Gtk::RELIEF_NONE);
midi_tool_buttons.push_back (&midi_tool_pencil_button);
midi_tool_erase_button.set_relief(Gtk::RELIEF_NONE);
midi_tool_buttons.push_back (&midi_tool_erase_button);
- midi_tool_pencil_button.set_active(true);
-
- midi_tool_button_set = new GroupedButtons (midi_tool_buttons);
-
- midi_tool_button_box.set_border_width (2);
- midi_tool_button_box.set_spacing(1);
- midi_tool_button_box.pack_start(midi_tool_pencil_button, true, true);
- midi_tool_button_box.pack_start(midi_tool_select_button, true, true);
- midi_tool_button_box.pack_start(midi_tool_resize_button, true, true);
- midi_tool_button_box.pack_start(midi_tool_erase_button , true, true);
- midi_tool_button_box.set_homogeneous(true);
-
- midi_tool_pencil_button.set_name ("MouseModeButton");
- midi_tool_select_button.set_name ("MouseModeButton");
- midi_tool_resize_button.set_name ("MouseModeButton");
- midi_tool_erase_button .set_name ("MouseModeButton");
-
ARDOUR_UI::instance()->tooltips().set_tip (midi_tool_pencil_button, _("Add/Move/Stretch Notes"));
ARDOUR_UI::instance()->tooltips().set_tip (midi_tool_select_button, _("Select/Move Notes"));
ARDOUR_UI::instance()->tooltips().set_tip (midi_tool_resize_button, _("Resize Notes"));
ARDOUR_UI::instance()->tooltips().set_tip (midi_tool_erase_button, _("Erase Notes"));
-
- midi_tool_pencil_button.unset_flags (CAN_FOCUS);
- midi_tool_select_button.unset_flags (CAN_FOCUS);
- midi_tool_resize_button.unset_flags (CAN_FOCUS);
- midi_tool_erase_button.unset_flags (CAN_FOCUS);
-
- midi_tool_pencil_button.signal_toggled().connect (bind (mem_fun(*this,
- &Editor::midi_edit_mode_toggled), Editing::MidiEditPencil));
- midi_tool_select_button.signal_toggled().connect (bind (mem_fun(*this,
- &Editor::midi_edit_mode_toggled), Editing::MidiEditSelect));
- midi_tool_resize_button.signal_toggled().connect (bind (mem_fun(*this,
- &Editor::midi_edit_mode_toggled), Editing::MidiEditResize));
- midi_tool_erase_button.signal_toggled().connect (bind (mem_fun(*this,
- &Editor::midi_edit_mode_toggled), Editing::MidiEditErase));
-
+#endif
/* Midi sound notes */
midi_sound_notes.add (*(manage (new Image (::get_icon("midi_sound_notes")))));
/* Panic */
- HBox* panic_box = manage (new HBox);
midi_panic_button.set_name("MidiPanicButton");
- midi_panic_button.signal_pressed().connect (
- mem_fun(this, &Editor::midi_panic_button_pressed));
- panic_box->pack_start (midi_sound_notes , true, true);
- panic_box->pack_start (midi_panic_button, true, true);
-
- /* Pack everything in... */
-
- midi_tools_tearoff = manage (new TearOff (midi_tool_button_box));
- midi_tools_tearoff->set_name ("MouseModeBase");
-
- /*
- midi_tools_tearoff->Detach.connect (bind (mem_fun(*this, &Editor::detach_tearoff), static_cast<Box*>(&midi_toolbar_hbox),
- &midi_tools_tearoff->tearoff_window()));
- midi_tools_tearoff->Attach.connect (bind (mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&midi_toolbar_hbox),
- &midi_tools_tearoff->tearoff_window(), 0));
- midi_tools_tearoff->Hidden.connect (bind (mem_fun(*this, &Editor::detach_tearoff), static_cast<Box*>(&midi_toolbar_hbox),
- &midi_tools_tearoff->tearoff_window()));
- midi_tools_tearoff->Visible.connect (bind (mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&midi_toolbar_hbox),
- &midi_tools_tearoff->tearoff_window(), 0));
- */
+ midi_panic_button.signal_pressed().connect (mem_fun(this, &Editor::midi_panic_button_pressed));
- midi_toolbar_hbox.set_spacing (10);
- midi_toolbar_hbox.set_border_width (1);
-
- midi_toolbar_hbox.pack_start (*midi_tools_tearoff, false, true);
-
- midi_toolbar_hbox.pack_start(*panic_box, false, true, 4);
-
- midi_tool_button_box.show_all ();
- midi_toolbar_hbox.show_all();
- midi_tools_tearoff->show_all();
-
- midi_toolbar_base.set_name ("ToolBarBase");
- midi_toolbar_base.add (midi_toolbar_hbox);
-
- midi_toolbar_frame.set_shadow_type (SHADOW_OUT);
- midi_toolbar_frame.set_name ("BaseFrame");
- midi_toolbar_frame.add (midi_toolbar_base);
+ panic_box.pack_start (midi_sound_notes , true, true);
+ panic_box.pack_start (midi_panic_button, true, true);
}
int
void
Editor::detach_tearoff (Box* /*b*/, Window* /*w*/)
{
+ cerr << "remove tearoff\n";
+
if (tools_tearoff->torn_off() &&
mouse_mode_tearoff->torn_off()) {
top_hbox.remove (toolbar_frame);
void
Editor::reattach_tearoff (Box* /*b*/, Window* /*w*/, int32_t /*n*/)
{
+ cerr << "reattach tearoff\n";
if (toolbar_frame.get_parent() == 0) {
top_hbox.pack_end (toolbar_frame);
}
void set_mouse_mode (Editing::MouseMode, bool force=true);
void step_mouse_mode (bool next);
Editing::MouseMode current_mouse_mode () const { return mouse_mode; }
-
- void set_midi_edit_cursor (Editing::MidiEditMode);
- void set_midi_edit_mode (Editing::MidiEditMode, bool force=true);
- Editing::MidiEditMode current_midi_edit_mode () const { return midi_edit_mode; }
+ Editing::MidiEditMode current_midi_edit_mode () const;
+
+ bool internal_editing() const { return _internal_editing ; }
+ void set_internal_edit (bool yn);
#ifdef WITH_CMT
void add_imageframe_time_axis(const std::string & track_name, void*) ;
void post_zoom ();
Editing::MouseMode mouse_mode;
- Editing::MidiEditMode midi_edit_mode;
-
+ bool _internal_editing;
+
int post_maximal_editor_width;
int post_maximal_pane_position;
int pre_maximal_pane_position;
Gtk::HBox mouse_mode_button_box;
Gtkmm2ext::TearOff* mouse_mode_tearoff;
- Gtk::ToggleButton mouse_select_button;
- Gtk::ToggleButton mouse_move_button;
- Gtk::ToggleButton mouse_gain_button;
- Gtk::ToggleButton mouse_zoom_button;
- Gtk::ToggleButton mouse_timefx_button;
- Gtk::ToggleButton mouse_audition_button;
- Gtk::ToggleButton mouse_note_button;
- GroupedButtons *mouse_mode_button_set;
+ Gtk::ToggleButton mouse_select_button;
+ Gtk::ToggleButton mouse_move_button;
+ Gtk::ToggleButton mouse_gain_button;
+ Gtk::ToggleButton mouse_zoom_button;
+ Gtk::ToggleButton mouse_timefx_button;
+ Gtk::ToggleButton mouse_audition_button;
+
void mouse_mode_toggled (Editing::MouseMode m);
bool ignore_mouse_mode_toggle;
+ Gtk::ToggleButton internal_edit_button;
+ void toggle_internal_editing ();
+
gint mouse_select_button_release (GdkEventButton*);
Gtk::VBox automation_box;
/* midi toolbar */
- Gtk::HBox midi_tool_button_box;
- Gtk::ToggleButton midi_tool_pencil_button;
- Gtk::ToggleButton midi_tool_select_button;
- Gtk::ToggleButton midi_tool_resize_button;
- Gtk::ToggleButton midi_tool_erase_button;
+ Gtk::HBox panic_box;
Gtk::Button midi_panic_button;
Gtk::ToggleButton midi_sound_notes;
- GroupedButtons *midi_tool_button_set;
- void midi_edit_mode_toggled (Editing::MidiEditMode m);
void midi_panic_button_pressed ();
bool sound_notes () const { return midi_sound_notes.get_active(); }
- bool ignore_midi_edit_mode_toggle;
-
- Gtkmm2ext::TearOff* midi_tools_tearoff;
- Gtk::HBox midi_toolbar_hbox;
- Gtk::EventBox midi_toolbar_base;
- Gtk::Frame midi_toolbar_frame;
-
void setup_midi_toolbar ();
/* selection process */
*/
+#include <gio/gio.h>
+#include <gtk/gtkiconfactory.h>
+
#include "ardour/ardour.h"
#include "ardour/profile.h"
Glib::RefPtr<ActionGroup> mouse_mode_actions = ActionGroup::create (X_("MouseMode"));
RadioAction::Group mouse_mode_group;
- ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-object", _("Object Tool"), bind (mem_fun(*this, &Editor::set_mouse_mode), Editing::MouseObject, false));
- ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-range", _("Range Tool"), bind (mem_fun(*this, &Editor::set_mouse_mode), Editing::MouseRange, false));
- ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-gain", _("Gain Tool"), bind (mem_fun(*this, &Editor::set_mouse_mode), Editing::MouseGain, false));
- ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-zoom", _("Zoom Tool"), bind (mem_fun(*this, &Editor::set_mouse_mode), Editing::MouseZoom, false));
- ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-timefx", _("Timefx Tool"), bind (mem_fun(*this, &Editor::set_mouse_mode), Editing::MouseTimeFX, false));
- ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-note", _("Note Tool"), bind (mem_fun(*this, &Editor::set_mouse_mode), Editing::MouseNote, false));
-
+ ARDOUR_UI::instance()->tooltips().set_tip (mouse_move_button, _("Select/Move Objects"));
+ ARDOUR_UI::instance()->tooltips().set_tip (mouse_select_button, _("Select/Move Ranges"));
+ ARDOUR_UI::instance()->tooltips().set_tip (mouse_gain_button, _("Draw Gain Automation"));
+ ARDOUR_UI::instance()->tooltips().set_tip (mouse_zoom_button, _("Select Zoom Range"));
+ ARDOUR_UI::instance()->tooltips().set_tip (mouse_timefx_button, _("Stretch/Shrink Regions"));
+ ARDOUR_UI::instance()->tooltips().set_tip (mouse_audition_button, _("Listen to Specific Regions"));
+ /* in the future, this may allow other kinds of "intra-region" editing, but for now its just MIDI */
+ ARDOUR_UI::instance()->tooltips().set_tip (internal_edit_button, _("Edit MIDI Notes"));
+
+ cerr << "Registering mouse mode actions\n";
+
+ act = ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-object", _("Object Tool"), bind (mem_fun(*this, &Editor::mouse_mode_toggled), Editing::MouseObject));
+ act->connect_proxy (mouse_move_button);
+ mouse_move_button.set_image (*(manage (new Image (::get_icon("tool_object")))));
+ mouse_move_button.set_label ("");
+ mouse_move_button.set_name ("MouseModeButton");
+
+ act = ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-range", _("Range Tool"), bind (mem_fun(*this, &Editor::mouse_mode_toggled), Editing::MouseRange));
+ act->connect_proxy (mouse_select_button);
+ mouse_select_button.set_image (*(manage (new Image (::get_xpm("tool_range.xpm")))));
+ mouse_select_button.set_label ("");
+ mouse_select_button.set_name ("MouseModeButton");
+
+ act = ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-gain", _("Gain Tool"), bind (mem_fun(*this, &Editor::mouse_mode_toggled), Editing::MouseGain));
+ act->connect_proxy (mouse_gain_button);
+ mouse_gain_button.set_image (*(manage (new Image (::get_icon("tool_gain")))));
+ mouse_gain_button.set_label ("");
+ mouse_gain_button.set_name ("MouseModeButton");
+
+ act = ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-zoom", _("Zoom Tool"), bind (mem_fun(*this, &Editor::mouse_mode_toggled), Editing::MouseZoom));
+ act->connect_proxy (mouse_zoom_button);
+ mouse_zoom_button.set_image (*(manage (new Image (::get_icon("tool_zoom")))));
+ mouse_zoom_button.set_label ("");
+ mouse_zoom_button.set_name ("MouseModeButton");
+
+ act = ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-audition", _("Audition Tool"), bind (mem_fun(*this, &Editor::mouse_mode_toggled), Editing::MouseAudition));
+ act->connect_proxy (mouse_audition_button);
+ mouse_audition_button.set_image (*(manage (new Image (::get_icon("tool_audition")))));
+ mouse_audition_button.set_label ("");
+ mouse_audition_button.set_name ("MouseModeButton");
+
+ act = ActionManager::register_radio_action (mouse_mode_actions, mouse_mode_group, "set-mouse-mode-timefx", _("Timefx Tool"), bind (mem_fun(*this, &Editor::mouse_mode_toggled), Editing::MouseTimeFX));
+ act->connect_proxy (mouse_timefx_button);
+ mouse_timefx_button.set_image (*(manage (new Image (::get_icon("tool_stretch")))));
+ mouse_timefx_button.set_label ("");
+ mouse_timefx_button.set_name ("MouseModeButton");
+
ActionManager::register_action (editor_actions, "step-mouse-mode", _("Step Mouse Mode"), bind (mem_fun(*this, &Editor::step_mouse_mode), true));
+ act = ActionManager::register_toggle_action (mouse_mode_actions, "toggle-internal-edit", _("Edit MIDI"), mem_fun(*this, &Editor::toggle_internal_editing));
+ act->connect_proxy (internal_edit_button);
+ internal_edit_button.set_image (*(manage (new Image (::get_icon("tool_note")))));
+ internal_edit_button.set_label ("");
+ internal_edit_button.set_name ("MouseModeButton");
+
RadioAction::Group edit_point_group;
ActionManager::register_radio_action (editor_actions, edit_point_group, X_("edit-at-playhead"), _("Playhead"), (bind (mem_fun(*this, &Editor::edit_point_chosen), Editing::EditAtPlayhead)));
ActionManager::register_radio_action (editor_actions, edit_point_group, X_("edit-at-mouse"), _("Mouse"), (bind (mem_fun(*this, &Editor::edit_point_chosen), Editing::EditAtPlayhead)));
}
}
+void
+Editor::toggle_internal_editing ()
+{
+ Glib::RefPtr<Gtk::Action> act = ActionManager::get_action (X_("MouseMode"), X_("toggle-internal-edit"));
+ if (act) {
+ Glib::RefPtr<Gtk::ToggleAction> tact = Glib::RefPtr<Gtk::ToggleAction>::cast_dynamic(act);
+ set_internal_edit (tact->get_active());
+ }
+}
bool
Editor::track_canvas_map_handler (GdkEventAny* /*ev*/)
{
- track_canvas->get_window()->set_cursor (*current_canvas_cursor);
+ if (current_canvas_cursor) {
+ track_canvas->get_window()->set_cursor (*current_canvas_cursor);
+ }
return false;
}
#include <algorithm>
#include "pbd/error.h"
+#include "pbd/enumwriter.h"
#include <gtkmm2ext/utils.h>
#include <gtkmm2ext/tearoff.h>
#include "pbd/memento_command.h"
#include "pbd/basename.h"
#include "ardour_ui.h"
+#include "actions.h"
#include "editor.h"
#include "time_axis_view.h"
#include "audio_time_axis.h"
return pixel_to_frame (*pcx);
}
-void
-Editor::mouse_mode_toggled (MouseMode m)
+Gdk::Cursor*
+Editor::which_grabber_cursor ()
{
- if (ignore_mouse_mode_toggle) {
- return;
- }
+ Gdk::Cursor* c = grabber_cursor;
- switch (m) {
- case MouseRange:
- if (mouse_select_button.get_active()) {
- set_mouse_mode (m);
- }
- break;
+ if (_internal_editing) {
+ switch (mouse_mode) {
+ case MouseObject:
+ c = midi_pencil_cursor;
+ break;
+
+ case MouseRange:
+ c = midi_select_cursor;
+ break;
+
+ case MouseTimeFX:
+ c = midi_resize_cursor;
+ break;
- case MouseObject:
- if (mouse_move_button.get_active()) {
- set_mouse_mode (m);
+ default:
+ break;
}
- break;
- case MouseGain:
- if (mouse_gain_button.get_active()) {
- set_mouse_mode (m);
- }
- break;
+ } else {
- case MouseZoom:
- if (mouse_zoom_button.get_active()) {
- set_mouse_mode (m);
+ switch (_edit_point) {
+ case EditAtMouse:
+ c = grabber_edit_point_cursor;
+ break;
+ default:
+ break;
}
- break;
+ }
- case MouseTimeFX:
- if (mouse_timefx_button.get_active()) {
- set_mouse_mode (m);
- }
- break;
+ return c;
+}
- case MouseAudition:
- if (mouse_audition_button.get_active()) {
- set_mouse_mode (m);
- }
- break;
-
- case MouseNote:
- if (mouse_note_button.get_active()) {
- set_mouse_mode (m);
+void
+Editor::set_canvas_cursor ()
+{
+ if (_internal_editing) {
+
+ switch (mouse_mode) {
+ case MouseObject:
+ current_canvas_cursor = midi_pencil_cursor;
+ break;
+
+ case MouseRange:
+ current_canvas_cursor = midi_select_cursor;
+ break;
+
+ case MouseTimeFX:
+ current_canvas_cursor = midi_resize_cursor;
+ break;
+
+ default:
+ return;
}
- break;
- default:
- break;
+ } else {
+
+ switch (mouse_mode) {
+ case MouseRange:
+ current_canvas_cursor = selector_cursor;
+ break;
+
+ case MouseObject:
+ current_canvas_cursor = which_grabber_cursor();
+ break;
+
+ case MouseGain:
+ current_canvas_cursor = cross_hair_cursor;
+ break;
+
+ case MouseZoom:
+ current_canvas_cursor = zoom_cursor;
+ break;
+
+ case MouseTimeFX:
+ current_canvas_cursor = time_fx_cursor; // just use playhead
+ break;
+
+ case MouseAudition:
+ current_canvas_cursor = speaker_cursor;
+ break;
+ }
}
-}
-Gdk::Cursor*
-Editor::which_grabber_cursor ()
-{
- switch (_edit_point) {
- case EditAtMouse:
- return grabber_edit_point_cursor;
- break;
- default:
- break;
+ if (is_drawable()) {
+ track_canvas->get_window()->set_cursor(*current_canvas_cursor);
}
- return grabber_cursor;
}
void
-Editor::set_canvas_cursor ()
+Editor::set_mouse_mode (MouseMode m, bool force)
{
- switch (mouse_mode) {
+ if (_drag) {
+ return;
+ }
+
+ if (!force && m == mouse_mode) {
+ return;
+ }
+
+ Glib::RefPtr<Action> act;
+
+ switch (m) {
case MouseRange:
- current_canvas_cursor = selector_cursor;
+ act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-range"));
break;
case MouseObject:
- current_canvas_cursor = which_grabber_cursor();
+ act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-object"));
break;
case MouseGain:
- current_canvas_cursor = cross_hair_cursor;
+ act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-gain"));
break;
case MouseZoom:
- current_canvas_cursor = zoom_cursor;
+ act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-zoom"));
break;
case MouseTimeFX:
- current_canvas_cursor = time_fx_cursor; // just use playhead
+ act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-timefx"));
break;
case MouseAudition:
- current_canvas_cursor = speaker_cursor;
- break;
-
- case MouseNote:
- set_midi_edit_cursor (current_midi_edit_mode());
+ act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-audition"));
break;
}
- if (is_drawable()) {
- track_canvas->get_window()->set_cursor(*current_canvas_cursor);
- }
+ assert (act);
+
+ Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
+ assert (tact);
+ tact->set_active (true);
}
void
-Editor::set_mouse_mode (MouseMode m, bool force)
+Editor::mouse_mode_toggled (MouseMode m)
{
- if (_drag) {
- return;
- }
-
- if (!force && m == mouse_mode) {
- return;
- }
-
mouse_mode = m;
instant_save ();
}
}
- /* XXX the hack of unsetting all other buttons should go
- away once GTK2 allows us to use regular radio buttons drawn like
- normal buttons, rather than my silly GroupedButton hack.
- */
-
- ignore_mouse_mode_toggle = true;
-
- switch (mouse_mode) {
- case MouseRange:
- mouse_select_button.set_active (true);
- break;
-
- case MouseObject:
- mouse_move_button.set_active (true);
- break;
-
- case MouseGain:
- mouse_gain_button.set_active (true);
- break;
-
- case MouseZoom:
- mouse_zoom_button.set_active (true);
- break;
-
- case MouseTimeFX:
- mouse_timefx_button.set_active (true);
- break;
-
- case MouseAudition:
- mouse_audition_button.set_active (true);
- break;
-
- case MouseNote:
- mouse_note_button.set_active (true);
- set_midi_edit_cursor (current_midi_edit_mode());
- break;
- }
-
- if (midi_tools_tearoff) {
- if (mouse_mode == MouseNote) {
- midi_tools_tearoff->show();
- } else {
- midi_tools_tearoff->hide();
- }
- }
-
- ignore_mouse_mode_toggle = false;
-
set_canvas_cursor ();
}
if (next) set_mouse_mode (MouseObject);
else set_mouse_mode (MouseTimeFX);
break;
-
- case MouseNote:
- if (next) set_mouse_mode (MouseObject);
- else set_mouse_mode (MouseAudition);
- break;
- }
-}
-
-void
-Editor::midi_edit_mode_toggled (MidiEditMode m)
-{
- if (ignore_midi_edit_mode_toggle) {
- return;
- }
-
- switch (m) {
- case MidiEditPencil:
- if (midi_tool_pencil_button.get_active())
- set_midi_edit_mode (m);
- break;
-
- case MidiEditSelect:
- if (midi_tool_select_button.get_active())
- set_midi_edit_mode (m);
- break;
-
- case MidiEditResize:
- if (midi_tool_resize_button.get_active())
- set_midi_edit_mode (m);
- break;
-
- case MidiEditErase:
- if (midi_tool_erase_button.get_active())
- set_midi_edit_mode (m);
- break;
-
- default:
- break;
- }
-
- set_midi_edit_cursor(m);
-}
-
-
-void
-Editor::set_midi_edit_mode (MidiEditMode m, bool force)
-{
- if (_drag) {
- return;
- }
-
- if (!force && m == midi_edit_mode) {
- return;
- }
-
- midi_edit_mode = m;
-
- instant_save ();
-
- ignore_midi_edit_mode_toggle = true;
-
- switch (midi_edit_mode) {
- case MidiEditPencil:
- midi_tool_pencil_button.set_active (true);
- break;
-
- case MidiEditSelect:
- midi_tool_select_button.set_active (true);
- break;
-
- case MidiEditResize:
- midi_tool_resize_button.set_active (true);
- break;
-
- case MidiEditErase:
- midi_tool_erase_button.set_active (true);
- break;
- }
-
- ignore_midi_edit_mode_toggle = false;
-
- set_midi_edit_cursor (current_midi_edit_mode());
-
- if (is_drawable()) {
- track_canvas->get_window()->set_cursor(*current_canvas_cursor);
- }
-}
-
-void
-Editor::set_midi_edit_cursor (MidiEditMode)
-{
- switch (midi_edit_mode) {
- case MidiEditPencil:
- current_canvas_cursor = midi_pencil_cursor;
- break;
-
- case MidiEditSelect:
- current_canvas_cursor = midi_select_cursor;
- break;
-
- case MidiEditResize:
- current_canvas_cursor = midi_resize_cursor;
- break;
-
- case MidiEditErase:
- current_canvas_cursor = midi_erase_cursor;
- break;
}
}
}
}
- switch (mouse_mode) {
- case MouseRange:
- switch (item_type) {
- case StartSelectionTrimItem:
- assert (_drag == 0);
- _drag = new SelectionDrag (this, item, SelectionDrag::SelectionStartTrim);
- _drag->start_grab (event);
- break;
+ if (internal_editing()) {
+ assert (_drag == 0);
+ _drag = new RegionCreateDrag (this, item, clicked_axisview);
+ _drag->start_grab (event);
+ cerr << "--- DRAG START FOR RCD\n";
+ } else {
+ switch (mouse_mode) {
+ case MouseRange:
+ switch (item_type) {
+ case StartSelectionTrimItem:
+ assert (_drag == 0);
+ _drag = new SelectionDrag (this, item, SelectionDrag::SelectionStartTrim);
+ _drag->start_grab (event);
+ break;
- case EndSelectionTrimItem:
- assert (_drag == 0);
- _drag = new SelectionDrag (this, item, SelectionDrag::SelectionEndTrim);
- _drag->start_grab (event);
- break;
-
- case SelectionItem:
- if (Keyboard::modifier_state_contains
- (event->button.state, Keyboard::ModifierMask(Keyboard::SecondaryModifier))) {
- // contains and not equals because I can't use alt as a modifier alone.
- start_selection_grab (item, event);
- } else if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
- /* grab selection for moving */
+ case EndSelectionTrimItem:
assert (_drag == 0);
- _drag = new SelectionDrag (this, item, SelectionDrag::SelectionMove);
+ _drag = new SelectionDrag (this, item, SelectionDrag::SelectionEndTrim);
_drag->start_grab (event);
- } else {
- /* this was debated, but decided the more common action was to
- make a new selection */
+ break;
+
+ case SelectionItem:
+ if (Keyboard::modifier_state_contains
+ (event->button.state, Keyboard::ModifierMask(Keyboard::SecondaryModifier))) {
+ // contains and not equals because I can't use alt as a modifier alone.
+ start_selection_grab (item, event);
+ } else if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
+ /* grab selection for moving */
+ assert (_drag == 0);
+ _drag = new SelectionDrag (this, item, SelectionDrag::SelectionMove);
+ _drag->start_grab (event);
+ } else {
+ /* this was debated, but decided the more common action was to
+ make a new selection */
+ assert (_drag == 0);
+ _drag = new SelectionDrag (this, item, SelectionDrag::CreateSelection);
+ _drag->start_grab (event);
+ }
+ break;
+
+ default:
assert (_drag == 0);
_drag = new SelectionDrag (this, item, SelectionDrag::CreateSelection);
_drag->start_grab (event);
}
+ return true;
break;
-
- default:
- assert (_drag == 0);
- _drag = new SelectionDrag (this, item, SelectionDrag::CreateSelection);
- _drag->start_grab (event);
- }
- return true;
- break;
- case MouseObject:
- if (Keyboard::modifier_state_contains (event->button.state, Keyboard::ModifierMask(Keyboard::PrimaryModifier|Keyboard::SecondaryModifier)) &&
- event->type == GDK_BUTTON_PRESS) {
-
- assert (_drag == 0);
- _drag = new RubberbandSelectDrag (this, item);
- _drag->start_grab (event);
+ case MouseObject:
+ if (Keyboard::modifier_state_contains (event->button.state, Keyboard::ModifierMask(Keyboard::PrimaryModifier|Keyboard::SecondaryModifier)) &&
+ event->type == GDK_BUTTON_PRESS) {
- } else if (event->type == GDK_BUTTON_PRESS) {
-
- switch (item_type) {
- case FadeInHandleItem:
- {
assert (_drag == 0);
- RegionSelection s = get_equivalent_regions (selection->regions, RouteGroup::Edit);
- _drag = new FadeInDrag (this, item, reinterpret_cast<RegionView*> (item->get_data("regionview")), s);
+ _drag = new RubberbandSelectDrag (this, item);
_drag->start_grab (event);
- return true;
- }
+
+ } else if (event->type == GDK_BUTTON_PRESS) {
+
+ switch (item_type) {
+ case FadeInHandleItem:
+ {
+ assert (_drag == 0);
+ RegionSelection s = get_equivalent_regions (selection->regions, RouteGroup::Edit);
+ _drag = new FadeInDrag (this, item, reinterpret_cast<RegionView*> (item->get_data("regionview")), s);
+ _drag->start_grab (event);
+ return true;
+ }
- case FadeOutHandleItem:
- {
- assert (_drag == 0);
- RegionSelection s = get_equivalent_regions (selection->regions, RouteGroup::Edit);
- _drag = new FadeOutDrag (this, item, reinterpret_cast<RegionView*> (item->get_data("regionview")), s);
- _drag->start_grab (event);
- return true;
- }
+ case FadeOutHandleItem:
+ {
+ assert (_drag == 0);
+ RegionSelection s = get_equivalent_regions (selection->regions, RouteGroup::Edit);
+ _drag = new FadeOutDrag (this, item, reinterpret_cast<RegionView*> (item->get_data("regionview")), s);
+ _drag->start_grab (event);
+ return true;
+ }
- case RegionItem:
- if (Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier)) {
- start_region_copy_grab (item, event, clicked_regionview);
- } else if (Keyboard::the_keyboard().key_is_down (GDK_b)) {
- start_region_brush_grab (item, event, clicked_regionview);
- } else {
- start_region_grab (item, event, clicked_regionview);
+ case RegionItem:
+ if (Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier)) {
+ start_region_copy_grab (item, event, clicked_regionview);
+ } else if (Keyboard::the_keyboard().key_is_down (GDK_b)) {
+ start_region_brush_grab (item, event, clicked_regionview);
+ } else {
+ start_region_grab (item, event, clicked_regionview);
+ }
+ break;
+
+ case RegionViewNameHighlight:
+ {
+ assert (_drag == 0);
+ RegionSelection s = get_equivalent_regions (selection->regions, RouteGroup::Edit);
+ _drag = new TrimDrag (this, item, clicked_regionview, s.by_layer());
+ _drag->start_grab (event);
+ return true;
+ break;
}
- break;
- case RegionViewNameHighlight:
- {
+ case RegionViewName:
+ {
+ /* rename happens on edit clicks */
+ assert (_drag == 0);
+ RegionSelection s = get_equivalent_regions (selection->regions, RouteGroup::Edit);
+ _drag = new TrimDrag (this, clicked_regionview->get_name_highlight(), clicked_regionview, s.by_layer());
+ _drag->start_grab (event);
+ return true;
+ break;
+ }
+
+ case ControlPointItem:
+ assert (_drag == 0);
+ _drag = new ControlPointDrag (this, item);
+ _drag->start_grab (event);
+ return true;
+ break;
+
+ case AutomationLineItem:
+ assert (_drag == 0);
+ _drag = new LineDrag (this, item);
+ _drag->start_grab (event);
+ return true;
+ break;
+
+ case StreamItem:
+ case AutomationTrackItem:
+ assert (_drag == 0);
+ _drag = new RubberbandSelectDrag (this, item);
+ _drag->start_grab (event);
+ break;
+
+#ifdef WITH_CMT
+ case ImageFrameHandleStartItem:
+ imageframe_start_handle_op(item, event) ;
+ return(true) ;
+ break ;
+ case ImageFrameHandleEndItem:
+ imageframe_end_handle_op(item, event) ;
+ return(true) ;
+ break ;
+ case MarkerViewHandleStartItem:
+ markerview_item_start_handle_op(item, event) ;
+ return(true) ;
+ break ;
+ case MarkerViewHandleEndItem:
+ markerview_item_end_handle_op(item, event) ;
+ return(true) ;
+ break ;
+ case MarkerViewItem:
+ start_markerview_grab(item, event) ;
+ break ;
+ case ImageFrameItem:
+ start_imageframe_grab(item, event) ;
+ break ;
+#endif
+
+ case MarkerBarItem:
+
+ break;
+
+ default:
+ break;
+ }
+ }
+ return true;
+ break;
+
+ case MouseGain:
+ switch (item_type) {
+ case RegionItem:
+ /* start a grab so that if we finish after moving
+ we can tell what happened.
+ */
assert (_drag == 0);
- RegionSelection s = get_equivalent_regions (selection->regions, RouteGroup::Edit);
- _drag = new TrimDrag (this, item, clicked_regionview, s.by_layer());
- _drag->start_grab (event);
- return true;
+ _drag = new RegionGainDrag (this, item);
+ _drag->start_grab (event, current_canvas_cursor);
break;
- }
-
- case RegionViewName:
- {
- /* rename happens on edit clicks */
+
+ case GainLineItem:
assert (_drag == 0);
- RegionSelection s = get_equivalent_regions (selection->regions, RouteGroup::Edit);
- _drag = new TrimDrag (this, clicked_regionview->get_name_highlight(), clicked_regionview, s.by_layer());
+ _drag = new LineDrag (this, item);
_drag->start_grab (event);
return true;
- break;
- }
case ControlPointItem:
assert (_drag == 0);
_drag->start_grab (event);
return true;
break;
-
- case AutomationLineItem:
+
+ default:
+ break;
+ }
+ return true;
+ break;
+
+ switch (item_type) {
+ case ControlPointItem:
assert (_drag == 0);
- _drag = new LineDrag (this, item);
+ _drag = new ControlPointDrag (this, item);
_drag->start_grab (event);
- return true;
break;
- case StreamItem:
- case AutomationTrackItem:
+ case AutomationLineItem:
assert (_drag == 0);
- _drag = new RubberbandSelectDrag (this, item);
+ _drag = new LineDrag (this, item);
_drag->start_grab (event);
break;
-
-#ifdef WITH_CMT
- case ImageFrameHandleStartItem:
- imageframe_start_handle_op(item, event) ;
- return(true) ;
- break ;
- case ImageFrameHandleEndItem:
- imageframe_end_handle_op(item, event) ;
- return(true) ;
- break ;
- case MarkerViewHandleStartItem:
- markerview_item_start_handle_op(item, event) ;
- return(true) ;
- break ;
- case MarkerViewHandleEndItem:
- markerview_item_end_handle_op(item, event) ;
- return(true) ;
- break ;
- case MarkerViewItem:
- start_markerview_grab(item, event) ;
- break ;
- case ImageFrameItem:
- start_imageframe_grab(item, event) ;
- break ;
-#endif
- case MarkerBarItem:
-
+ case RegionItem:
+ // XXX need automation mode to identify which
+ // line to use
+ // start_line_grab_from_regionview (item, event);
break;
default:
break;
}
- }
- return true;
- break;
-
- case MouseGain:
- switch (item_type) {
- case RegionItem:
- /* start a grab so that if we finish after moving
- we can tell what happened.
- */
- assert (_drag == 0);
- _drag = new RegionGainDrag (this, item);
- _drag->start_grab (event, current_canvas_cursor);
+ return true;
break;
- case GainLineItem:
- assert (_drag == 0);
- _drag = new LineDrag (this, item);
- _drag->start_grab (event);
- return true;
+ case MouseZoom:
+ if (event->type == GDK_BUTTON_PRESS) {
+ assert (_drag == 0);
+ _drag = new MouseZoomDrag (this, item);
+ _drag->start_grab (event);
+ }
- case ControlPointItem:
- assert (_drag == 0);
- _drag = new ControlPointDrag (this, item);
- _drag->start_grab (event);
return true;
break;
- default:
- break;
- }
- return true;
- break;
-
- switch (item_type) {
- case ControlPointItem:
- assert (_drag == 0);
- _drag = new ControlPointDrag (this, item);
- _drag->start_grab (event);
+ case MouseTimeFX:
+ if (item_type == RegionItem) {
+ assert (_drag == 0);
+ _drag = new TimeFXDrag (this, item, clicked_regionview, selection->regions.by_layer());
+ _drag->start_grab (event);
+ }
break;
- case AutomationLineItem:
- assert (_drag == 0);
- _drag = new LineDrag (this, item);
+ case MouseAudition:
+ _drag = new ScrubDrag (this, item);
_drag->start_grab (event);
- break;
-
- case RegionItem:
- // XXX need automation mode to identify which
- // line to use
- // start_line_grab_from_regionview (item, event);
+ scrub_reversals = 0;
+ scrub_reverse_distance = 0;
+ last_scrub_x = event->button.x;
+ scrubbing_direction = 0;
+ track_canvas->get_window()->set_cursor (*transparent_cursor);
break;
default:
break;
}
- return true;
- break;
-
- case MouseZoom:
- if (event->type == GDK_BUTTON_PRESS) {
- assert (_drag == 0);
- _drag = new MouseZoomDrag (this, item);
- _drag->start_grab (event);
- }
-
- return true;
- break;
-
- case MouseTimeFX:
- if (item_type == RegionItem) {
- assert (_drag == 0);
- _drag = new TimeFXDrag (this, item, clicked_regionview, selection->regions.by_layer());
- _drag->start_grab (event);
- }
- break;
-
- case MouseAudition:
- _drag = new ScrubDrag (this, item);
- _drag->start_grab (event);
- scrub_reversals = 0;
- scrub_reverse_distance = 0;
- last_scrub_x = event->button.x;
- scrubbing_direction = 0;
- track_canvas->get_window()->set_cursor (*transparent_cursor);
- break;
-
- case MouseNote:
- assert (_drag == 0);
- _drag = new RegionCreateDrag (this, item, clicked_axisview);
- _drag->start_grab (event);
- break;
-
- default:
- break;
}
break;
bool const r = _drag->end_grab (event);
delete _drag;
_drag = 0;
+ cerr << "DRAG DONE, r = " << r << endl;
if (r) {
/* grab dragged, so do nothing else */
return true;
_drag->break_drag ();
}
}
+
+void
+Editor::set_internal_edit (bool yn)
+{
+ _internal_editing = yn;
+ set_canvas_cursor ();
+}
bool
MidiRegionView::canvas_event(GdkEvent* ev)
{
+ PublicEditor& editor (trackview.editor());
+
+ if (!editor.internal_editing()) {
+ return false;
+ }
+
static double drag_start_x, drag_start_y;
static double last_x, last_y;
double event_x, event_y;
static ArdourCanvas::SimpleRect* drag_rect = NULL;
- if (trackview.editor().current_mouse_mode() != MouseNote)
- return false;
-
- const Editing::MidiEditMode midi_edit_mode = trackview.editor().current_midi_edit_mode();
-
switch (ev->type) {
case GDK_KEY_PRESS:
if (ev->key.keyval == GDK_Shift_L || ev->key.keyval == GDK_Control_L) {
case Pressed: // Drag start
// Select drag start
- if (_pressed_button == 1 && midi_edit_mode == MidiEditSelect) {
+ if (_pressed_button == 1 && editor.current_mouse_mode() == MouseRange) {
group->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
Gdk::Cursor(Gdk::FLEUR), ev->motion.time);
last_x = event_x;
return true;
// Add note drag start
- } else if (midi_edit_mode == MidiEditPencil) {
+ } else if (editor.current_mouse_mode() == MouseObject) {
group->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
Gdk::Cursor(Gdk::FLEUR), ev->motion.time);
last_x = event_x;
switch (_mouse_state) {
case Pressed: // Clicked
- switch (midi_edit_mode) {
- case MidiEditSelect:
- case MidiEditResize:
+ switch (editor.current_mouse_mode()) {
+ case MouseRange:
+ case MouseTimeFX:
clear_selection();
break;
- case MidiEditPencil:
+ case MouseObject:
create_note_at(event_x, event_y, _default_note_length);
default: break;
}
* (defined in editing_syms.h)
*/
virtual Editing::MouseMode current_mouse_mode () const = 0;
+
+ /** Switch into a mode in which editing is primarily focused on "within" regions,
+ rather than regions as black-box objects. For Ardour3, this is aimed at
+ editing MIDI regions but may expand in the future to other types of regions.
+ */
- /** Set the midi edit mode (pencil, select, eraser, etc.)
- * @param m Midi edit mode (defined in editing_syms.h)
- * @param force Perform the effects of the change even if no change is required
- * (ie even if the current midi edit mode is equal to \ref m)
- */
- virtual void set_midi_edit_mode (Editing::MidiEditMode m, bool force = false) = 0;
-
- /** @return The current mouse mode (gain, object, range, timefx etc.)
- * (defined in editing_syms.h)
+ virtual void set_internal_edit (bool yn) = 0;
+
+ /** @return Whether editing is currently in "internal" mode or not
*/
- virtual Editing::MidiEditMode current_midi_edit_mode () const = 0;
-
+
+ virtual bool internal_editing() const = 0;
+
/** @return Sound edited notes in MIDI regions while editing
*/
virtual bool sound_notes () const = 0;
return xpm_map[name];
}
-
-Glib::RefPtr<Gdk::Pixbuf>
-get_icon (const char* cname)
+Glib::ustring
+get_icon_path (const char* cname)
{
string name = cname;
name += X_(".png");
fatal << string_compose (_("cannot find icon image for %1"), name) << endmsg;
}
+ return data_file_path.to_string();
+}
+
+Glib::RefPtr<Gdk::Pixbuf>
+get_icon (const char* cname)
+{
Glib::RefPtr<Gdk::Pixbuf> img;
try {
- img = Gdk::Pixbuf::create_from_file (data_file_path.to_string());
+ img = Gdk::Pixbuf::create_from_file (get_icon_path (cname));
} catch (const Gdk::PixbufError &e) {
cerr << "Caught PixbufError: " << e.what() << endl;
} catch (...) {
bool possibly_translate_keyval_to_make_legal_accelerator (uint32_t& keyval);
Glib::RefPtr<Gdk::Pixbuf> get_xpm (std::string);
+Glib::ustring get_icon_path (const char*);
Glib::RefPtr<Gdk::Pixbuf> get_icon (const char*);
static std::map<std::string, Glib::RefPtr<Gdk::Pixbuf> > xpm_map;
const char* const *get_xpm_data (std::string path);
void attach_buffers(PortSet& ports, nframes_t nframes, nframes_t offset = 0);
+ /* the capacity here is a size_t and has a different interpretation depending
+ on the DataType of the buffers. for audio, its a frame count. for MIDI
+ its a byte count.
+ */
+
void ensure_buffers(DataType type, size_t num_buffers, size_t buffer_capacity);
void ensure_buffers(const ChanCount& chns, size_t buffer_capacity);
void run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame, nframes_t nframes);
bool feeds (boost::shared_ptr<Route> other) const;
bool can_support_io_configuration (const ChanCount& in, ChanCount& out) const;
+ bool configure_io (ChanCount in, ChanCount out);
+ void set_block_size (nframes_t);
boost::shared_ptr<Route> target_route() const { return _send_to; }
private:
+ BufferSet mixbufs;
BufferSet* target;
boost::shared_ptr<Route> _send_to;
PBD::ID _send_to_id;
// we have to copy the input, because we may alter the buffers with the amp
// in-place, which a send must never do.
- BufferSet& sendbufs = _session.get_mix_buffers (bufs.count());
- sendbufs.read_from (bufs, nframes);
- assert(sendbufs.count() == bufs.count());
-
+ assert(mixbufs.available() >= bufs.count());
+ mixbufs.read_from (bufs, nframes);
+
/* gain control */
gain_t tgain = target_gain ();
/* target gain has changed */
- Amp::apply_gain (sendbufs, nframes, _current_gain, tgain);
+ Amp::apply_gain (mixbufs, nframes, _current_gain, tgain);
_current_gain = tgain;
} else if (tgain == 0.0) {
*/
_meter->reset ();
- Amp::apply_simple_gain (sendbufs, nframes, 0.0);
+ Amp::apply_simple_gain (mixbufs, nframes, 0.0);
goto out;
} else if (tgain != 1.0) {
/* target gain has not changed, but is not zero or unity */
- Amp::apply_simple_gain (sendbufs, nframes, tgain);
+ Amp::apply_simple_gain (mixbufs, nframes, tgain);
}
// so that we don't overwrite the main automation data for the route amp
// _amp->setup_gain_automation (start_frame, end_frame, nframes);
- _amp->run (sendbufs, start_frame, end_frame, nframes);
+ _amp->run (mixbufs, start_frame, end_frame, nframes);
/* XXX NEED TO PAN */
if (_amp->gain_control()->get_value() == 0) {
_meter->reset();
} else {
- _meter->run (sendbufs, start_frame, end_frame, nframes);
+ _meter->run (mixbufs, start_frame, end_frame, nframes);
}
}
/* deliver to target */
- target->merge_from (sendbufs, nframes);
+ target->merge_from (mixbufs, nframes);
out:
_active = _pending_active;
}
+void
+InternalSend::set_block_size (nframes_t nframes)
+{
+ mixbufs.ensure_buffers (_configured_input, nframes);
+}
+
bool
InternalSend::feeds (boost::shared_ptr<Route> other) const
{
return true;
}
+bool
+InternalSend::configure_io (ChanCount in, ChanCount out)
+{
+ bool ret = Send::configure_io (in, out);
+ set_block_size (_session.get_block_size());
+ return ret;
+}
+
bool
InternalSend::set_name (const std::string& str)
{
}
- // XXX: do we want to emit the signal here ? change call order.
- processor->activate ();
+ if (_control_outs != processor) {
+ // XXX: do we want to emit the signal here ? change call order.
+ processor->activate ();
+ }
processor->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
_output->set_user_latency (0);
#include "ardour/cycle_timer.h"
#include "ardour/data_type.h"
#include "ardour/filename_extensions.h"
+#include "ardour/internal_send.h"
#include "ardour/io_processor.h"
#include "ardour/midi_diskstream.h"
#include "ardour/midi_playlist.h"
*/
#include <cmath>
+#include <iostream>
#include <gtkmm2ext/tearoff.h>
#include <gtkmm2ext/utils.h>
own_window.set_name (get_name());
close_event_box.set_name (get_name());
own_window.show_all ();
+ own_window.present ();
+ std::cerr << "own window should be visible\n";
hide ();
Detach ();
}
projects / ardour.git / commitdiff