X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fluainstance.cc;h=c8a4fe9e3b09f9033d1f7e72fee18555d6d85acd;hb=1e4e97019da3e90f89614da51ac537ed2041bb55;hp=d8ec0a20f2bcf32f37fca3b7cc02b7963619a51d;hpb=2b943ea36c128819d808087f853977fdd8e5c09d;p=ardour.git diff --git a/gtk2_ardour/luainstance.cc b/gtk2_ardour/luainstance.cc index d8ec0a20f2..c8a4fe9e3b 100644 --- a/gtk2_ardour/luainstance.cc +++ b/gtk2_ardour/luainstance.cc @@ -17,6 +17,8 @@ */ #include +#include +#include #include "gtkmm2ext/gui_thread.h" @@ -28,16 +30,298 @@ #include "LuaBridge/LuaBridge.h" +#include "ardour_http.h" #include "ardour_ui.h" #include "public_editor.h" #include "region_selection.h" #include "luainstance.h" #include "luasignal.h" +#include "marker.h" +#include "region_view.h" +#include "processor_box.h" #include "time_axis_view.h" +#include "time_axis_view_item.h" #include "selection.h" #include "script_selector.h" +#include "timers.h" +#include "utils_videotl.h" -#include "i18n.h" +#include "pbd/i18n.h" + +namespace LuaCairo { +/** wrap RefPtr< Cairo::ImageSurface > + * + * Image surfaces provide the ability to render to memory buffers either + * allocated by cairo or by the calling code. The supported image formats are + * those defined in Cairo::Format. + */ +class ImageSurface { + public: + /** + * Creates an image surface of the specified format and dimensions. Initially + * the surface contents are all 0. (Specifically, within each pixel, each + * color or alpha channel belonging to format will be 0. The contents of bits + * within a pixel, but not belonging to the given format are undefined). + * + * @param format format of pixels in the surface to create + * @param width width of the surface, in pixels + * @param height height of the surface, in pixels + */ + ImageSurface (Cairo::Format format, int width, int height) + : _surface (Cairo::ImageSurface::create (format, width, height)) + , _ctx (Cairo::Context::create (_surface)) + , ctx (_ctx->cobj ()) {} + + ~ImageSurface () {} + + /** + * Set this surface as source for another context. + * This allows to draw this surface + */ + void set_as_source (Cairo::Context* c, int x, int y) { + _surface->flush (); + c->set_source (_surface, x, y); + } + + /** + * Returns a context object to perform operations on the surface + */ + Cairo::Context* context () { + return (Cairo::Context *)&ctx; + } + + /** + * Returns the stride of the image surface in bytes (or 0 if surface is not + * an image surface). The stride is the distance in bytes from the beginning + * of one row of the image data to the beginning of the next row. + */ + int get_stride () const { + return _surface->get_stride (); + } + + /** Gets the width of the ImageSurface in pixels */ + int get_width () const { + return _surface->get_width (); + } + + /** Gets the height of the ImageSurface in pixels */ + int get_height () const { + return _surface->get_height (); + } + + /** + * Get a pointer to the data of the image surface, for direct + * inspection or modification. + * + * Return value: a pointer to the image data of this surface or NULL + * if @surface is not an image surface. + * + */ + unsigned char* get_data () { + return _surface->get_data (); + } + + /** Tells cairo to consider the data buffer dirty. + * + * In particular, if you've created an ImageSurface with a data buffer that + * you've allocated yourself and you draw to that data buffer using means + * other than cairo, you must call mark_dirty() before doing any additional + * drawing to that surface with cairo. + * + * Note that if you do draw to the Surface outside of cairo, you must call + * flush() before doing the drawing. + */ + void mark_dirty () { + _surface->mark_dirty (); + } + + /** Marks a rectangular area of the given surface dirty. + * + * @param x X coordinate of dirty rectangle + * @param y Y coordinate of dirty rectangle + * @param width width of dirty rectangle + * @param height height of dirty rectangle + */ + void mark_dirty (int x, int y, int width, int height) { + _surface->mark_dirty (x, y, width, height); + } + + private: + Cairo::RefPtr _surface; + Cairo::RefPtr _ctx; + Cairo::Context ctx; +}; + +class PangoLayout { + public: + /** Create a new PangoLayout Text Display + * @param c CairoContext for the layout + * @param font_name a font-description e.g. "Mono 8px" + */ + PangoLayout (Cairo::Context* c, std::string font_name) { + ::PangoLayout* pl = pango_cairo_create_layout (c->cobj ()); + _layout = Glib::wrap (pl); + Pango::FontDescription fd (font_name); + _layout->set_font_description (fd); + } + + ~PangoLayout () {} + + /** Gets the text in the layout. The returned text should not + * be freed or modified. + * + * @return The text in the @a layout. + */ + std::string get_text () const { + return _layout->get_text (); + } + /** Set the text of the layout. + * @param text The text for the layout. + */ + void set_text (const std::string& text) { + _layout->set_text (text); + } + + /** Sets the layout text and attribute list from marked-up text (see markup format). + * Replaces the current text and attribute list. + * @param markup Some marked-up text. + */ + void set_markup (const std::string& markup) { + _layout->set_markup (markup); + } + + /** Sets the width to which the lines of the Pango::Layout should wrap or + * ellipsized. The default value is -1: no width set. + * + * @param width The desired width in Pango units, or -1 to indicate that no + * wrapping or ellipsization should be performed. + */ + void set_width (int width) { + _layout->set_width (width * PANGO_SCALE); + } + + /** Gets the width to which the lines of the Pango::Layout should wrap. + * + * @return The width in Pango units, or -1 if no width set. + */ + int get_width () const { + return _layout->get_width () / PANGO_SCALE; + } + + /** Sets the type of ellipsization being performed for @a layout. + * Depending on the ellipsization mode @a ellipsize text is + * removed from the start, middle, or end of text so they + * fit within the width and height of layout set with + * set_width() and set_height(). + * + * If the layout contains characters such as newlines that + * force it to be layed out in multiple paragraphs, then whether + * each paragraph is ellipsized separately or the entire layout + * is ellipsized as a whole depends on the set height of the layout. + * See set_height() for details. + * + * @param ellipsize The new ellipsization mode for @a layout. + */ + void set_ellipsize (Pango::EllipsizeMode ellipsize) { + _layout->set_ellipsize (ellipsize); + } + + /** Gets the type of ellipsization being performed for @a layout. + * See set_ellipsize() + * + * @return The current ellipsization mode for @a layout. + * + * Use is_ellipsized() to query whether any paragraphs + * were actually ellipsized. + */ + Pango::EllipsizeMode get_ellipsize () const { + return _layout->get_ellipsize (); + } + + /** Queries whether the layout had to ellipsize any paragraphs. + * + * This returns true if the ellipsization mode for @a layout + * is not Pango::ELLIPSIZE_NONE, a positive width is set on @a layout, + * and there are paragraphs exceeding that width that have to be + * ellipsized. + * + * @return true if any paragraphs had to be ellipsized, false + * otherwise. + */ + bool is_ellipsized () const { + return _layout->is_ellipsized (); + } + + /** Sets the wrap mode; the wrap mode only has effect if a width + * is set on the layout with set_width(). + * To turn off wrapping, set the width to -1. + * + * @param wrap The wrap mode. + */ + void set_wrap (Pango::WrapMode wrap) { + _layout->set_width (wrap); + } + + /** Gets the wrap mode for the layout. + * + * Use is_wrapped() to query whether any paragraphs + * were actually wrapped. + * + * @return Active wrap mode. + */ + Pango::WrapMode get_wrap () const { + return _layout->get_wrap (); + } + + /** Queries whether the layout had to wrap any paragraphs. + * + * This returns true if a positive width is set on @a layout, + * ellipsization mode of @a layout is set to Pango::ELLIPSIZE_NONE, + * and there are paragraphs exceeding the layout width that have + * to be wrapped. + * + * @return true if any paragraphs had to be wrapped, false + * otherwise. + */ + bool is_wrapped () const { + return _layout->is_wrapped (); + } + + /** Determines the logical width and height of a Pango::Layout + * in device units. + */ + int get_pixel_size (lua_State *L) { + int width, height; + _layout->get_pixel_size (width, height); + luabridge::Stack::push (L, width); + luabridge::Stack::push (L, height); + return 2; + } + + + /** Draws a Layout in the specified Cairo @a context. The top-left + * corner of the Layout will be drawn at the current point of the + * cairo context. + * + * @param context A Cairo context. + */ + void show_in_cairo_context (Cairo::Context* c) { + pango_cairo_update_layout (c->cobj (), _layout->gobj()); + pango_cairo_show_layout (c->cobj (), _layout->gobj()); + } + + void layout_cairo_path (Cairo::Context* c) { + pango_cairo_update_layout (c->cobj (), _layout->gobj()); + pango_cairo_layout_path (c->cobj (), _layout->gobj()); + } + + private: + Glib::RefPtr _layout; +}; + +}; // namespace + +//////////////////////////////////////////////////////////////////////////////// namespace LuaSignal { @@ -72,6 +356,17 @@ const char *luasignalstr[] = { #undef ENGINE }; // namespace + +/** special cases for Ardour's Mixer UI */ +namespace LuaMixer { + + ProcessorBox::ProcSelection + processor_selection () { + return ProcessorBox::current_processor_selection (); + } + +}; + //////////////////////////////////////////////////////////////////////////////// #define xstr(s) stringify(s) @@ -79,6 +374,8 @@ const char *luasignalstr[] = { using namespace ARDOUR; +PBD::Signal0 LuaInstance::LuaTimerDS; + void LuaInstance::register_hooks (lua_State* L) { @@ -180,6 +477,52 @@ LuaInstance::bind_cairo (lua_State* L) .addConst ("Add", CAIRO_OPERATOR_ADD) .endNamespace () + .beginNamespace ("Format") + .addConst ("ARGB32", CAIRO_FORMAT_ARGB32) + .addConst ("RGB24", CAIRO_FORMAT_RGB24) + .endNamespace () + + .beginClass ("ImageSurface") + .addConstructor () + .addFunction ("set_as_source", &LuaCairo::ImageSurface::set_as_source) + .addFunction ("context", &LuaCairo::ImageSurface::context) + .addFunction ("get_stride", &LuaCairo::ImageSurface::get_stride) + .addFunction ("get_width", &LuaCairo::ImageSurface::get_width) + .addFunction ("get_height", &LuaCairo::ImageSurface::get_height) + //.addFunction ("get_data", &LuaCairo::ImageSurface::get_data) // uint8_t* array is n/a + .endClass () + + .beginClass ("PangoLayout") + .addConstructor () + .addCFunction ("get_pixel_size", &LuaCairo::PangoLayout::get_pixel_size) + .addFunction ("get_text", &LuaCairo::PangoLayout::get_text) + .addFunction ("set_text", &LuaCairo::PangoLayout::set_text) + .addFunction ("show_in_cairo_context", &LuaCairo::PangoLayout::show_in_cairo_context) + .addFunction ("layout_cairo_path", &LuaCairo::PangoLayout::layout_cairo_path) + .addFunction ("set_markup", &LuaCairo::PangoLayout::set_markup) + .addFunction ("set_width", &LuaCairo::PangoLayout::set_width) + .addFunction ("set_ellipsize", &LuaCairo::PangoLayout::set_ellipsize) + .addFunction ("get_ellipsize", &LuaCairo::PangoLayout::get_ellipsize) + .addFunction ("is_ellipsized", &LuaCairo::PangoLayout::is_ellipsized) + .addFunction ("set_wrap", &LuaCairo::PangoLayout::set_wrap) + .addFunction ("get_wrap", &LuaCairo::PangoLayout::get_wrap) + .addFunction ("is_wrapped", &LuaCairo::PangoLayout::is_wrapped) + .endClass () + + /* enums */ + .beginNamespace ("EllipsizeMode") + .addConst ("None", Pango::ELLIPSIZE_NONE) + .addConst ("Start", Pango::ELLIPSIZE_START) + .addConst ("Middle", Pango::ELLIPSIZE_MIDDLE) + .addConst ("End", Pango::ELLIPSIZE_END) + .endNamespace () + + .beginNamespace ("WrapMode") + .addConst ("Word", Pango::WRAP_WORD) + .addConst ("Char", Pango::WRAP_CHAR) + .addConst ("WordChar", Pango::WRAP_WORD_CHAR) + .endNamespace () + .endNamespace (); /* Lua/cairo bindings operate on Cairo::Context, there is no Cairo::RefPtr wrapper [yet]. @@ -218,12 +561,18 @@ LuaInstance::register_classes (lua_State* L) luabridge::getGlobalNamespace (L) .beginNamespace ("ArdourUI") - .beginClass ("RegionSelection") - .addFunction ("clear_all", &RegionSelection::clear_all) - .addFunction ("start", &RegionSelection::start) - .addFunction ("end_frame", &RegionSelection::end_frame) - .addFunction ("n_midi_regions", &RegionSelection::n_midi_regions) - .addFunction ("regionlist", &RegionSelection::regionlist) // XXX check windows binding (libardour) + + .addFunction ("http_get", (std::string (*)(const std::string&))&ArdourCurl::http_get) + + .addFunction ("processor_selection", &LuaMixer::processor_selection) + + .beginStdList ("ArdourMarkerList") + .endClass () + + .beginClass ("ArdourMarker") + .addFunction ("name", &ArdourMarker::name) + .addFunction ("position", &ArdourMarker::position) + .addFunction ("_type", &ArdourMarker::type) .endClass () #if 0 @@ -235,11 +584,30 @@ LuaInstance::register_classes (lua_State* L) .endClass () #endif - .beginClass ("Selection") - .addFunction ("clear", &Selection::clear) - .addFunction ("clear_all", &Selection::clear_all) - .addData ("tracks", &Selection::tracks) - .addData ("regions", &Selection::regions) + .beginClass ("Selectable") + .endClass () + .deriveClass ("TimeAxisViewItem") + .endClass () + .deriveClass ("RegionView") + .endClass () + + .beginStdCPtrList ("SelectionList") + .endClass () + + .beginClass ("RegionSelection") + .addFunction ("start", &RegionSelection::start) + .addFunction ("end_frame", &RegionSelection::end_frame) + .addFunction ("n_midi_regions", &RegionSelection::n_midi_regions) + .addFunction ("regionlist", &RegionSelection::regionlist) // XXX check windows binding (libardour) + .endClass () + + .deriveClass > ("TimeSelection") + .addFunction ("start", &TimeSelection::start) + .addFunction ("end_frame", &TimeSelection::end_frame) + .addFunction ("length", &TimeSelection::length) + .endClass () + + .deriveClass > ("MarkerSelection") .endClass () .beginClass ("TrackViewList") @@ -249,7 +617,21 @@ LuaInstance::register_classes (lua_State* L) .deriveClass ("TrackSelection") .endClass () - .beginClass ("ArdourMarker") + .beginClass ("Selection") + .addFunction ("clear", &Selection::clear) + .addFunction ("clear_all", &Selection::clear_all) + .addFunction ("empty", &Selection::empty) + .addData ("tracks", &Selection::tracks) + .addData ("regions", &Selection::regions) + .addData ("time", &Selection::time) + .addData ("markers", &Selection::markers) +#if 0 + .addData ("lines", &Selection::lines) + .addData ("playlists", &Selection::playlists) + .addData ("points", &Selection::points) + .addData ("midi_regions", &Selection::midi_regions) + .addData ("midi_notes", &Selection::midi_notes) // cut buffer only +#endif .endClass () .beginClass ("Editor") @@ -275,6 +657,8 @@ LuaInstance::register_classes (lua_State* L) .addFunction ("get_cut_buffer", &PublicEditor::get_cut_buffer) .addRefFunction ("get_selection_extents", &PublicEditor::get_selection_extents) + .addFunction ("set_selection", &PublicEditor::set_selection) + .addFunction ("play_selection", &PublicEditor::play_selection) .addFunction ("play_with_preroll", &PublicEditor::play_with_preroll) .addFunction ("maybe_locate_with_edit_preroll", &PublicEditor::maybe_locate_with_edit_preroll) @@ -320,6 +704,8 @@ LuaInstance::register_classes (lua_State* L) .addFunction ("set_selected_mixer_strip", &PublicEditor::set_selected_mixer_strip) .addFunction ("hide_track_in_display", &PublicEditor::hide_track_in_display) #endif + + .addFunction ("get_regionview_from_region", &PublicEditor::get_regionview_from_region) .addFunction ("set_stationary_playhead", &PublicEditor::set_stationary_playhead) .addFunction ("stationary_playhead", &PublicEditor::stationary_playhead) .addFunction ("set_follow_playhead", &PublicEditor::set_follow_playhead) @@ -396,7 +782,32 @@ LuaInstance::register_classes (lua_State* L) .addFunction ("access_action", &PublicEditor::access_action) .endClass () - .endNamespace (); + + /* ArdourUI enums */ + .beginNamespace ("MarkerType") + .addConst ("Mark", ArdourMarker::Type(ArdourMarker::Mark)) + .addConst ("Tempo", ArdourMarker::Type(ArdourMarker::Tempo)) + .addConst ("Meter", ArdourMarker::Type(ArdourMarker::Meter)) + .addConst ("SessionStart", ArdourMarker::Type(ArdourMarker::SessionStart)) + .addConst ("SessionEnd", ArdourMarker::Type(ArdourMarker::SessionEnd)) + .addConst ("RangeStart", ArdourMarker::Type(ArdourMarker::RangeStart)) + .addConst ("RangeEnd", ArdourMarker::Type(ArdourMarker::RangeEnd)) + .addConst ("LoopStart", ArdourMarker::Type(ArdourMarker::LoopStart)) + .addConst ("LoopEnd", ArdourMarker::Type(ArdourMarker::LoopEnd)) + .addConst ("PunchIn", ArdourMarker::Type(ArdourMarker::PunchIn)) + .addConst ("PunchOut", ArdourMarker::Type(ArdourMarker::PunchOut)) + .endNamespace () + + .beginNamespace ("SelectionOp") + .addConst ("Toggle", Selection::Operation(Selection::Toggle)) + .addConst ("Set", Selection::Operation(Selection::Set)) + .addConst ("Extend", Selection::Operation(Selection::Extend)) + .addConst ("Add", Selection::Operation(Selection::Add)) + .endNamespace () + + .endNamespace (); // end ArdourUI + + // Editing Symbols #undef ZOOMFOCUS #undef SNAPTYPE @@ -431,11 +842,12 @@ using namespace ARDOUR_UI_UTILS; using namespace PBD; using namespace std; -#ifndef NDEBUG static void _lua_print (std::string s) { +#ifndef NDEBUG std::cout << "LuaInstance: " << s << "\n"; -} #endif + PBD::info << "LuaInstance: " << s << endmsg; +} LuaInstance* LuaInstance::_instance = 0; @@ -449,11 +861,16 @@ LuaInstance::instance () return _instance; } +void +LuaInstance::destroy_instance () +{ + delete _instance; + _instance = 0; +} + LuaInstance::LuaInstance () { -#ifndef NDEBUG lua.Print.connect (&_lua_print); -#endif init (); LuaScriptParamList args; @@ -462,6 +879,7 @@ LuaInstance::LuaInstance () LuaInstance::~LuaInstance () { delete _lua_call_action; + delete _lua_render_icon; delete _lua_add_action; delete _lua_del_action; delete _lua_get_action; @@ -477,22 +895,28 @@ LuaInstance::init () { lua.do_command ( "function ScriptManager ()" - " local self = { scripts = {}, instances = {} }" + " local self = { scripts = {}, instances = {}, icons = {} }" "" " local remove = function (id)" " self.scripts[id] = nil" " self.instances[id] = nil" + " self.icons[id] = nil" " end" "" - " local addinternal = function (i, n, s, f, a)" + " local addinternal = function (i, n, s, f, c, a)" " assert(type(i) == 'number', 'id must be numeric')" " assert(type(n) == 'string', 'Name must be string')" " assert(type(s) == 'string', 'Script must be string')" " assert(type(f) == 'function', 'Factory is a not a function')" " assert(type(a) == 'table' or type(a) == 'nil', 'Given argument is invalid')" - " self.scripts[i] = { ['n'] = n, ['s'] = s, ['f'] = f, ['a'] = a }" + " self.scripts[i] = { ['n'] = n, ['s'] = s, ['f'] = f, ['a'] = a, ['c'] = c }" " local env = _ENV; env.f = nil env.debug = nil os.exit = nil require = nil dofile = nil loadfile = nil package = nil" " self.instances[i] = load (string.dump(f, true), nil, nil, env)(a)" + " if type(c) == 'function' then" + " self.icons[i] = load (string.dump(c, true), nil, nil, env)(a)" + " else" + " self.icons[i] = nil" + " end" " end" "" " local call = function (id)" @@ -506,17 +930,26 @@ LuaInstance::init () " collectgarbage()" " end" "" - " local add = function (i, n, s, b, a)" + " local icon = function (id, ...)" + " if type(self.icons[id]) == 'function' then" + " pcall (self.icons[id], ...)" + " end" + " collectgarbage()" + " end" + "" + " local add = function (i, n, s, b, c, a)" " assert(type(b) == 'string', 'ByteCode must be string')" - " load (b)()" // assigns f + " f = nil load (b)()" // assigns f + " icn = nil load (c)()" // may assign "icn" " assert(type(f) == 'string', 'Assigned ByteCode must be string')" - " addinternal (i, n, s, load(f), a)" + " addinternal (i, n, s, load(f), type(icn) ~= \"string\" or icn == '' or load(icn), a)" " end" "" " local get = function (id)" " if type(self.scripts[id]) == 'table' then" " return { ['name'] = self.scripts[id]['n']," " ['script'] = self.scripts[id]['s']," + " ['icon'] = type(self.scripts[id]['c']) == 'function'," " ['args'] = self.scripts[id]['a'] }" " end" " return nil" @@ -545,6 +978,8 @@ LuaInstance::init () " return rv;" " elseif type(value) == \"function\" then" " return rv .. string.format(\"%q\", string.dump(value, true))" + " elseif type(value) == \"boolean\" then" + " return rv .. tostring (value)" " else" " error('cannot save a ' .. type(value))" " end" @@ -558,6 +993,7 @@ LuaInstance::init () " local clear = function ()" " self.scripts = {}" " self.instances = {}" + " self.icons = {}" " collectgarbage()" " end" "" @@ -565,13 +1001,13 @@ LuaInstance::init () " clear()" " load (state)()" " for i, s in pairs (scripts) do" - " addinternal (i, s['n'], s['s'], load(s['f']), s['a'])" + " addinternal (i, s['n'], s['s'], load(s['f']), type (s['c']) ~= \"string\" or s['c'] == '' or load (s['c']), s['a'])" " end" " collectgarbage()" " end" "" " return { call = call, add = add, remove = remove, get = get," - " restore = restore, save = save, clear = clear}" + " restore = restore, save = save, clear = clear, icon = icon}" " end" " " " manager = ScriptManager ()" @@ -589,6 +1025,7 @@ LuaInstance::init () _lua_del_action = new luabridge::LuaRef(lua_mgr["remove"]); _lua_get_action = new luabridge::LuaRef(lua_mgr["get"]); _lua_call_action = new luabridge::LuaRef(lua_mgr["call"]); + _lua_render_icon = new luabridge::LuaRef(lua_mgr["icon"]); _lua_save = new luabridge::LuaRef(lua_mgr["save"]); _lua_load = new luabridge::LuaRef(lua_mgr["restore"]); _lua_clear = new luabridge::LuaRef(lua_mgr["clear"]); @@ -619,12 +1056,15 @@ void LuaInstance::set_session (Session* s) for (LuaCallbackMap::iterator i = _callbacks.begin(); i != _callbacks.end(); ++i) { i->second->set_session (s); } + point_one_second_connection = Timers::rapid_connect (sigc::mem_fun(*this, & LuaInstance::every_point_one_seconds)); } void LuaInstance::session_going_away () { ENSURE_GUI_THREAD (*this, &LuaInstance::session_going_away); + point_one_second_connection.disconnect (); + (*_lua_clear)(); for (int i = 0; i < 9; ++i) { ActionChanged (i, ""); /* EMIT SIGNAL */ @@ -637,10 +1077,16 @@ LuaInstance::session_going_away () lua.do_command ("collectgarbage();"); } +void +LuaInstance::every_point_one_seconds () +{ + LuaTimerDS (); // emit signal +} + int LuaInstance::set_state (const XMLNode& node) { - LocaleGuard lg (X_("C")); + LocaleGuard lg; XMLNode* child; if ((child = find_named_node (node, "ActionScript"))) { @@ -683,16 +1129,25 @@ bool LuaInstance::interactive_add (LuaScriptInfo::ScriptType type, int id) { std::string title; + std::string param_function = "action_params"; std::vector reg; switch (type) { case LuaScriptInfo::EditorAction: reg = lua_action_names (); - title = "Add Lua Action"; + title = _("Add Lua Action"); break; case LuaScriptInfo::EditorHook: reg = lua_slot_names (); - title = "Add Lua Callback Hook"; + title = _("Add Lua Callback Hook"); + break; + case LuaScriptInfo::Session: + if (!_session) { + return false; + } + reg = _session->registered_lua_functions (); + title = _("Add Lua Session Script"); + param_function = "sess_params"; break; default: return false; @@ -720,7 +1175,7 @@ LuaInstance::interactive_add (LuaScriptInfo::ScriptType type, int id) return false; } - LuaScriptParamList lsp = LuaScriptParams::script_params (spi, "action_params"); + LuaScriptParamList lsp = LuaScriptParams::script_params (spi, param_function); ScriptParameterDialog spd (_("Set Script Parameters"), spi, reg, lsp); switch (spd.run ()) { @@ -737,6 +1192,18 @@ LuaInstance::interactive_add (LuaScriptInfo::ScriptType type, int id) case LuaScriptInfo::EditorHook: return register_lua_slot (spd.name(), script, lsp); break; + case LuaScriptInfo::Session: + try { + _session->register_lua_function (spd.name(), script, lsp); + } catch (luabridge::LuaException const& e) { + string msg = string_compose (_("Session script '%1' instantiation failed: %2"), spd.name(), e.what ()); + Gtk::MessageDialog am (msg); + am.run (); + } catch (SessionException e) { + string msg = string_compose (_("Loading Session script '%1' failed: %2"), spd.name(), e.what ()); + Gtk::MessageDialog am (msg); + am.run (); + } default: break; } @@ -746,7 +1213,7 @@ LuaInstance::interactive_add (LuaScriptInfo::ScriptType type, int id) XMLNode& LuaInstance::get_action_state () { - LocaleGuard lg (X_("C")); + LocaleGuard lg; std::string saved; { luabridge::LuaRef savedstate ((*_lua_save)()); @@ -780,11 +1247,29 @@ LuaInstance::call_action (const int id) { try { (*_lua_call_action)(id + 1); + lua.collect_garbage_step (); } catch (luabridge::LuaException const& e) { cerr << "LuaException:" << e.what () << endl; } } +void +LuaInstance::render_action_icon (cairo_t* cr, int w, int h, uint32_t c, void* i) { + int ii = reinterpret_cast (i); + instance()->render_icon (ii, cr, w, h, c); +} + +void +LuaInstance::render_icon (int i, cairo_t* cr, int w, int h, uint32_t clr) +{ + Cairo::Context ctx (cr); + try { + (*_lua_render_icon)(i + 1, (Cairo::Context *)&ctx, w, h, clr); + } catch (luabridge::LuaException const& e) { + cerr << "LuaException:" << e.what () << endl; + } +} + bool LuaInstance::set_lua_action ( const int id, @@ -797,17 +1282,19 @@ LuaInstance::set_lua_action ( // get bytcode of factory-function in a sandbox // (don't allow scripts to interfere) const std::string& bytecode = LuaScripting::get_factory_bytecode (script); + const std::string& iconfunc = LuaScripting::get_factory_bytecode (script, "icon", "icn"); luabridge::LuaRef tbl_arg (luabridge::newTable(L)); for (LuaScriptParamList::const_iterator i = args.begin(); i != args.end(); ++i) { if ((*i)->optional && !(*i)->is_set) { continue; } tbl_arg[(*i)->name] = (*i)->value; } - (*_lua_add_action)(id + 1, name, script, bytecode, tbl_arg); + (*_lua_add_action)(id + 1, name, script, bytecode, iconfunc, tbl_arg); ActionChanged (id, name); /* EMIT SIGNAL */ } catch (luabridge::LuaException const& e) { cerr << "LuaException:" << e.what () << endl; return false; } + _session->set_dirty (); return true; } @@ -821,6 +1308,7 @@ LuaInstance::remove_lua_action (const int id) return false; } ActionChanged (id, ""); /* EMIT SIGNAL */ + _session->set_dirty (); return true; } @@ -857,6 +1345,23 @@ LuaInstance::lua_action_names () return rv; } +bool +LuaInstance::lua_action_has_icon (const int id) +{ + try { + luabridge::LuaRef ref ((*_lua_get_action)(id + 1)); + if (ref.isNil()) { + return false; + } + if (ref["icon"].isBoolean()) { + return ref["icon"].cast(); + } + } catch (luabridge::LuaException const& e) { + cerr << "LuaException:" << e.what () << endl; + } + return false; +} + bool LuaInstance::lua_action (const int id, std::string& name, std::string& script, LuaScriptParamList& args) { @@ -900,9 +1405,7 @@ LuaInstance::register_lua_slot (const std::string& name, const std::string& scri ActionHook ah; try { LuaState l; -#ifndef NDEBUG l.Print.connect (&_lua_print); -#endif lua_State* L = l.getState(); register_hooks (L); l.do_command ("function ardour () end"); @@ -931,6 +1434,7 @@ LuaInstance::register_lua_slot (const std::string& name, const std::string& scri } catch (luabridge::LuaException const& e) { cerr << "LuaException:" << e.what () << endl; } + _session->set_dirty (); return false; } @@ -943,6 +1447,7 @@ LuaInstance::unregister_lua_slot (const PBD::ID& id) _callbacks.erase (i); return true; } + _session->set_dirty (); return false; } @@ -1098,9 +1603,7 @@ LuaCallback::get_state (void) void LuaCallback::init (void) { -#ifndef NDEBUG lua.Print.connect (&_lua_print); -#endif lua.do_command ( "function ScriptManager ()" @@ -1171,6 +1674,8 @@ LuaCallback::init (void) " return rv;" " elseif type(value) == \"function\" then" " return rv .. string.format(\"%q\", string.dump(value, true))" + " elseif type(value) == \"boolean\" then" + " return rv .. tostring (value)" " else" " error('cannot save a ' .. type(value))" " end" @@ -1266,11 +1771,13 @@ LuaCallback::set_session (ARDOUR::Session *s) { SessionHandlePtr::set_session (s); - if (_session) { - lua_State* L = lua.getState(); - LuaBindings::set_session (L, _session); + if (!_session) { + return; } + lua_State* L = lua.getState(); + LuaBindings::set_session (L, _session); + reconnect(); }