gtk2_ardour/region_layering_order_editor.cc

   1 #include <gtkmm/table.h>
   2 #include <gtkmm/stock.h>
   3 #include <gtkmm/alignment.h>
   4 #include <ardour/region.h>
   5
   6 #include "i18n.h"
   7 #include "keyboard.h"
   8 #include "public_editor.h"
   9 #include "region_layering_order_editor.h"
  10 #include "utils.h"
  11
  12 using namespace Gtk;
  13 using namespace ARDOUR;
  14
  15 RegionLayeringOrderEditor::RegionLayeringOrderEditor (PublicEditor& pe)
  16         : ArdourDialog (pe, _("RegionLayeringOrderEditor"), false, false)
  17         , playlist ()
  18         , position ()
  19         , in_row_change (false)
  20         , regions_at_position (0)
  21         , layering_order_columns ()
  22         , layering_order_model (Gtk::ListStore::create (layering_order_columns))
  23         , layering_order_display ()
  24         , clock ("layer dialog", true, "RegionLayeringOrderEditorClock", false, false, false)
  25         , scroller ()
  26         , editor (pe)
  27 {
  28         set_name ("RegionLayeringOrderEditorWindow");
  29
  30         layering_order_display.set_model (layering_order_model);
  31
  32         layering_order_display.append_column (_("Region Name"), layering_order_columns.name);
  33         layering_order_display.set_headers_visible (true);
  34         layering_order_display.set_reorderable (false);
  35         layering_order_display.set_rules_hint (true);
  36
  37         scroller.set_border_width (10);
  38         scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
  39         scroller.add (layering_order_display);
  40
  41         clock.set_mode (AudioClock::BBT);
  42
  43
  44         Gtk::Table* scroller_table = manage (new Gtk::Table);
  45         scroller_table->set_size_request (300, 250);
  46         scroller_table->attach (scroller, 0, 1, 0, 1);
  47         scroller_table->set_col_spacings (5);
  48         scroller_table->set_row_spacings (5);
  49         scroller_table->set_border_width (5);
  50
  51         track_label.set_name ("RegionLayeringOrderEditorLabel");
  52         track_label.set_text (_("Track:"));
  53         clock_label.set_name ("RegionLayeringOrderEditorLabel");
  54         clock_label.set_text (_("Position:"));
  55         track_name_label.set_name ("RegionLayeringOrderEditorNameLabel");
  56         clock.set_mode (AudioClock::BBT);
  57
  58         Gtk::Alignment* track_alignment = manage (new Gtk::Alignment);
  59         track_alignment->set (1.0, 0.5);
  60         track_alignment->add (track_label);
  61
  62         Gtk::Alignment* clock_alignment = manage (new Gtk::Alignment);
  63         clock_alignment->set (1.0, 0.5);
  64         clock_alignment->add (clock_label);
  65
  66         Gtk::Table* info_table = manage (new Gtk::Table (2, 2));
  67         info_table->set_col_spacings (5);
  68         info_table->set_row_spacings (5);
  69         info_table->set_border_width (5);
  70         info_table->attach (*track_alignment, 0, 1, 0, 1, FILL, FILL);
  71         info_table->attach (track_name_label, 1, 2, 0, 1, FILL, FILL);
  72         info_table->attach (*clock_alignment, 0, 1, 1, 2, FILL, FILL);
  73         info_table->attach (clock, 1, 2, 1, 2, FILL, FILL);
  74
  75         HBox* info_hbox = manage (new HBox);
  76
  77         info_hbox->pack_start (*info_table, true, false);
  78
  79         get_vbox()->set_spacing (5);
  80         get_vbox()->pack_start (*info_hbox, false, false);
  81         get_vbox()->pack_start (*scroller_table, true, true);
  82
  83         info_table->set_name ("RegionLayeringOrderTable");
  84         scroller_table->set_name ("RegionLayeringOrderTable");
  85
  86         layering_order_display.set_name ("RegionLayeringOrderDisplay");
  87
  88         layering_order_display.signal_row_activated ().connect (mem_fun (*this, &RegionLayeringOrderEditor::row_activated));
  89
  90         layering_order_display.grab_focus ();
  91
  92         set_title (_("Choose Top Region"));
  93         show_all();
  94 }
  95
  96 RegionLayeringOrderEditor::~RegionLayeringOrderEditor ()
  97 {
  98 }
  99
 100 void
 101 RegionLayeringOrderEditor::row_activated (const TreeModel::Path& path, TreeViewColumn* column)
 102 {
 103         if (in_row_change) {
 104                 return;
 105         }
 106
 107         TreeModel::iterator iter = layering_order_model->get_iter (path);
 108
 109         if (iter) {
 110                 TreeModel::Row row = *iter;
 111                 boost::shared_ptr<Region> region = row[layering_order_columns.region];
 112
 113                 region->raise_to_top ();
 114         }
 115 }
 116
 117 typedef boost::shared_ptr<Region> RegionPtr;
 118
 119 struct RegionCompareByLayer {
 120     bool operator() (RegionPtr a, RegionPtr b) const {
 121             return a->layer() > b->layer();
 122     }
 123 };
 124
 125 void
 126 RegionLayeringOrderEditor::refill ()
 127 {
 128         regions_at_position = 0;
 129
 130         if (!playlist) {
 131                 return;
 132         }
 133
 134         typedef Playlist::RegionList RegionList;
 135
 136         in_row_change = true;
 137
 138         layering_order_model->clear ();
 139
 140         boost::shared_ptr<RegionList> region_list(playlist->regions_at (position));
 141
 142         regions_at_position = region_list->size();
 143
 144         if (regions_at_position < 2) {
 145                 playlist_modified_connection.disconnect ();
 146                 hide ();
 147                 in_row_change = false;
 148                 return;
 149         }
 150
 151         RegionCompareByLayer cmp;
 152         region_list->sort (cmp);
 153
 154         for (RegionList::const_iterator i = region_list->begin(); i != region_list->end(); ++i) {
 155                 TreeModel::Row newrow = *(layering_order_model->append());
 156                 newrow[layering_order_columns.name] = (*i)->name();
 157                 newrow[layering_order_columns.region] = *i;
 158
 159                if (i == region_list->begin()) {
 160                        layering_order_display.get_selection()->select(newrow);
 161                }
 162         }
 163
 164         in_row_change = false;
 165 }
 166
 167 void
 168 RegionLayeringOrderEditor::set_context (const string& a_name, Session* s, const boost::shared_ptr<Playlist>  & pl, nframes64_t pos)
 169 {
 170         track_name_label.set_text (a_name);
 171
 172         clock.set_session (s);
 173         clock.set (pos, true, 0, 0);
 174
 175         playlist_modified_connection.disconnect ();
 176         playlist = pl;
 177         playlist_modified_connection = playlist->Modified.connect (mem_fun (*this, &RegionLayeringOrderEditor::playlist_modified));
 178
 179         position = pos;
 180         refill ();
 181 }
 182
 183 bool
 184 RegionLayeringOrderEditor::on_key_press_event (GdkEventKey* ev)
 185 {
 186         bool handled = false;
 187
 188         /* in general, we want shortcuts working while in this
 189            dialog. However, we'd like to treat "return" specially
 190            since it is used for row activation. So ..
 191
 192            for return: try normal handling first
 193            then try the editor (to get accelerators/shortcuts)
 194            then try normal handling (for keys other than return)
 195         */
 196
 197         if (ev->keyval == GDK_Return) {
 198                 handled = ArdourDialog::on_key_press_event (ev);
 199         }
 200
 201         if (!handled) {
 202                 handled = key_press_focus_accelerator_handler (editor, ev);
 203         }
 204
 205         if (!handled) {
 206                 handled = ArdourDialog::on_key_press_event (ev);
 207         }
 208
 209         return handled;
 210 }
 211
 212 void
 213 RegionLayeringOrderEditor::maybe_present ()
 214 {
 215         if (regions_at_position < 2) {
 216                 hide ();
 217                 return;
 218         }
 219         present ();
 220 }
 221
 222 void
 223 RegionLayeringOrderEditor::playlist_modified ()
 224 {
 225         refill ();
 226 }