gtk2_ardour/luainstance.cc

   1 /*
   2  * Copyright (C) 2016 Robin Gareus <robin@gareus.org>
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17  */
  18
  19 #include <cairomm/context.h>
  20
  21 #include "gtkmm2ext/gui_thread.h"
  22
  23 #include "ardour/audioengine.h"
  24 #include "ardour/diskstream.h"
  25 #include "ardour/plugin_manager.h"
  26 #include "ardour/route.h"
  27 #include "ardour/session.h"
  28
  29 #include "ardour_ui.h"
  30 #include "public_editor.h"
  31 #include "region_selection.h"
  32 #include "luainstance.h"
  33 #include "luasignal.h"
  34 #include "script_selector.h"
  35
  36 #include "i18n.h"
  37
  38 namespace LuaSignal {
  39
  40 #define STATIC(name,c,p) else if (!strcmp(type, #name)) {return name;}
  41 #define SESSION(name,c,p) else if (!strcmp(type, #name)) {return name;}
  42 #define ENGINE(name,c,p) else if (!strcmp(type, #name)) {return name;}
  43
  44 LuaSignal
  45 str2luasignal (const std::string &str) {
  46         const char* type = str.c_str();
  47         if (0) { }
  48 #       include "luasignal_syms.h"
  49         else {
  50                 PBD::fatal << string_compose (_("programming error: %1: %2"), "Impossible LuaSignal type", str) << endmsg;
  51                 abort(); /*NOTREACHED*/
  52         }
  53 }
  54 #undef STATIC
  55 #undef SESSION
  56 #undef ENGINE
  57
  58 #define STATIC(name,c,p) N_(#name),
  59 #define SESSION(name,c,p) N_(#name),
  60 #define ENGINE(name,c,p) N_(#name),
  61 const char *luasignalstr[] = {
  62 #       include "luasignal_syms.h"
  63         0
  64 };
  65
  66 #undef STATIC
  67 #undef SESSION
  68 #undef ENGINE
  69 }; // namespace
  70
  71 ////////////////////////////////////////////////////////////////////////////////
  72
  73 #define xstr(s) stringify(s)
  74 #define stringify(s) #s
  75
  76 using namespace ARDOUR;
  77
  78 void
  79 LuaInstance::register_hooks (lua_State* L)
  80 {
  81
  82 #define ENGINE(name,c,p) .addConst (stringify(name), (LuaSignal::LuaSignal)LuaSignal::name)
  83 #define STATIC(name,c,p) .addConst (stringify(name), (LuaSignal::LuaSignal)LuaSignal::name)
  84 #define SESSION(name,c,p) .addConst (stringify(name), (LuaSignal::LuaSignal)LuaSignal::name)
  85         luabridge::getGlobalNamespace (L)
  86                 .beginNamespace ("LuaSignal")
  87 #               include "luasignal_syms.h"
  88                 .endNamespace ();
  89 #undef ENGINE
  90 #undef SESSION
  91 #undef STATIC
  92
  93         luabridge::getGlobalNamespace (L)
  94                 .beginNamespace ("LuaSignal")
  95                 .beginStdBitSet <LuaSignal::LAST_SIGNAL> ("Set")
  96                 .endClass()
  97                 .endNamespace ();
  98 }
  99
 100 void
 101 LuaInstance::bind_cairo (lua_State* L)
 102 {
 103         luabridge::getGlobalNamespace (L)
 104                 .beginNamespace ("Cairo")
 105                 .beginClass <Cairo::Context> ("Context")
 106                 .addFunction ("save", &Cairo::Context::save)
 107                 .addFunction ("restore", &Cairo::Context::restore)
 108                 .addFunction ("set_operator", &Cairo::Context::set_operator)
 109                 //.addFunction ("set_source", &Cairo::Context::set_operator) // needs RefPtr
 110                 .addFunction ("set_source_rgb", &Cairo::Context::set_source_rgb)
 111                 .addFunction ("set_source_rgba", &Cairo::Context::set_source_rgba)
 112                 .addFunction ("set_line_width", &Cairo::Context::set_line_width)
 113                 .addFunction ("set_line_cap", &Cairo::Context::set_line_cap)
 114                 .addFunction ("set_line_join", &Cairo::Context::set_line_join)
 115                 .addFunction ("set_dash", (void (Cairo::Context::*)(std::vector<double>&, double))&Cairo::Context::set_dash)
 116                 .addFunction ("unset_dash", &Cairo::Context::unset_dash)
 117                 .addFunction ("translate", &Cairo::Context::translate)
 118                 .addFunction ("scale", &Cairo::Context::scale)
 119                 .addFunction ("rotate", &Cairo::Context::rotate)
 120                 .addFunction ("begin_new_path", &Cairo::Context::begin_new_path)
 121                 .addFunction ("begin_new_sub_path", &Cairo::Context::begin_new_sub_path)
 122                 .addFunction ("move_to", &Cairo::Context::move_to)
 123                 .addFunction ("line_to", &Cairo::Context::line_to)
 124                 .addFunction ("curve_to", &Cairo::Context::curve_to)
 125                 .addFunction ("arc", &Cairo::Context::arc)
 126                 .addFunction ("arc_negative", &Cairo::Context::arc_negative)
 127                 .addFunction ("rel_move_to", &Cairo::Context::rel_move_to)
 128                 .addFunction ("rel_line_to", &Cairo::Context::rel_line_to)
 129                 .addFunction ("rel_curve_to", &Cairo::Context::rel_curve_to)
 130                 .addFunction ("rectangle", (void (Cairo::Context::*)(double, double, double, double))&Cairo::Context::rectangle)
 131                 .addFunction ("close_path", &Cairo::Context::close_path)
 132                 .addFunction ("paint", &Cairo::Context::paint)
 133                 .addFunction ("paint_with_alpha", &Cairo::Context::paint_with_alpha)
 134                 .addFunction ("stroke", &Cairo::Context::stroke)
 135                 .addFunction ("stroke_preserve", &Cairo::Context::stroke_preserve)
 136                 .addFunction ("fill", &Cairo::Context::fill)
 137                 .addFunction ("fill_preserve", &Cairo::Context::fill_preserve)
 138                 .addFunction ("reset_clip", &Cairo::Context::reset_clip)
 139                 .addFunction ("clip", &Cairo::Context::clip)
 140                 .addFunction ("clip_preserve", &Cairo::Context::clip_preserve)
 141                 .addFunction ("set_font_size", &Cairo::Context::set_font_size)
 142                 .addFunction ("show_text", &Cairo::Context::show_text)
 143                 .endClass ()
 144                 /* enums */
 145                 // LineCap, LineJoin, Operator
 146                 .beginNamespace ("LineCap")
 147                 .addConst ("Butt", CAIRO_LINE_CAP_BUTT)
 148                 .addConst ("Round", CAIRO_LINE_CAP_ROUND)
 149                 .addConst ("Square", CAIRO_LINE_CAP_SQUARE)
 150                 .endNamespace ()
 151
 152                 .beginNamespace ("LineJoin")
 153                 .addConst ("Miter", CAIRO_LINE_JOIN_MITER)
 154                 .addConst ("Round", CAIRO_LINE_JOIN_ROUND)
 155                 .addConst ("Bevel", CAIRO_LINE_JOIN_BEVEL)
 156                 .endNamespace ()
 157
 158                 .beginNamespace ("Operator")
 159                 .addConst ("Clear", CAIRO_OPERATOR_CLEAR)
 160                 .addConst ("Source", CAIRO_OPERATOR_SOURCE)
 161                 .addConst ("Over", CAIRO_OPERATOR_OVER)
 162                 .addConst ("Add", CAIRO_OPERATOR_ADD)
 163                 .endNamespace ()
 164
 165                 .endNamespace ();
 166
 167 /* Lua/cairo bindings operate on Cairo::Context, there is no Cairo::RefPtr wrapper [yet].
 168   one can work around this as follows:
 169
 170   LuaState lua;
 171   LuaInstance::register_classes (lua.getState());
 172   lua.do_command (
 173       "function render (ctx)"
 174       "  ctx:rectangle (0, 0, 100, 100)"
 175       "  ctx:set_source_rgba (0.1, 1.0, 0.1, 1.0)"
 176       "  ctx:fill ()"
 177       " end"
 178       );
 179   {
 180                 Cairo::RefPtr<Cairo::Context> context = get_window ()->create_cairo_context ();
 181     Cairo::Context ctx (context->cobj ());
 182
 183     luabridge::LuaRef lua_render = luabridge::getGlobal (lua.getState(), "render");
 184     lua_render ((Cairo::Context *)&ctx);
 185   }
 186 */
 187
 188 }
 189
 190 void
 191 LuaInstance::register_classes (lua_State* L)
 192 {
 193         LuaBindings::stddef (L);
 194         LuaBindings::common (L);
 195         LuaBindings::session (L);
 196         LuaBindings::osc (L);
 197
 198         bind_cairo (L);
 199         register_hooks (L);
 200
 201         luabridge::getGlobalNamespace (L)
 202                 .beginNamespace ("ArdourUI")
 203                 .beginClass <RegionSelection> ("RegionSelection")
 204                 .addFunction ("clear_all", &RegionSelection::clear_all)
 205                 .addFunction ("start", &RegionSelection::start)
 206                 .addFunction ("end_frame", &RegionSelection::end_frame)
 207                 .addFunction ("n_midi_regions", &RegionSelection::n_midi_regions)
 208                 .endClass ()
 209
 210                 .beginClass <ArdourMarker> ("ArdourMarker")
 211                 .endClass ()
 212
 213                 .beginClass <PublicEditor> ("Editor")
 214                 .addFunction ("snap_type", &PublicEditor::snap_type)
 215                 .addFunction ("snap_mode", &PublicEditor::snap_mode)
 216                 .addFunction ("set_snap_mode", &PublicEditor::set_snap_mode)
 217                 .addFunction ("set_snap_threshold", &PublicEditor::set_snap_threshold)
 218
 219                 .addFunction ("undo", &PublicEditor::undo)
 220                 .addFunction ("redo", &PublicEditor::redo)
 221
 222                 .addFunction ("set_mouse_mode", &PublicEditor::set_mouse_mode)
 223                 .addFunction ("current_mouse_mode", &PublicEditor::current_mouse_mode)
 224
 225                 .addFunction ("consider_auditioning", &PublicEditor::consider_auditioning)
 226
 227                 .addFunction ("new_region_from_selection", &PublicEditor::new_region_from_selection)
 228                 .addFunction ("separate_region_from_selection", &PublicEditor::separate_region_from_selection)
 229                 .addFunction ("pixel_to_sample", &PublicEditor::pixel_to_sample)
 230                 .addFunction ("sample_to_pixel", &PublicEditor::sample_to_pixel)
 231
 232 #if 0 // Selection is not yet exposed
 233                 .addFunction ("get_selection", &PublicEditor::get_selection)
 234                 .addFunction ("get_cut_buffer", &PublicEditor::get_cut_buffer)
 235                 .addFunction ("track_mixer_selection", &PublicEditor::track_mixer_selection)
 236                 .addFunction ("extend_selection_to_track", &PublicEditor::extend_selection_to_track)
 237 #endif
 238
 239                 .addFunction ("play_selection", &PublicEditor::play_selection)
 240                 .addFunction ("play_with_preroll", &PublicEditor::play_with_preroll)
 241                 .addFunction ("maybe_locate_with_edit_preroll", &PublicEditor::maybe_locate_with_edit_preroll)
 242                 .addFunction ("goto_nth_marker", &PublicEditor::goto_nth_marker)
 243
 244                 .addFunction ("add_location_from_playhead_cursor", &PublicEditor::add_location_from_playhead_cursor)
 245                 .addFunction ("remove_location_at_playhead_cursor", &PublicEditor::remove_location_at_playhead_cursor)
 246
 247                 .addFunction ("set_show_measures", &PublicEditor::set_show_measures)
 248                 .addFunction ("show_measures", &PublicEditor::show_measures)
 249                 .addFunction ("remove_tracks", &PublicEditor::remove_tracks)
 250
 251                 .addFunction ("effective_mouse_mode", &PublicEditor::effective_mouse_mode)
 252
 253                 .addRefFunction ("do_import", &PublicEditor::do_import)
 254                 .addRefFunction ("do_embed", &PublicEditor::do_embed)
 255
 256                 .addFunction ("export_audio", &PublicEditor::export_audio)
 257                 .addFunction ("stem_export", &PublicEditor::stem_export)
 258                 .addFunction ("export_selection", &PublicEditor::export_selection)
 259                 .addFunction ("export_range", &PublicEditor::export_range)
 260
 261                 .addFunction ("set_zoom_focus", &PublicEditor::set_zoom_focus)
 262                 .addFunction ("get_zoom_focus", &PublicEditor::get_zoom_focus)
 263                 .addFunction ("get_current_zoom", &PublicEditor::get_current_zoom)
 264                 .addFunction ("reset_zoom", &PublicEditor::reset_zoom)
 265
 266 #if 0 // These need TimeAxisView* which isn't exposed, yet
 267                 .addFunction ("playlist_selector", &PublicEditor::playlist_selector)
 268                 .addFunction ("clear_playlist", &PublicEditor::clear_playlist)
 269                 .addFunction ("new_playlists", &PublicEditor::new_playlists)
 270                 .addFunction ("copy_playlists", &PublicEditor::copy_playlists)
 271                 .addFunction ("clear_playlists", &PublicEditor::clear_playlists)
 272 #endif
 273
 274                 .addFunction ("select_all_tracks", &PublicEditor::select_all_tracks)
 275                 .addFunction ("deselect_all", &PublicEditor::deselect_all)
 276 #if 0
 277                 .addFunction ("set_selected_track", &PublicEditor::set_selected_track)
 278                 .addFunction ("set_selected_mixer_strip", &PublicEditor::set_selected_mixer_strip)
 279                 .addFunction ("hide_track_in_display", &PublicEditor::hide_track_in_display)
 280 #endif
 281                 .addFunction ("set_stationary_playhead", &PublicEditor::set_stationary_playhead)
 282                 .addFunction ("stationary_playhead", &PublicEditor::stationary_playhead)
 283                 .addFunction ("set_follow_playhead", &PublicEditor::set_follow_playhead)
 284                 .addFunction ("follow_playhead", &PublicEditor::follow_playhead)
 285
 286                 .addFunction ("dragging_playhead", &PublicEditor::dragging_playhead)
 287                 .addFunction ("leftmost_sample", &PublicEditor::leftmost_sample)
 288                 .addFunction ("current_page_samples", &PublicEditor::current_page_samples)
 289                 .addFunction ("visible_canvas_height", &PublicEditor::visible_canvas_height)
 290                 .addFunction ("temporal_zoom_step", &PublicEditor::temporal_zoom_step)
 291                 //.addFunction ("ensure_time_axis_view_is_visible", &PublicEditor::ensure_time_axis_view_is_visible)
 292                 .addFunction ("override_visible_track_count", &PublicEditor::override_visible_track_count)
 293
 294                 .addFunction ("scroll_tracks_down_line", &PublicEditor::scroll_tracks_down_line)
 295                 .addFunction ("scroll_tracks_up_line", &PublicEditor::scroll_tracks_up_line)
 296                 .addFunction ("scroll_down_one_track", &PublicEditor::scroll_down_one_track)
 297                 .addFunction ("scroll_up_one_track", &PublicEditor::scroll_up_one_track)
 298
 299                 .addFunction ("reset_x_origin", &PublicEditor::reset_x_origin)
 300                 .addFunction ("get_y_origin", &PublicEditor::get_y_origin)
 301                 .addFunction ("reset_y_origin", &PublicEditor::reset_y_origin)
 302
 303                 .addFunction ("remove_last_capture", &PublicEditor::remove_last_capture)
 304
 305                 .addFunction ("maximise_editing_space", &PublicEditor::maximise_editing_space)
 306                 .addFunction ("restore_editing_space", &PublicEditor::restore_editing_space)
 307                 .addFunction ("toggle_meter_updating", &PublicEditor::toggle_meter_updating)
 308
 309                 //.addFunction ("get_preferred_edit_position", &PublicEditor::get_preferred_edit_position)
 310                 //.addFunction ("split_regions_at", &PublicEditor::split_regions_at)
 311
 312                 .addRefFunction ("get_nudge_distance", &PublicEditor::get_nudge_distance)
 313                 .addFunction ("get_paste_offset", &PublicEditor::get_paste_offset)
 314                 .addFunction ("get_grid_beat_divisions", &PublicEditor::get_grid_beat_divisions)
 315                 .addRefFunction ("get_grid_type_as_beats", &PublicEditor::get_grid_type_as_beats)
 316
 317                 .addFunction ("toggle_ruler_video", &PublicEditor::toggle_ruler_video)
 318                 .addFunction ("toggle_xjadeo_proc", &PublicEditor::toggle_xjadeo_proc)
 319                 .addFunction ("get_videotl_bar_height", &PublicEditor::get_videotl_bar_height)
 320                 .addFunction ("set_video_timeline_height", &PublicEditor::set_video_timeline_height)
 321
 322 #if 0
 323                 .addFunction ("get_route_view_by_route_id", &PublicEditor::get_route_view_by_route_id)
 324                 .addFunction ("get_equivalent_regions", &PublicEditor::get_equivalent_regions)
 325
 326                 .addFunction ("axis_view_from_route", &PublicEditor::axis_view_from_route)
 327                 .addFunction ("axis_views_from_routes", &PublicEditor::axis_views_from_routes)
 328                 .addFunction ("get_track_views", &PublicEditor::get_track_views)
 329                 .addFunction ("drags", &PublicEditor::drags)
 330 #endif
 331
 332                 .addFunction ("center_screen", &PublicEditor::center_screen)
 333
 334                 .addFunction ("get_smart_mode", &PublicEditor::get_smart_mode)
 335                 .addRefFunction ("get_pointer_position", &PublicEditor::get_pointer_position)
 336
 337                 .addRefFunction ("find_location_from_marker", &PublicEditor::find_location_from_marker)
 338                 .addFunction ("find_marker_from_location_id", &PublicEditor::find_marker_from_location_id)
 339                 .addFunction ("mouse_add_new_marker", &PublicEditor::mouse_add_new_marker)
 340 #if 0
 341                 .addFunction ("get_regions_at", &PublicEditor::get_regions_at)
 342                 .addFunction ("get_regions_after", &PublicEditor::get_regions_after)
 343                 .addFunction ("get_regions_from_selection_and_mouse", &PublicEditor::get_regions_from_selection_and_mouse)
 344                 .addFunction ("get_regionviews_by_id", &PublicEditor::get_regionviews_by_id)
 345                 .addFunction ("get_per_region_note_selection", &PublicEditor::get_per_region_note_selection)
 346 #endif
 347
 348 #if 0
 349                 .addFunction ("mouse_add_new_tempo_event", &PublicEditor::mouse_add_new_tempo_event)
 350                 .addFunction ("mouse_add_new_meter_event", &PublicEditor::mouse_add_new_meter_event)
 351                 .addFunction ("edit_tempo_section", &PublicEditor::edit_tempo_section)
 352                 .addFunction ("edit_meter_section", &PublicEditor::edit_meter_section)
 353 #endif
 354
 355                 .addFunction ("access_action", &PublicEditor::access_action)
 356                 .endClass ()
 357                 .endNamespace ();
 358
 359 #undef ZOOMFOCUS
 360 #undef SNAPTYPE
 361 #undef SNAPMODE
 362 #undef MOUSEMODE
 363 #undef DISPLAYCONTROL
 364 #undef IMPORTMODE
 365 #undef IMPORTPOSITION
 366 #undef IMPORTDISPOSITION
 367
 368 #define ZOOMFOCUS(NAME) .addConst (stringify(NAME), (Editing::ZoomFocus)Editing::NAME)
 369 #define SNAPTYPE(NAME) .addConst (stringify(NAME), (Editing::SnapType)Editing::NAME)
 370 #define SNAPMODE(NAME) .addConst (stringify(NAME), (Editing::SnapMode)Editing::NAME)
 371 #define MOUSEMODE(NAME) .addConst (stringify(NAME), (Editing::MouseMode)Editing::NAME)
 372 #define DISPLAYCONTROL(NAME) .addConst (stringify(NAME), (Editing::DisplayControl)Editing::NAME)
 373 #define IMPORTMODE(NAME) .addConst (stringify(NAME), (Editing::ImportMode)Editing::NAME)
 374 #define IMPORTPOSITION(NAME) .addConst (stringify(NAME), (Editing::ImportPosition)Editing::NAME)
 375 #define IMPORTDISPOSITION(NAME) .addConst (stringify(NAME), (Editing::ImportDisposition)Editing::NAME)
 376         luabridge::getGlobalNamespace (L)
 377                 .beginNamespace ("Editing")
 378 #               include "editing_syms.h"
 379                 .endNamespace ();
 380 }
 381
 382 #undef xstr
 383 #undef stringify
 384
 385 ////////////////////////////////////////////////////////////////////////////////
 386
 387 using namespace ARDOUR;
 388 using namespace ARDOUR_UI_UTILS;
 389 using namespace PBD;
 390 using namespace std;
 391
 392 #ifndef NDEBUG
 393 static void _lua_print (std::string s) {
 394         std::cout << "LuaInstance: " << s << "\n";
 395 }
 396 #endif
 397
 398 LuaInstance* LuaInstance::_instance = 0;
 399
 400 LuaInstance*
 401 LuaInstance::instance ()
 402 {
 403         if (!_instance) {
 404                 _instance  = new LuaInstance;
 405         }
 406
 407         return _instance;
 408 }
 409
 410 LuaInstance::LuaInstance ()
 411 {
 412 #ifndef NDEBUG
 413         lua.Print.connect (&_lua_print);
 414 #endif
 415         init ();
 416
 417         LuaScriptParamList args;
 418 }
 419
 420 LuaInstance::~LuaInstance ()
 421 {
 422         delete _lua_call_action;
 423         delete _lua_add_action;
 424         delete _lua_del_action;
 425         delete _lua_get_action;
 426
 427         delete _lua_load;
 428         delete _lua_save;
 429         delete _lua_clear;
 430         _callbacks.clear();
 431 }
 432
 433 void
 434 LuaInstance::init ()
 435 {
 436         lua.do_command (
 437                         "function ScriptManager ()"
 438                         "  local self = { scripts = {}, instances = {} }"
 439                         ""
 440                         "  local remove = function (id)"
 441                         "   self.scripts[id] = nil"
 442                         "   self.instances[id] = nil"
 443                         "  end"
 444                         ""
 445                         "  local addinternal = function (i, n, s, f, a)"
 446                         "   assert(type(i) == 'number', 'id must be numeric')"
 447                         "   assert(type(n) == 'string', 'Name must be string')"
 448                         "   assert(type(s) == 'string', 'Script must be string')"
 449                         "   assert(type(f) == 'function', 'Factory is a not a function')"
 450                         "   assert(type(a) == 'table' or type(a) == 'nil', 'Given argument is invalid')"
 451                         "   self.scripts[i] = { ['n'] = n, ['s'] = s, ['f'] = f, ['a'] = a }"
 452                         "   local env = _ENV;  env.f = nil env.debug = nil os.exit = nil require = nil dofile = nil loadfile = nil package = nil"
 453                         "   self.instances[i] = load (string.dump(f, true), nil, nil, env)(a)"
 454                         "  end"
 455                         ""
 456                         "  local call = function (id)"
 457                         "   if type(self.instances[id]) == 'function' then"
 458                         "     local status, err = pcall (self.instances[id])"
 459                         "     if not status then"
 460                         "       print ('action \"'.. id .. '\": ', err)" // error out
 461                         "       remove (id)"
 462                         "     end"
 463                         "   end"
 464                         "   collectgarbage()"
 465                         "  end"
 466                         ""
 467                         "  local add = function (i, n, s, b, a)"
 468                         "   assert(type(b) == 'string', 'ByteCode must be string')"
 469                         "   load (b)()" // assigns f
 470                         "   assert(type(f) == 'string', 'Assigned ByteCode must be string')"
 471                         "   addinternal (i, n, s, load(f), a)"
 472                         "  end"
 473                         ""
 474                         "  local get = function (id)"
 475                         "   if type(self.scripts[id]) == 'table' then"
 476                         "    return { ['name'] = self.scripts[id]['n'],"
 477                         "             ['script'] = self.scripts[id]['s'],"
 478                         "             ['args'] = self.scripts[id]['a'] }"
 479                         "   end"
 480                         "   return nil"
 481                         "  end"
 482                         ""
 483                         "  local function basic_serialize (o)"
 484                         "    if type(o) == \"number\" then"
 485                         "     return tostring(o)"
 486                         "    else"
 487                         "     return string.format(\"%q\", o)"
 488                         "    end"
 489                         "  end"
 490                         ""
 491                         "  local function serialize (name, value)"
 492                         "   local rv = name .. ' = '"
 493                         "   collectgarbage()"
 494                         "   if type(value) == \"number\" or type(value) == \"string\" or type(value) == \"nil\" then"
 495                         "    return rv .. basic_serialize(value) .. ' '"
 496                         "   elseif type(value) == \"table\" then"
 497                         "    rv = rv .. '{} '"
 498                         "    for k,v in pairs(value) do"
 499                         "     local fieldname = string.format(\"%s[%s]\", name, basic_serialize(k))"
 500                         "     rv = rv .. serialize(fieldname, v) .. ' '"
 501                         "     collectgarbage()" // string concatenation allocates a new string
 502                         "    end"
 503                         "    return rv;"
 504                         "   elseif type(value) == \"function\" then"
 505                         "     return rv .. string.format(\"%q\", string.dump(value, true))"
 506                         "   else"
 507                         "    error('cannot save a ' .. type(value))"
 508                         "   end"
 509                         "  end"
 510                         ""
 511                         ""
 512                         "  local save = function ()"
 513                         "   return (serialize('scripts', self.scripts))"
 514                         "  end"
 515                         ""
 516                         "  local clear = function ()"
 517                         "   self.scripts = {}"
 518                         "   self.instances = {}"
 519                         "   collectgarbage()"
 520                         "  end"
 521                         ""
 522                         "  local restore = function (state)"
 523                         "   clear()"
 524                         "   load (state)()"
 525                         "   for i, s in pairs (scripts) do"
 526                         "    addinternal (i, s['n'], s['s'], load(s['f']), s['a'])"
 527                         "   end"
 528                         "   collectgarbage()"
 529                         "  end"
 530                         ""
 531                         " return { call = call, add = add, remove = remove, get = get,"
 532                         "          restore = restore, save = save, clear = clear}"
 533                         " end"
 534                         " "
 535                         " manager = ScriptManager ()"
 536                         " ScriptManager = nil"
 537                         );
 538
 539         lua_State* L = lua.getState();
 540
 541         try {
 542                 luabridge::LuaRef lua_mgr = luabridge::getGlobal (L, "manager");
 543                 lua.do_command ("manager = nil"); // hide it.
 544                 lua.do_command ("collectgarbage()");
 545
 546                 _lua_add_action = new luabridge::LuaRef(lua_mgr["add"]);
 547                 _lua_del_action = new luabridge::LuaRef(lua_mgr["remove"]);
 548                 _lua_get_action = new luabridge::LuaRef(lua_mgr["get"]);
 549                 _lua_call_action = new luabridge::LuaRef(lua_mgr["call"]);
 550                 _lua_save = new luabridge::LuaRef(lua_mgr["save"]);
 551                 _lua_load = new luabridge::LuaRef(lua_mgr["restore"]);
 552                 _lua_clear = new luabridge::LuaRef(lua_mgr["clear"]);
 553
 554         } catch (luabridge::LuaException const& e) {
 555                 fatal << string_compose (_("programming error: %1"),
 556                                 X_("Failed to setup Lua action interpreter"))
 557                         << endmsg;
 558                 abort(); /*NOTREACHED*/
 559         }
 560
 561         register_classes (L);
 562
 563         luabridge::push <PublicEditor *> (L, &PublicEditor::instance());
 564         lua_setglobal (L, "Editor");
 565 }
 566
 567 void LuaInstance::set_session (Session* s)
 568 {
 569         SessionHandlePtr::set_session (s);
 570         if (!_session) {
 571                 return;
 572         }
 573
 574         lua_State* L = lua.getState();
 575         LuaBindings::set_session (L, _session);
 576
 577         for (LuaCallbackMap::iterator i = _callbacks.begin(); i != _callbacks.end(); ++i) {
 578                 i->second->set_session (s);
 579         }
 580 }
 581
 582 void
 583 LuaInstance::session_going_away ()
 584 {
 585         ENSURE_GUI_THREAD (*this, &LuaInstance::session_going_away);
 586         (*_lua_clear)();
 587         for (int i = 0; i < 9; ++i) {
 588                 ActionChanged (i, ""); /* EMIT SIGNAL */
 589         }
 590         SessionHandlePtr::session_going_away ();
 591         _session = 0;
 592
 593         lua_State* L = lua.getState();
 594         LuaBindings::set_session (L, _session);
 595         lua.do_command ("collectgarbage();");
 596 }
 597
 598 int
 599 LuaInstance::set_state (const XMLNode& node)
 600 {
 601         LocaleGuard lg (X_("C"));
 602         XMLNode* child;
 603
 604         if ((child = find_named_node (node, "ActionScript"))) {
 605                 for (XMLNodeList::const_iterator n = child->children ().begin (); n != child->children ().end (); ++n) {
 606                         if (!(*n)->is_content ()) { continue; }
 607                         gsize size;
 608                         guchar* buf = g_base64_decode ((*n)->content ().c_str (), &size);
 609                         try {
 610                                 (*_lua_load)(std::string ((const char*)buf, size));
 611                         } catch (luabridge::LuaException const& e) {
 612                                 cerr << "LuaException:" << e.what () << endl;
 613                         }
 614                         for (int i = 0; i < 9; ++i) {
 615                                 std::string name;
 616                                 if (lua_action_name (i, name)) {
 617                                         ActionChanged (i, name); /* EMIT SIGNAL */
 618                                 }
 619                         }
 620                         g_free (buf);
 621                 }
 622         }
 623
 624         if ((child = find_named_node (node, "ActionHooks"))) {
 625                 for (XMLNodeList::const_iterator n = child->children ().begin (); n != child->children ().end (); ++n) {
 626                         try {
 627                                 LuaCallbackPtr p (new LuaCallback (_session, *(*n)));
 628                                 _callbacks.insert (std::make_pair(p->id(), p));
 629                                 p->drop_callback.connect (_slotcon, MISSING_INVALIDATOR, boost::bind (&LuaInstance::unregister_lua_slot, this, p->id()), gui_context());
 630                                 SlotChanged (p->id(), p->name(), p->signals()); /* EMIT SIGNAL */
 631                         } catch (luabridge::LuaException const& e) {
 632                                 cerr << "LuaException:" << e.what () << endl;
 633                         }
 634                 }
 635         }
 636
 637         return 0;
 638 }
 639
 640 bool
 641 LuaInstance::interactive_add (LuaScriptInfo::ScriptType type, int id)
 642 {
 643         std::string title;
 644         std::vector<std::string> reg;
 645
 646         switch (type) {
 647                 case LuaScriptInfo::EditorAction:
 648                         reg = lua_action_names ();
 649                         title = "Add Lua Action";
 650                         break;
 651                 case LuaScriptInfo::EditorHook:
 652                         reg = lua_slot_names ();
 653                         title = "Add Lua Callback Hook";
 654                         break;
 655                 default:
 656                         return false;
 657         }
 658
 659         LuaScriptInfoPtr spi;
 660         ScriptSelector ss (title, type);
 661         switch (ss.run ()) {
 662                 case Gtk::RESPONSE_ACCEPT:
 663                         spi = ss.script();
 664                         break;
 665                 default:
 666                         return false;
 667         }
 668         ss.hide ();
 669
 670         std::string script = "";
 671
 672         try {
 673                 script = Glib::file_get_contents (spi->path);
 674         } catch (Glib::FileError e) {
 675                 string msg = string_compose (_("Cannot read script '%1': %2"), spi->path, e.what());
 676                 Gtk::MessageDialog am (msg);
 677                 am.run ();
 678                 return false;
 679         }
 680
 681         LuaScriptParamList lsp = LuaScriptParams::script_params (spi, "action_params");
 682
 683         ScriptParameterDialog spd (_("Set Script Parameters"), spi, reg, lsp);
 684         switch (spd.run ()) {
 685                 case Gtk::RESPONSE_ACCEPT:
 686                         break;
 687                 default:
 688                         return false;
 689         }
 690
 691         switch (type) {
 692                 case LuaScriptInfo::EditorAction:
 693                         return set_lua_action (id, spd.name(), script, lsp);
 694                         break;
 695                 case LuaScriptInfo::EditorHook:
 696                         return register_lua_slot (spd.name(), script, lsp);
 697                         break;
 698                 default:
 699                         break;
 700         }
 701         return false;
 702 }
 703
 704 XMLNode&
 705 LuaInstance::get_action_state ()
 706 {
 707         LocaleGuard lg (X_("C"));
 708         std::string saved;
 709         {
 710                 luabridge::LuaRef savedstate ((*_lua_save)());
 711                 saved = savedstate.cast<std::string>();
 712         }
 713         lua.collect_garbage ();
 714
 715         gchar* b64 = g_base64_encode ((const guchar*)saved.c_str (), saved.size ());
 716         std::string b64s (b64);
 717         g_free (b64);
 718
 719         XMLNode* script_node = new XMLNode (X_("ActionScript"));
 720         script_node->add_property (X_("lua"), LUA_VERSION);
 721         script_node->add_content (b64s);
 722
 723         return *script_node;
 724 }
 725
 726 XMLNode&
 727 LuaInstance::get_hook_state ()
 728 {
 729         XMLNode* script_node = new XMLNode (X_("ActionHooks"));
 730         for (LuaCallbackMap::const_iterator i = _callbacks.begin(); i != _callbacks.end(); ++i) {
 731                 script_node->add_child_nocopy (i->second->get_state ());
 732         }
 733         return *script_node;
 734 }
 735
 736 void
 737 LuaInstance::call_action (const int id)
 738 {
 739         try {
 740                 (*_lua_call_action)(id + 1);
 741         } catch (luabridge::LuaException const& e) {
 742                 cerr << "LuaException:" << e.what () << endl;
 743         }
 744 }
 745
 746 bool
 747 LuaInstance::set_lua_action (
 748                 const int id,
 749                 const std::string& name,
 750                 const std::string& script,
 751                 const LuaScriptParamList& args)
 752 {
 753         try {
 754                 lua_State* L = lua.getState();
 755                 // get bytcode of factory-function in a sandbox
 756                 // (don't allow scripts to interfere)
 757                 const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
 758                 luabridge::LuaRef tbl_arg (luabridge::newTable(L));
 759                 for (LuaScriptParamList::const_iterator i = args.begin(); i != args.end(); ++i) {
 760                         if ((*i)->optional && !(*i)->is_set) { continue; }
 761                         tbl_arg[(*i)->name] = (*i)->value;
 762                 }
 763                 (*_lua_add_action)(id + 1, name, script, bytecode, tbl_arg);
 764                 ActionChanged (id, name); /* EMIT SIGNAL */
 765         } catch (luabridge::LuaException const& e) {
 766                 cerr << "LuaException:" << e.what () << endl;
 767                 return false;
 768         }
 769         return true;
 770 }
 771
 772 bool
 773 LuaInstance::remove_lua_action (const int id)
 774 {
 775         try {
 776                 (*_lua_del_action)(id + 1);
 777         } catch (luabridge::LuaException const& e) {
 778                 cerr << "LuaException:" << e.what () << endl;
 779                 return false;
 780         }
 781         ActionChanged (id, ""); /* EMIT SIGNAL */
 782         return true;
 783 }
 784
 785 bool
 786 LuaInstance::lua_action_name (const int id, std::string& rv)
 787 {
 788         try {
 789                 luabridge::LuaRef ref ((*_lua_get_action)(id + 1));
 790                 if (ref.isNil()) {
 791                         return false;
 792                 }
 793                 if (ref["name"].isString()) {
 794                         rv = ref["name"].cast<std::string>();
 795                         return true;
 796                 }
 797                 return true;
 798         } catch (luabridge::LuaException const& e) {
 799                 cerr << "LuaException:" << e.what () << endl;
 800                 return false;
 801         }
 802         return false;
 803 }
 804
 805 std::vector<std::string>
 806 LuaInstance::lua_action_names ()
 807 {
 808         std::vector<std::string> rv;
 809         for (int i = 0; i < 9; ++i) {
 810                 std::string name;
 811                 if (lua_action_name (i, name)) {
 812                         rv.push_back (name);
 813                 }
 814         }
 815         return rv;
 816 }
 817
 818 bool
 819 LuaInstance::lua_action (const int id, std::string& name, std::string& script, LuaScriptParamList& args)
 820 {
 821         try {
 822                 luabridge::LuaRef ref ((*_lua_get_action)(id + 1));
 823                 if (ref.isNil()) {
 824                         return false;
 825                 }
 826                 if (!ref["name"].isString()) {
 827                         return false;
 828                 }
 829                 if (!ref["script"].isString()) {
 830                         return false;
 831                 }
 832                 if (!ref["args"].isTable()) {
 833                         return false;
 834                 }
 835                 name = ref["name"].cast<std::string>();
 836                 script = ref["script"].cast<std::string>();
 837
 838                 args.clear();
 839                 LuaScriptInfoPtr lsi = LuaScripting::script_info (script);
 840                 if (!lsi) {
 841                         return false;
 842                 }
 843                 args = LuaScriptParams::script_params (lsi, "action_params");
 844                 luabridge::LuaRef rargs (ref["args"]);
 845                 LuaScriptParams::ref_to_params (args, &rargs);
 846                 return true;
 847         } catch (luabridge::LuaException const& e) {
 848                 cerr << "LuaException:" << e.what () << endl;
 849                 return false;
 850         }
 851         return false;
 852 }
 853
 854 bool
 855 LuaInstance::register_lua_slot (const std::string& name, const std::string& script, const ARDOUR::LuaScriptParamList& args)
 856 {
 857         /* parse script, get ActionHook(s) from script */
 858         ActionHook ah;
 859         try {
 860                 LuaState l;
 861 #ifndef NDEBUG
 862                 l.Print.connect (&_lua_print);
 863 #endif
 864                 lua_State* L = l.getState();
 865                 register_hooks (L);
 866                 l.do_command ("function ardour () end");
 867                 l.do_command (script);
 868                 luabridge::LuaRef signals = luabridge::getGlobal (L, "signals");
 869                 if (signals.isFunction()) {
 870                         ah = signals();
 871                 }
 872         } catch (luabridge::LuaException const& e) {
 873                 cerr << "LuaException:" << e.what () << endl;
 874         }
 875
 876         if (ah.none ()) {
 877                 cerr << "Script registered no hooks." << endl;
 878                 return false;
 879         }
 880
 881         /* register script w/args, get entry-point / ID */
 882
 883         try {
 884                 LuaCallbackPtr p (new LuaCallback (_session, name, script, ah, args));
 885                 _callbacks.insert (std::make_pair(p->id(), p));
 886                 p->drop_callback.connect (_slotcon, MISSING_INVALIDATOR, boost::bind (&LuaInstance::unregister_lua_slot, this, p->id()), gui_context());
 887                 SlotChanged (p->id(), p->name(), p->signals()); /* EMIT SIGNAL */
 888                 return true;
 889         } catch (luabridge::LuaException const& e) {
 890                 cerr << "LuaException:" << e.what () << endl;
 891         }
 892         return false;
 893 }
 894
 895 bool
 896 LuaInstance::unregister_lua_slot (const PBD::ID& id)
 897 {
 898         LuaCallbackMap::iterator i = _callbacks.find (id);
 899         if (i != _callbacks.end()) {
 900                 SlotChanged (id, "", ActionHook()); /* EMIT SIGNAL */
 901                 _callbacks.erase (i);
 902                 return true;
 903         }
 904         return false;
 905 }
 906
 907 std::vector<PBD::ID>
 908 LuaInstance::lua_slots () const
 909 {
 910         std::vector<PBD::ID> rv;
 911         for (LuaCallbackMap::const_iterator i = _callbacks.begin(); i != _callbacks.end(); ++i) {
 912                 rv.push_back (i->first);
 913         }
 914         return rv;
 915 }
 916
 917 bool
 918 LuaInstance::lua_slot_name (const PBD::ID& id, std::string& name) const
 919 {
 920         LuaCallbackMap::const_iterator i = _callbacks.find (id);
 921         if (i != _callbacks.end()) {
 922                 name = i->second->name();
 923                 return true;
 924         }
 925         return false;
 926 }
 927
 928 std::vector<std::string>
 929 LuaInstance::lua_slot_names () const
 930 {
 931         std::vector<std::string> rv;
 932         std::vector<PBD::ID> ids = lua_slots();
 933         for (std::vector<PBD::ID>::const_iterator i = ids.begin(); i != ids.end(); ++i) {
 934                 std::string name;
 935                 if (lua_slot_name (*i, name)) {
 936                         rv.push_back (name);
 937                 }
 938         }
 939         return rv;
 940 }
 941
 942 bool
 943 LuaInstance::lua_slot (const PBD::ID& id, std::string& name, std::string& script, ActionHook& ah, ARDOUR::LuaScriptParamList& args)
 944 {
 945         LuaCallbackMap::const_iterator i = _callbacks.find (id);
 946         if (i == _callbacks.end()) {
 947                 return false; // error
 948         }
 949         return i->second->lua_slot (name, script, ah, args);
 950 }
 951
 952 ///////////////////////////////////////////////////////////////////////////////
 953
 954 LuaCallback::LuaCallback (Session *s,
 955                 const std::string& name,
 956                 const std::string& script,
 957                 const ActionHook& ah,
 958                 const ARDOUR::LuaScriptParamList& args)
 959         : SessionHandlePtr (s)
 960         , _id ("0")
 961         , _name (name)
 962         , _signals (ah)
 963 {
 964         // TODO: allow to reference object (e.g region)
 965         init ();
 966
 967         lua_State* L = lua.getState();
 968         luabridge::LuaRef tbl_arg (luabridge::newTable(L));
 969         for (LuaScriptParamList::const_iterator i = args.begin(); i != args.end(); ++i) {
 970                 if ((*i)->optional && !(*i)->is_set) { continue; }
 971                 tbl_arg[(*i)->name] = (*i)->value;
 972         }
 973
 974         try {
 975         const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
 976         (*_lua_add)(name, script, bytecode, tbl_arg);
 977         } catch (luabridge::LuaException const& e) {
 978                 cerr << "LuaException:" << e.what () << endl;
 979                 throw failed_constructor ();
 980         }
 981
 982         _id.reset ();
 983         set_session (s);
 984 }
 985
 986 LuaCallback::LuaCallback (Session *s, XMLNode & node)
 987         : SessionHandlePtr (s)
 988 {
 989         XMLNode* child = NULL;
 990         if (node.name() != X_("LuaCallback")
 991                         || !node.property ("signals")
 992                         || !node.property ("id")
 993                         || !node.property ("name")) {
 994                 throw failed_constructor ();
 995         }
 996
 997         for (XMLNodeList::const_iterator n = node.children ().begin (); n != node.children ().end (); ++n) {
 998                 if (!(*n)->is_content ()) { continue; }
 999                 child = *n;
1000         }
1001
1002         if (!child) {
1003                 throw failed_constructor ();
1004         }
1005
1006         init ();
1007
1008         _id = PBD::ID (node.property ("id")->value ());
1009         _name = node.property ("name")->value ();
1010         _signals = ActionHook (node.property ("signals")->value ());
1011
1012         gsize size;
1013         guchar* buf = g_base64_decode (child->content ().c_str (), &size);
1014         try {
1015                 (*_lua_load)(std::string ((const char*)buf, size));
1016         } catch (luabridge::LuaException const& e) {
1017                 cerr << "LuaException:" << e.what () << endl;
1018         }
1019         g_free (buf);
1020
1021         set_session (s);
1022 }
1023
1024 LuaCallback::~LuaCallback ()
1025 {
1026         delete _lua_add;
1027         delete _lua_get;
1028         delete _lua_call;
1029         delete _lua_load;
1030         delete _lua_save;
1031 }
1032
1033 XMLNode&
1034 LuaCallback::get_state (void)
1035 {
1036         std::string saved;
1037         {
1038                 luabridge::LuaRef savedstate ((*_lua_save)());
1039                 saved = savedstate.cast<std::string>();
1040         }
1041         lua.collect_garbage ();
1042
1043         gchar* b64 = g_base64_encode ((const guchar*)saved.c_str (), saved.size ());
1044         std::string b64s (b64);
1045         g_free (b64);
1046
1047         XMLNode* script_node = new XMLNode (X_("LuaCallback"));
1048         script_node->add_property (X_("lua"), LUA_VERSION);
1049         script_node->add_property (X_("id"), _id.to_s ());
1050         script_node->add_property (X_("name"), _name);
1051         script_node->add_property (X_("signals"), _signals.to_string ());
1052         script_node->add_content (b64s);
1053         return *script_node;
1054 }
1055
1056 void
1057 LuaCallback::init (void)
1058 {
1059 #ifndef NDEBUG
1060         lua.Print.connect (&_lua_print);
1061 #endif
1062
1063         lua.do_command (
1064                         "function ScriptManager ()"
1065                         "  local self = { script = {}, instance = {} }"
1066                         ""
1067                         "  local addinternal = function (n, s, f, a)"
1068                         "   assert(type(n) == 'string', 'Name must be string')"
1069                         "   assert(type(s) == 'string', 'Script must be string')"
1070                         "   assert(type(f) == 'function', 'Factory is a not a function')"
1071                         "   assert(type(a) == 'table' or type(a) == 'nil', 'Given argument is invalid')"
1072                         "   self.script = { ['n'] = n, ['s'] = s, ['f'] = f, ['a'] = a }"
1073                         "   local env = _ENV;  env.f = nil env.debug = nil os.exit = nil require = nil dofile = nil loadfile = nil package = nil"
1074                         "   self.instance = load (string.dump(f, true), nil, nil, env)(a)"
1075                         "  end"
1076                         ""
1077                         "  local call = function (...)"
1078                         "   if type(self.instance) == 'function' then"
1079                         "     local status, err = pcall (self.instance, ...)"
1080                         "     if not status then"
1081                         "       print ('callback \"'.. self.script['n'] .. '\": ', err)" // error out
1082                         "       self.script = nil"
1083                         "       self.instance = nil"
1084                         "       return false"
1085                         "     end"
1086                         "   end"
1087                         "   collectgarbage()"
1088                         "   return true"
1089                         "  end"
1090                         ""
1091                         "  local add = function (n, s, b, a)"
1092                         "   assert(type(b) == 'string', 'ByteCode must be string')"
1093                         "   load (b)()" // assigns f
1094                         "   assert(type(f) == 'string', 'Assigned ByteCode must be string')"
1095                         "   addinternal (n, s, load(f), a)"
1096                         "  end"
1097                         ""
1098                         "  local get = function ()"
1099                         "   if type(self.instance) == 'function' and type(self.script['n']) == 'string' then"
1100                         "    return { ['name'] = self.script['n'],"
1101                         "             ['script'] = self.script['s'],"
1102                         "             ['args'] = self.script['a'] }"
1103                         "   end"
1104                         "   return nil"
1105                         "  end"
1106                         ""
1107                         // code dup
1108                         ""
1109                         "  local function basic_serialize (o)"
1110                         "    if type(o) == \"number\" then"
1111                         "     return tostring(o)"
1112                         "    else"
1113                         "     return string.format(\"%q\", o)"
1114                         "    end"
1115                         "  end"
1116                         ""
1117                         "  local function serialize (name, value)"
1118                         "   local rv = name .. ' = '"
1119                         "   collectgarbage()"
1120                         "   if type(value) == \"number\" or type(value) == \"string\" or type(value) == \"nil\" then"
1121                         "    return rv .. basic_serialize(value) .. ' '"
1122                         "   elseif type(value) == \"table\" then"
1123                         "    rv = rv .. '{} '"
1124                         "    for k,v in pairs(value) do"
1125                         "     local fieldname = string.format(\"%s[%s]\", name, basic_serialize(k))"
1126                         "     rv = rv .. serialize(fieldname, v) .. ' '"
1127                         "     collectgarbage()" // string concatenation allocates a new string
1128                         "    end"
1129                         "    return rv;"
1130                         "   elseif type(value) == \"function\" then"
1131                         "     return rv .. string.format(\"%q\", string.dump(value, true))"
1132                         "   else"
1133                         "    error('cannot save a ' .. type(value))"
1134                         "   end"
1135                         "  end"
1136                         ""
1137                         // end code dup
1138                         ""
1139                         "  local save = function ()"
1140                         "   return (serialize('s', self.script))"
1141                         "  end"
1142                         ""
1143                         "  local restore = function (state)"
1144                         "   self.script = {}"
1145                         "   load (state)()"
1146                         "   addinternal (s['n'], s['s'], load(s['f']), s['a'])"
1147                         "  end"
1148                         ""
1149                         " return { call = call, add = add, get = get,"
1150                         "          restore = restore, save = save}"
1151                         " end"
1152                         " "
1153                         " manager = ScriptManager ()"
1154                         " ScriptManager = nil"
1155                         );
1156
1157         lua_State* L = lua.getState();
1158
1159         try {
1160                 luabridge::LuaRef lua_mgr = luabridge::getGlobal (L, "manager");
1161                 lua.do_command ("manager = nil"); // hide it.
1162                 lua.do_command ("collectgarbage()");
1163
1164                 _lua_add = new luabridge::LuaRef(lua_mgr["add"]);
1165                 _lua_get = new luabridge::LuaRef(lua_mgr["get"]);
1166                 _lua_call = new luabridge::LuaRef(lua_mgr["call"]);
1167                 _lua_save = new luabridge::LuaRef(lua_mgr["save"]);
1168                 _lua_load = new luabridge::LuaRef(lua_mgr["restore"]);
1169
1170         } catch (luabridge::LuaException const& e) {
1171                 fatal << string_compose (_("programming error: %1"),
1172                                 X_("Failed to setup Lua callback interpreter"))
1173                         << endmsg;
1174                 abort(); /*NOTREACHED*/
1175         }
1176
1177         LuaInstance::register_classes (L);
1178
1179         luabridge::push <PublicEditor *> (L, &PublicEditor::instance());
1180         lua_setglobal (L, "Editor");
1181 }
1182
1183 bool
1184 LuaCallback::lua_slot (std::string& name, std::string& script, ActionHook& ah, ARDOUR::LuaScriptParamList& args)
1185 {
1186         // TODO consolidate w/ LuaInstance::lua_action()
1187         try {
1188                 luabridge::LuaRef ref = (*_lua_get)();
1189                 if (ref.isNil()) {
1190                         return false;
1191                 }
1192                 if (!ref["name"].isString()) {
1193                         return false;
1194                 }
1195                 if (!ref["script"].isString()) {
1196                         return false;
1197                 }
1198                 if (!ref["args"].isTable()) {
1199                         return false;
1200                 }
1201
1202                 ah = _signals;
1203                 name = ref["name"].cast<std::string> ();
1204                 script = ref["script"].cast<std::string> ();
1205
1206                 args.clear();
1207                 LuaScriptInfoPtr lsi = LuaScripting::script_info (script);
1208                 if (!lsi) {
1209                         return false;
1210                 }
1211                 args = LuaScriptParams::script_params (lsi, "action_params");
1212                 luabridge::LuaRef rargs (ref["args"]);
1213                 LuaScriptParams::ref_to_params (args, &rargs);
1214                 return true;
1215         } catch (luabridge::LuaException const& e) {
1216                 cerr << "LuaException:" << e.what () << endl;
1217                 return false;
1218         }
1219         return false;
1220 }
1221
1222 void
1223 LuaCallback::set_session (ARDOUR::Session *s)
1224 {
1225         SessionHandlePtr::set_session (s);
1226
1227         if (_session) {
1228                 lua_State* L = lua.getState();
1229                 LuaBindings::set_session (L, _session);
1230         }
1231
1232         reconnect();
1233 }
1234
1235 void
1236 LuaCallback::session_going_away ()
1237 {
1238         ENSURE_GUI_THREAD (*this, &LuaCallback::session_going_away);
1239         lua.do_command ("collectgarbage();");
1240
1241         SessionHandlePtr::session_going_away ();
1242         _session = 0;
1243
1244         drop_callback (); /* EMIT SIGNAL */
1245 }
1246
1247 void
1248 LuaCallback::reconnect ()
1249 {
1250         _connections.drop_connections ();
1251         if ((*_lua_get) ().isNil ()) {
1252                 drop_callback (); /* EMIT SIGNAL */
1253                 return;
1254         }
1255
1256         // TODO pass object which emits the signal (e.g region)
1257         //
1258         // save/load bound objects will be tricky.
1259         // Best idea so far is to save/lookup the PBD::ID
1260         // (either use boost::any indirection or templates for bindable
1261         // object types or a switch statement..)
1262         //
1263         // _session->route_by_id ()
1264         // _session->track_by_diskstream_id ()
1265         // _session->source_by_id ()
1266         // _session->controllable_by_id ()
1267         // _session->processor_by_id ()
1268         // RegionFactory::region_by_id ()
1269         //
1270         // TODO loop over objects (if any)
1271
1272         reconnect_object ((void*)0);
1273 }
1274
1275 template <class T> void
1276 LuaCallback::reconnect_object (T obj)
1277 {
1278         for (uint32_t i = 0; i < LuaSignal::LAST_SIGNAL; ++i) {
1279                 if (_signals[i]) {
1280 #define ENGINE(n,c,p) else if (i == LuaSignal::n) { connect_ ## p (LuaSignal::n, AudioEngine::instance(), &(AudioEngine::instance()->c)); }
1281 #define SESSION(n,c,p) else if (i == LuaSignal::n) { if (_session) { connect_ ## p (LuaSignal::n, _session, &(_session->c)); } }
1282 #define STATIC(n,c,p) else if (i == LuaSignal::n) { connect_ ## p (LuaSignal::n, obj, c); }
1283                         if (0) {}
1284 #                       include "luasignal_syms.h"
1285                         else {
1286                                 PBD::fatal << string_compose (_("programming error: %1: %2"), "Impossible LuaSignal type", i) << endmsg;
1287                                 abort(); /*NOTREACHED*/
1288                         }
1289 #undef ENGINE
1290 #undef SESSION
1291 #undef STATIC
1292                 }
1293         }
1294 }
1295
1296 template <typename T, typename S> void
1297 LuaCallback::connect_0 (enum LuaSignal::LuaSignal ls, T ref, S *signal) {
1298         signal->connect (
1299                         _connections, invalidator (*this),
1300                         boost::bind (&LuaCallback::proxy_0<T>, this, ls, ref),
1301                         gui_context());
1302 }
1303
1304 template <typename T, typename C1> void
1305 LuaCallback::connect_1 (enum LuaSignal::LuaSignal ls, T ref, PBD::Signal1<void, C1> *signal) {
1306         signal->connect (
1307                         _connections, invalidator (*this),
1308                         boost::bind (&LuaCallback::proxy_1<T, C1>, this, ls, ref, _1),
1309                         gui_context());
1310 }
1311
1312 template <typename T, typename C1, typename C2> void
1313 LuaCallback::connect_2 (enum LuaSignal::LuaSignal ls, T ref, PBD::Signal2<void, C1, C2> *signal) {
1314         signal->connect (
1315                         _connections, invalidator (*this),
1316                         boost::bind (&LuaCallback::proxy_2<T, C1, C2>, this, ls, ref, _1, _2),
1317                         gui_context());
1318 }
1319
1320 template <typename T> void
1321 LuaCallback::proxy_0 (enum LuaSignal::LuaSignal ls, T ref) {
1322         luabridge::LuaRef rv ((*_lua_call)((int)ls, ref));
1323         if (! rv.cast<bool> ()) { drop_callback (); /* EMIT SIGNAL */}
1324 }
1325
1326 template <typename T, typename C1> void
1327 LuaCallback::proxy_1 (enum LuaSignal::LuaSignal ls, T ref, C1 a1) {
1328         luabridge::LuaRef rv ((*_lua_call)((int)ls, ref, a1));
1329         if (! rv.cast<bool> ()) { drop_callback (); /* EMIT SIGNAL */}
1330 }
1331
1332 template <typename T, typename C1, typename C2> void
1333 LuaCallback::proxy_2 (enum LuaSignal::LuaSignal ls, T ref, C1 a1, C2 a2) {
1334         luabridge::LuaRef rv ((*_lua_call)((int)ls, ref, a1, a2));
1335         if (! rv.cast<bool> ()) { drop_callback (); /* EMIT SIGNAL */}
1336 }