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