* implemented three coloring modes for MIDI tracks (untested yet)

git-svn-id: svn://localhost/ardour2/branches/3.0@4344 d708f5d6-7413-0410-9779-e7cbd77b26cf

gtk2_ardour/canvas-flag.cc

@@ -24,7 +24,7 @@ CanvasFlag::set_text(string& a_text)
 {
 	delete_allocated_objects();
 	
-	_text = new CanvasFlagText(*this, 0.0, 0.0, Glib::ustring(a_text));
+	_text = new InteractiveText(*this, 0.0, 0.0, Glib::ustring(a_text));
 	_text->property_justification() = Gtk::JUSTIFY_CENTER;
 	_text->property_fill_color_rgba() = _outline_color_rgba;
 	double flagwidth  = _text->property_text_width()  + 10.0;
@@ -34,11 +34,10 @@ CanvasFlag::set_text(string& a_text)
 	_text->show();
 	_line = new SimpleLine(*this, 0.0, 0.0, 0.0, _height);
 	_line->property_color_rgba() = _outline_color_rgba;
-	_rect = new CanvasFlagRect(*this, 0.0, 0.0, flagwidth, flagheight);
+	_rect = new InteractiveRect(*this, 0.0, 0.0, flagwidth, flagheight);
 	_rect->property_outline_color_rgba() = _outline_color_rgba;
 	_rect->property_fill_color_rgba() = _fill_color_rgba;
-	_text->lower_to_bottom();
+	_text->raise_to_top();	
-	_text->raise(2);	
 }
 
 CanvasFlag::~CanvasFlag()

gtk2_ardour/canvas-flag.h

@@ -2,23 +2,20 @@
 #define CANVASFLAG_H_
 
 #include <libgnomecanvasmm/group.h>
-#include <libgnomecanvasmm/text.h>
 #include <libgnomecanvasmm/widget.h>
 
 #include <ardour/midi_model.h>
 
 #include "simplerect.h"
 #include "simpleline.h"
+#include "interactive-item.h"
 
 class MidiRegionView;
 
 namespace Gnome {
 namespace Canvas {
 
-class CanvasFlagRect;
+class CanvasFlag : public Group, public InteractiveItem
-class CanvasFlagText;
-
-class CanvasFlag : public Group
 {
 public:
 	CanvasFlag(
@@ -46,7 +43,7 @@ public:
 	void set_text(string& a_text);
 
 protected:
-	CanvasFlagText*                   _text;
+	InteractiveText*                  _text;
 	double                            _height;
 	guint                             _outline_color_rgba;
 	guint                             _fill_color_rgba;
@@ -56,48 +53,7 @@ private:
 	void delete_allocated_objects();
 	
 	SimpleLine*                       _line;
-	CanvasFlagRect*                   _rect;
+	InteractiveRect*                  _rect;
-};
-
-class CanvasFlagText: public Text
-{
-public:
-	CanvasFlagText(Group& parent, double x, double y, const Glib::ustring& text) 
-		: Text(parent, x, y, text) {
-		_parent = dynamic_cast<CanvasFlag*>(&parent);
-;
-	}
-	
-	virtual bool on_event(GdkEvent* ev) {
-		if(_parent) {
-			return _parent->on_event(ev);
-		} else {
-			return false;
-		}
-	}
-
-private:
-	CanvasFlag* _parent;
-};
-
-class CanvasFlagRect: public SimpleRect
-{
-public:
-	CanvasFlagRect(Group& parent, double x1, double y1, double x2, double y2) 
-		: SimpleRect(parent, x1, y1, x2, y2) {
-		_parent = dynamic_cast<CanvasFlag*>(&parent);
-	}
-	
-	virtual bool on_event(GdkEvent* ev) {
-		if(_parent) {
-			return _parent->on_event(ev);
-		} else {
-			return false;
-		}
-	}
-
-private:
-	CanvasFlag* _parent;
 };
 
 

gtk2_ardour/canvas-note-event.cc

@@ -75,7 +75,7 @@ void
 CanvasNoteEvent::show_velocity()
 {
 	hide_velocity();
-	_text = new Text(*(_item->property_parent()));
+	_text = new InteractiveText(*(_item->property_parent()));
 	_text->property_x() = (x1() + x2()) /2;
 	_text->property_y() = (y1() + y2()) /2;
 	ostringstream velo(ios::ate);
@@ -158,24 +158,47 @@ CanvasNoteEvent::hide_channel_selector(void)
 }
 
 void
-CanvasNoteEvent::selected(bool yn)
+CanvasNoteEvent::selected(bool selected)
 {
 	if (!_note) {
 		return;
-	} else if (yn) {
+	} else if (selected) {
-		set_fill_color(UINT_INTERPOLATE(meter_style_fill_color(_note->velocity()),
+		set_fill_color(UINT_INTERPOLATE(base_color(),
 					ARDOUR_UI::config()->canvasvar_MidiNoteSelected.get(), 0.1));
 		set_outline_color(calculate_outline(ARDOUR_UI::config()->canvasvar_MidiNoteSelected.get()));
 		show_velocity();
 	} else {
-		set_fill_color(meter_style_fill_color(_note->velocity()));
+		set_fill_color(base_color());
-		set_outline_color(meter_style_outline_color(_note->velocity()));
+		set_outline_color(calculate_outline(base_color()));
 		hide_velocity();
 	}
 
-	_selected = yn;
+	_selected = selected;
 }
 
+uint32_t 
+CanvasNoteEvent::base_color()
+{
+	using namespace ARDOUR;
+	
+	ColorMode mode = _region.color_mode();
+	
+	switch (mode) {
+	case TrackColor:
+		{
+			Gdk::Color color = _region.midi_stream_view()->get_region_color();
+			return RGBA_TO_UINT(color.get_red(), color.get_green(), color.get_blue(), 0xff);
+		}
+		
+	case ChannelColors:
+		return CanvasNoteEvent::midi_channel_colors[_note->channel()];
+		
+	default:
+		return meter_style_fill_color(_note->velocity());
+	};
+	
+	return 0;
+}
 
 bool
 CanvasNoteEvent::on_event(GdkEvent* ev)
@@ -188,6 +211,8 @@ CanvasNoteEvent::on_event(GdkEvent* ev)
 	bool select_mod;
 	uint8_t d_velocity = 10;
 
+	cerr << "CanvasNoteEvent::on_event(GdkEvent* ev)" << endl;
+	
 	if (_region.get_time_axis_view().editor.current_mouse_mode() != Editing::MouseNote)
 		return false;
 

gtk2_ardour/canvas-note-event.h

@@ -65,6 +65,8 @@ public:
 
 	void move_event(double dx, double dy);
 	
+	uint32_t base_color();
+	
 	void show_velocity();
 	void hide_velocity();
 	
@@ -102,11 +104,6 @@ public:
 		}
 	}
 	
-	inline static uint32_t meter_style_outline_color(uint8_t vel)
-	{
-		return calculate_outline(meter_style_fill_color(vel));
-	}
-	
 	/// calculate outline colors from fill colors of notes
 	inline static uint32_t calculate_outline(uint32_t color) 
 	{
@@ -121,7 +118,7 @@ protected:
 
 	MidiRegionView&                       _region;
 	Item* const                           _item;
-	Text*                                 _text;
+	InteractiveText*                      _text;
 	Widget*                               _channel_selector_widget;
 	State                                 _state;
 	const boost::shared_ptr<Evoral::Note> _note;

gtk2_ardour/editor_canvas_events.cc

@@ -62,8 +62,8 @@ Editor::track_canvas_scroll (GdkEventScroll* ev)
 	
 	Gnome::Canvas::Item* item = track_canvas->get_item_at(ev->x, ev->y);
 	InteractiveItem* interactive_item = dynamic_cast<InteractiveItem*>(item);
-	if (interactive_item && interactive_item->on_event(reinterpret_cast<GdkEvent*>(ev))) {
+	if (interactive_item) {
-		return true;
+		return interactive_item->on_event(reinterpret_cast<GdkEvent*>(ev));
 	}
 
   retry:

gtk2_ardour/interactive-item.h

@@ -20,6 +20,9 @@
 #ifndef __ardour_interactive_item_h__
 #define __ardour_interactive_item_h__
 
+#include <libgnomecanvasmm/text.h>
+#include "simplerect.h"
+
 namespace Gnome {
 namespace Canvas {
 
@@ -34,6 +37,53 @@ public:
 	virtual bool on_event(GdkEvent* ev) = 0;
 };
 
+/** A canvas text that forwards events to its parent.
+ */
+class InteractiveText : public Text, public InteractiveItem {
+public:
+	InteractiveText(Group& parent, double x, double y, const Glib::ustring& text) 
+		: Text(parent, x, y, text) 
+	{
+		_parent = dynamic_cast<InteractiveItem*>(&parent);
+	}
+	
+	InteractiveText(Group& parent)
+		: Text(parent) 
+	{
+		_parent = dynamic_cast<InteractiveItem*>(&parent);		
+	}
+	
+	bool on_event(GdkEvent* ev) {
+		if(_parent) {
+			return _parent->on_event(ev);
+		} else {
+			return false;
+		}
+	}
+
+protected:
+	InteractiveItem* _parent;
+};
+
+class InteractiveRect: public SimpleRect, public InteractiveItem
+{
+public:
+	InteractiveRect(Group& parent, double x1, double y1, double x2, double y2) 
+		: SimpleRect(parent, x1, y1, x2, y2) {
+		_parent = dynamic_cast<InteractiveItem*>(&parent);
+	}
+	
+	bool on_event(GdkEvent* ev) {
+		if(_parent) {
+			return _parent->on_event(ev);
+		} else {
+			return false;
+		}
+	}
+
+protected:
+	InteractiveItem* _parent;
+};
 
 } /* namespace Canvas */
 } /* namespace Gnome */

gtk2_ardour/midi_region_view.h

@@ -83,6 +83,8 @@ class MidiRegionView : public RegionView
 	void set_height (double);
 	void apply_note_range(uint8_t lowest, uint8_t highest, bool force=false);
 
+	inline ARDOUR::ColorMode color_mode() const { return midi_view()->color_mode(); }
+	
 	void set_frame_color();
 
 	void redisplay_model();

gtk2_ardour/midi_time_axis.cc

@@ -93,8 +93,12 @@ MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session& sess, boost::shar
 	, _range_scroomer(0)
 	, _piano_roll_header(0)
 	, _note_mode(Sustained)
-	, _note_mode_item(NULL)
+	, _note_mode_item(0)
-	, _percussion_mode_item(NULL)
+	, _percussion_mode_item(0)
+	, _color_mode(MeterColors)
+	, _meter_color_mode_item(0)
+	, _channel_color_mode_item(0)
+	, _track_color_mode_item(0)
 {
 	subplugin_menu.set_name ("ArdourContextMenu");
 
@@ -323,6 +327,34 @@ MidiTimeAxisView::build_mode_menu()
 	return mode_menu;
 }
 
+Gtk::Menu*
+MidiTimeAxisView::build_color_mode_menu()
+{
+	using namespace Menu_Helpers;
+
+	Menu* mode_menu = manage (new Menu);
+	MenuList& items = mode_menu->items();
+	mode_menu->set_name ("ArdourContextMenu");
+
+	RadioMenuItem::Group mode_group;
+	items.push_back (RadioMenuElem (mode_group, _("Meter Colors"),
+				bind (mem_fun (*this, &MidiTimeAxisView::set_color_mode), MeterColors)));
+	_meter_color_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
+	_meter_color_mode_item->set_active(_color_mode == MeterColors);
+
+	items.push_back (RadioMenuElem (mode_group, _("Channel Colors"),
+				bind (mem_fun (*this, &MidiTimeAxisView::set_color_mode), ChannelColors)));
+	_channel_color_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
+	_channel_color_mode_item->set_active(_color_mode == ChannelColors);
+	
+	items.push_back (RadioMenuElem (mode_group, _("Track Color"),
+				bind (mem_fun (*this, &MidiTimeAxisView::set_color_mode), TrackColor)));
+	_channel_color_mode_item = dynamic_cast<RadioMenuItem*>(&items.back());
+	_channel_color_mode_item->set_active(_color_mode == TrackColor);
+		
+	return mode_menu;
+}
+	
 void
 MidiTimeAxisView::set_note_mode(NoteMode mode)
 {
@@ -333,6 +365,14 @@ MidiTimeAxisView::set_note_mode(NoteMode mode)
 	}
 }
 
+void
+MidiTimeAxisView::set_color_mode(ColorMode mode)
+{
+	if (_color_mode != mode) {
+		_color_mode = mode;
+		_view->redisplay_diskstream();
+	}
+}
 
 void
 MidiTimeAxisView::set_note_range(MidiStreamView::VisibleNoteRange range)

gtk2_ardour/midi_time_axis.h

@@ -74,6 +74,7 @@ class MidiTimeAxisView : public RouteTimeAxisView
 	void create_automation_child (const Evoral::Parameter& param, bool show);
 
 	ARDOUR::NoteMode  note_mode() const { return _note_mode; }
+	ARDOUR::ColorMode color_mode() const { return _color_mode; }
 
 	void update_range();
 	
@@ -94,8 +95,10 @@ class MidiTimeAxisView : public RouteTimeAxisView
 	void append_extra_display_menu_items ();
 	void build_automation_action_menu ();
 	Gtk::Menu* build_mode_menu();
+	Gtk::Menu* build_color_mode_menu();
 
 	void set_note_mode (ARDOUR::NoteMode mode);
+	void set_color_mode(ARDOUR::ColorMode mode);
 	void set_note_range(MidiStreamView::VisibleNoteRange range);
 
 	void route_active_changed ();
@@ -109,6 +112,10 @@ class MidiTimeAxisView : public RouteTimeAxisView
 	ARDOUR::NoteMode             _note_mode;
 	Gtk::RadioMenuItem*          _note_mode_item;
 	Gtk::RadioMenuItem*          _percussion_mode_item;
+	ARDOUR::ColorMode            _color_mode;
+	Gtk::RadioMenuItem*          _meter_color_mode_item;
+	Gtk::RadioMenuItem*          _channel_color_mode_item;
+	Gtk::RadioMenuItem*          _track_color_mode_item;
 	Gtk::VBox                    _midi_controls_box;
 	MidiMultipleChannelSelector  _channel_selector;
 	Gtk::ComboBoxText            _model_selector;

gtk2_ardour/route_time_axis.cc

@@ -575,6 +575,12 @@ RouteTimeAxisView::build_display_menu ()
 		if (mode_menu)
 			items.push_back (MenuElem (_("Mode"), *mode_menu));
 			
+		items.push_back (SeparatorElem());
+
+		color_mode_menu = build_color_mode_menu();
+		if (color_mode_menu)
+			items.push_back (MenuElem (_("Color Mode"), *color_mode_menu));
+			
 		items.push_back (SeparatorElem());
 		}
 	}

gtk2_ardour/route_time_axis.h

@@ -285,8 +285,10 @@ protected:
 	Gtk::Menu*          playlist_action_menu;
 	Gtk::MenuItem*      playlist_item;
 	Gtk::Menu*          mode_menu;
+	Gtk::Menu*          color_mode_menu;
 
-	virtual Gtk::Menu* build_mode_menu() { return NULL; }
+	virtual Gtk::Menu* build_mode_menu() { return 0; }
+	virtual Gtk::Menu* build_color_mode_menu() { return 0; }
 
 	void use_playlist (boost::weak_ptr<ARDOUR::Playlist>);
 

libs/ardour/ardour/types.h

@@ -140,6 +140,12 @@ namespace ARDOUR {
 		ForceChannel     ///< Force all events to a certain channel
 	};
 	
+	enum ColorMode {
+		MeterColors = 0,
+		ChannelColors,
+		TrackColor
+	};
+
 	enum EventTimeUnit {
 		Frames,
 		Beats