ardour/ardour
ardour
/
ardour
13
1
Fork 0
Code Pull Requests Releases Activity

remove all MIDI-specific editing modes by making standard work either at object level or within (e.g. notes, etc) ; make tool buttons proxies for GtkActions ; internal sends have their own BufferSet now, instead of using Session ones; don't make internal sends to the monitor bus active when added to the Route 

git-svn-id: svn://localhost/ardour2/branches/3.0@5434 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
Paul Davis 2009-07-28 20:51:28 +00:00
parent 5eaf61242f
commit 3ae28868ff
19 changed files with 556 additions and 722 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
gtk2_ardour/canvas-note-event.cc
View File

@ -212,6 +212,12 @@ CanvasNoteEvent::base_color()
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;
@ -220,13 +226,6 @@ CanvasNoteEvent::on_event(GdkEvent* ev)
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)) {
@ -286,8 +285,7 @@ CanvasNoteEvent::on_event(GdkEvent* ev)
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;
@ -355,7 +353,7 @@ CanvasNoteEvent::on_event(GdkEvent* ev)
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);
@ -364,10 +362,12 @@ CanvasNoteEvent::on_event(GdkEvent* ev)
} 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;

9
gtk2_ardour/canvas-note.cc
View File

@ -11,16 +11,21 @@ namespace Canvas {
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;

19
gtk2_ardour/editing.cc
View File

@ -115,25 +115,6 @@ const char *mousemodestrs[] = {
#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;}

6
gtk2_ardour/editing_syms.h
View File

@ -59,12 +59,6 @@ MOUSEMODE(MouseRange)
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)

218
gtk2_ardour/editor.cc
View File

@ -211,50 +211,47 @@ show_me_the_size (Requisition* r, const char* what)
}
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;
@ -328,8 +325,6 @@ Editor::Editor ()
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;
@ -363,9 +358,9 @@ Editor::Editor ()
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 ();
@ -589,7 +584,6 @@ Editor::Editor ()
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);
@ -616,6 +610,7 @@ Editor::Editor ()
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);
@ -2785,36 +2780,13 @@ Editor::setup_toolbar ()
/* 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);
@ -2830,7 +2802,7 @@ Editor::setup_toolbar ()
}
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;
@ -2863,21 +2835,21 @@ Editor::setup_toolbar ()
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);
@ -2885,20 +2857,7 @@ Editor::setup_toolbar ()
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 */
@ -3000,11 +2959,10 @@ Editor::setup_toolbar ()
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 ();
@ -3027,12 +2985,7 @@ Editor::midi_panic_button_pressed ()
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);
@ -3046,42 +2999,11 @@ Editor::setup_midi_toolbar ()
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")))));
@ -3091,46 +3013,11 @@ Editor::setup_midi_toolbar ()
/* 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_panic_button.signal_pressed().connect (mem_fun(this, &Editor::midi_panic_button_pressed));
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_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
@ -3812,6 +3699,8 @@ Editor::pane_allocation_handler (Allocation &alloc, Paned* which)
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);
@ -3821,6 +3710,7 @@ Editor::detach_tearoff (Box* /*b*/, Window* /*w*/)
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);
}

45
gtk2_ardour/editor.h
View File

@ -184,10 +184,10 @@ class Editor : public PublicEditor
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*) ;
@ -467,8 +467,8 @@ class Editor : public PublicEditor
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;
@ -1513,17 +1513,19 @@ public:
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;
@ -1578,25 +1580,12 @@ public:
/* 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 */

70
gtk2_ardour/editor_actions.cc
View File

@ -17,6 +17,9 @@
*/
#include <gio/gio.h>
#include <gtk/gtkiconfactory.h>
#include "ardour/ardour.h"
#include "ardour/profile.h"
@ -661,15 +664,61 @@ Editor::register_actions ()
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)));
@ -1342,3 +1391,12 @@ Editor::reset_canvas_action_sensitivity (bool onoff)
}
}
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());
}
}

4
gtk2_ardour/editor_canvas.cc
View File

@ -432,7 +432,9 @@ Editor::controls_layout_size_request (Requisition* req)
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;
}

777
gtk2_ardour/editor_mouse.cc
View File

@ -26,12 +26,14 @@
#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"
@ -163,105 +165,92 @@ Editor::event_frame (GdkEvent const * event, double* pcx, double* pcy) const
return pixel_to_frame (*pcx);
}
void
Editor::mouse_mode_toggled (MouseMode m)
{
if (ignore_mouse_mode_toggle) {
return;
}
switch (m) {
case MouseRange:
if (mouse_select_button.get_active()) {
set_mouse_mode (m);
}
break;
case MouseObject:
if (mouse_move_button.get_active()) {
set_mouse_mode (m);
}
break;
case MouseGain:
if (mouse_gain_button.get_active()) {
set_mouse_mode (m);
}
break;
case MouseZoom:
if (mouse_zoom_button.get_active()) {
set_mouse_mode (m);
}
break;
case MouseTimeFX:
if (mouse_timefx_button.get_active()) {
set_mouse_mode (m);
}
break;
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);
}
break;
default:
break;
}
}
Gdk::Cursor*
Editor::which_grabber_cursor ()
{
switch (_edit_point) {
case EditAtMouse:
return grabber_edit_point_cursor;
break;
default:
break;
Gdk::Cursor* c = grabber_cursor;
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;
default:
break;
}
} else {
switch (_edit_point) {
case EditAtMouse:
c = grabber_edit_point_cursor;
break;
default:
break;
}
}
return grabber_cursor;
return c;
}
void
Editor::set_canvas_cursor ()
{
switch (mouse_mode) {
case MouseRange:
current_canvas_cursor = selector_cursor;
break;
if (_internal_editing) {
case MouseObject:
current_canvas_cursor = which_grabber_cursor();
break;
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;
case MouseGain:
current_canvas_cursor = cross_hair_cursor;
break;
default:
return;
}
case MouseZoom:
current_canvas_cursor = zoom_cursor;
break;
} else {
case MouseTimeFX:
current_canvas_cursor = time_fx_cursor; // just use playhead
break;
case MouseAudition:
current_canvas_cursor = speaker_cursor;
break;
case MouseNote:
set_midi_edit_cursor (current_midi_edit_mode());
break;
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;
}
}
if (is_drawable()) {
@ -279,7 +268,45 @@ Editor::set_mouse_mode (MouseMode m, bool force)
if (!force && m == mouse_mode) {
return;
}
Glib::RefPtr<Action> act;
switch (m) {
case MouseRange:
act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-range"));
break;
case MouseObject:
act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-object"));
break;
case MouseGain:
act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-gain"));
break;
case MouseZoom:
act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-zoom"));
break;
case MouseTimeFX:
act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-timefx"));
break;
case MouseAudition:
act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-audition"));
break;
}
assert (act);
Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
assert (tact);
tact->set_active (true);
}
void
Editor::mouse_mode_toggled (MouseMode m)
{
mouse_mode = m;
instant_save ();
@ -310,54 +337,6 @@ Editor::set_mouse_mode (MouseMode m, bool force)
}
}
/* 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 ();
}
@ -419,113 +398,6 @@ Editor::step_mouse_mode (bool next)
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;
}
}
@ -766,107 +638,187 @@ Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemTyp
}
}
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 */
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::SelectionMove);
_drag = new SelectionDrag (this, item, SelectionDrag::SelectionStartTrim);
_drag->start_grab (event);
} else {
/* this was debated, but decided the more common action was to
make a new selection */
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 */
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) {
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);
} 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;
}
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);
} 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;
}
break;
case RegionViewNameHighlight:
{
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);
}
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;
}
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 = new RegionGainDrag (this, item);
_drag->start_grab (event, current_canvas_cursor);
break;
case GainLineItem:
assert (_drag == 0);
_drag = new LineDrag (this, item);
_drag->start_grab (event);
return true;
break;
}
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);
@ -874,148 +826,69 @@ Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemTyp
_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);
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:
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;
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;
default:
break;
}
return true;
break;
switch (item_type) {
case ControlPointItem:
assert (_drag == 0);
_drag = new ControlPointDrag (this, item);
_drag->start_grab (event);
break;
case AutomationLineItem:
assert (_drag == 0);
_drag = new LineDrag (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);
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;
@ -1119,6 +992,7 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT
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;
@ -2669,3 +2543,10 @@ Editor::break_drag ()
_drag->break_drag ();
}
}
void
Editor::set_internal_edit (bool yn)
{
_internal_editing = yn;
set_canvas_cursor ();
}

23
gtk2_ardour/midi_region_view.cc
View File

@ -195,6 +195,12 @@ MidiRegionView::init (Gdk::Color const & basic_color, bool wfd)
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;
@ -202,11 +208,6 @@ MidiRegionView::canvas_event(GdkEvent* ev)
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) {
@ -262,7 +263,7 @@ MidiRegionView::canvas_event(GdkEvent* ev)
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;
@ -285,7 +286,7 @@ MidiRegionView::canvas_event(GdkEvent* ev)
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;
@ -365,12 +366,12 @@ MidiRegionView::canvas_event(GdkEvent* ev)
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;
}

22
gtk2_ardour/public_editor.h
View File

@ -150,19 +150,19 @@ class PublicEditor : public Gtk::Window, public PBD::StatefulThingWithGoingAway
* (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_internal_edit (bool yn) = 0;
/** @return Whether editing is currently in "internal" mode or not
*/
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 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;

13
gtk2_ardour/utils.cc
View File

@ -705,9 +705,8 @@ get_xpm (std::string name)
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");
@ -723,9 +722,15 @@ get_icon (const char* cname)
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 (...) {

1
gtk2_ardour/utils.h
View File

@ -86,6 +86,7 @@ bool key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev);
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);

5
libs/ardour/ardour/buffer_set.h
View File

@ -62,6 +62,11 @@ public:
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);

3
libs/ardour/ardour/internal_send.h
View File

@ -43,10 +43,13 @@ class InternalSend : public Send
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;

33
libs/ardour/internal_send.cc
View File

@ -80,10 +80,9 @@ InternalSend::run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame,
// 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 ();
@ -92,7 +91,7 @@ InternalSend::run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame,
/* 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) {
@ -101,13 +100,13 @@ InternalSend::run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame,
*/
_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);
}
@ -115,7 +114,7 @@ InternalSend::run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame,
// 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 */
@ -125,18 +124,24 @@ InternalSend::run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame,
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
{
@ -221,6 +226,14 @@ InternalSend::can_support_io_configuration (const ChanCount& in, ChanCount& out)
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)
{

6
libs/ardour/route.cc
View File

@ -694,8 +694,10 @@ Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorList::ite
}
// 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);

1
libs/ardour/session.cc
View File

@ -62,6 +62,7 @@
#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"

3
libs/gtkmm2ext/tearoff.cc
View File

@ -19,6 +19,7 @@
*/
#include <cmath>
#include <iostream>
#include <gtkmm2ext/tearoff.h>
#include <gtkmm2ext/utils.h>
@ -124,6 +125,8 @@ TearOff::tearoff_click (GdkEventButton* /*ev*/)
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 ();
}