gtk2_ardour/luawindow.cc

   1 /*
   2     Copyright (C) 2016 Robin Gareus <robin@gareus.org>
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (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., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifdef PLATFORM_WINDOWS
  21 #define random() rand()
  22 #endif
  23
  24 #ifdef WAF_BUILD
  25 #include "gtk2ardour-config.h"
  26 #endif
  27
  28 #include "pbd/gstdio_compat.h"
  29 #include <glibmm/fileutils.h>
  30 #include <gtkmm/messagedialog.h>
  31
  32 #include "pbd/basename.h"
  33 #include "pbd/file_utils.h"
  34 #include "pbd/md5.h"
  35
  36 #include "gtkmm2ext/gtk_ui.h"
  37 #include "gtkmm2ext/pane.h"
  38 #include "gtkmm2ext/utils.h"
  39 #include "gtkmm2ext/window_title.h"
  40
  41 #include "ardour/filesystem_paths.h"
  42 #include "ardour/luabindings.h"
  43 #include "LuaBridge/LuaBridge.h"
  44
  45 #include "ardour_ui.h"
  46 #include "gui_thread.h"
  47 #include "luainstance.h"
  48 #include "luawindow.h"
  49 #include "public_editor.h"
  50 #include "tooltips.h"
  51 #include "utils.h"
  52 #include "utils_videotl.h"
  53
  54 #include "pbd/i18n.h"
  55
  56 using namespace ARDOUR;
  57 using namespace ARDOUR_UI_UTILS;
  58 using namespace PBD;
  59 using namespace Gtk;
  60 using namespace Glib;
  61 using namespace Gtkmm2ext;
  62 using namespace std;
  63
  64
  65 inline LuaWindow::BufferFlags operator| (const LuaWindow::BufferFlags& a, const LuaWindow::BufferFlags& b) {
  66         return static_cast<LuaWindow::BufferFlags> (static_cast <int>(a) | static_cast<int> (b));
  67 }
  68
  69 inline LuaWindow::BufferFlags operator|= (LuaWindow::BufferFlags& a, const LuaWindow::BufferFlags& b) {
  70         return a = static_cast<LuaWindow::BufferFlags> (static_cast <int>(a) | static_cast<int> (b));
  71 }
  72
  73 inline LuaWindow::BufferFlags operator&= (LuaWindow::BufferFlags& a, const LuaWindow::BufferFlags& b) {
  74         return a = static_cast<LuaWindow::BufferFlags> (static_cast <int>(a) & static_cast<int> (b));
  75 }
  76
  77 LuaWindow* LuaWindow::_instance = 0;
  78
  79 LuaWindow*
  80 LuaWindow::instance ()
  81 {
  82         if (!_instance) {
  83                 _instance  = new LuaWindow;
  84         }
  85
  86         return _instance;
  87 }
  88
  89 LuaWindow::LuaWindow ()
  90         : Window (Gtk::WINDOW_TOPLEVEL)
  91         , VisibilityTracker (*((Gtk::Window*) this))
  92         , lua (0)
  93         , _visible (false)
  94         , _menu_scratch (0)
  95         , _menu_snippet (0)
  96         , _menu_actions (0)
  97         , _btn_run (_("Run"))
  98         , _btn_clear (_("Clear Output"))
  99         , _btn_open (_("Import"))
 100         , _btn_save (_("Save"))
 101         , _btn_delete (_("Delete"))
 102         , _btn_revert (_("Revert"))
 103         , _current_buffer ()
 104 {
 105         set_name ("Lua");
 106
 107         reinit_lua ();
 108         update_title ();
 109         set_wmclass (X_("ardour_mixer"), PROGRAM_NAME);
 110
 111         script_select.disable_scrolling ();
 112
 113         set_border_width (0);
 114
 115         outtext.set_editable (false);
 116         outtext.set_wrap_mode (Gtk::WRAP_WORD);
 117         outtext.set_cursor_visible (false);
 118
 119         signal_delete_event().connect (sigc::mem_fun (*this, &LuaWindow::hide_window));
 120         signal_configure_event().connect (sigc::mem_fun (*ARDOUR_UI::instance(), &ARDOUR_UI::configure_handler));
 121
 122         _btn_run.signal_clicked.connect (sigc::mem_fun(*this, &LuaWindow::run_script));
 123         _btn_clear.signal_clicked.connect (sigc::mem_fun(*this, &LuaWindow::clear_output));
 124         _btn_open.signal_clicked.connect (sigc::mem_fun(*this, &LuaWindow::import_script));
 125         _btn_save.signal_clicked.connect (sigc::mem_fun(*this, &LuaWindow::save_script));
 126         _btn_delete.signal_clicked.connect (sigc::mem_fun(*this, &LuaWindow::delete_script));
 127         _btn_revert.signal_clicked.connect (sigc::mem_fun(*this, &LuaWindow::revert_script));
 128
 129         _btn_open.set_sensitive (false); // TODO
 130         _btn_save.set_sensitive (false);
 131         _btn_delete.set_sensitive (false);
 132         _btn_revert.set_sensitive (false);
 133
 134         // layout
 135
 136         Gtk::ScrolledWindow *scrollin = manage (new Gtk::ScrolledWindow);
 137         scrollin->set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
 138         scrollin->add (entry);
 139         scrollout.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_ALWAYS);
 140         scrollout.add (outtext);
 141
 142         entry.set_name ("ArdourLuaEntry");
 143         outtext.set_name ("ArdourLuaEntry");
 144
 145         Gtk::HBox *hbox = manage (new HBox());
 146
 147         hbox->pack_start (_btn_run, false, false, 2);
 148         hbox->pack_start (_btn_clear, false, false, 2);
 149         hbox->pack_start (_btn_open, false, false, 2);
 150         hbox->pack_start (_btn_save, false, false, 2);
 151         hbox->pack_start (_btn_delete, false, false, 2);
 152         hbox->pack_start (_btn_revert, false, false, 2);
 153         hbox->pack_start (script_select, false, false, 2);
 154
 155         Gtk::VBox *vbox = manage (new VBox());
 156         vbox->pack_start (*scrollin, true, true, 0);
 157         vbox->pack_start (*hbox, false, false, 2);
 158
 159         Gtkmm2ext::VPane *vpane = manage (new Gtkmm2ext::VPane ());
 160         vpane->add (*vbox);
 161         vpane->add (scrollout);
 162
 163         vpane->show_all ();
 164         add (*vpane);
 165         set_size_request (640, 480); // XXX
 166         ARDOUR_UI_UTILS::set_tooltip (script_select, _("Select Editor Buffer"));
 167
 168         setup_buffers ();
 169         LuaScripting::instance().scripts_changed.connect (*this, invalidator (*this), boost::bind (&LuaWindow::refresh_scriptlist, this), gui_context());
 170
 171         Glib::RefPtr<Gtk::TextBuffer> tb (entry.get_buffer());
 172         _script_changed_connection = tb->signal_changed().connect (sigc::mem_fun(*this, &LuaWindow::script_changed));
 173 }
 174
 175 LuaWindow::~LuaWindow ()
 176 {
 177         delete lua;
 178 }
 179
 180 void
 181 LuaWindow::show_window ()
 182 {
 183         present();
 184         _visible = true;
 185 }
 186
 187 bool
 188 LuaWindow::hide_window (GdkEventAny *ev)
 189 {
 190         if (!_visible) return 0;
 191         _visible = false;
 192         return just_hide_it (ev, static_cast<Gtk::Window *>(this));
 193 }
 194
 195 void LuaWindow::reinit_lua ()
 196 {
 197         ENSURE_GUI_THREAD (*this, &LuaWindow::session_going_away);
 198         delete lua;
 199         lua = new LuaState();
 200         lua->Print.connect (sigc::mem_fun (*this, &LuaWindow::append_text));
 201
 202         lua_State* L = lua->getState();
 203         LuaInstance::register_classes (L);
 204         luabridge::push <PublicEditor *> (L, &PublicEditor::instance());
 205         lua_setglobal (L, "Editor");
 206 }
 207
 208 void LuaWindow::set_session (Session* s)
 209 {
 210         SessionHandlePtr::set_session (s);
 211         if (!_session) {
 212                 return;
 213         }
 214
 215         update_title ();
 216         _session->DirtyChanged.connect (_session_connections, invalidator (*this), boost::bind (&LuaWindow::update_title, this), gui_context());
 217
 218         lua_State* L = lua->getState();
 219         LuaBindings::set_session (L, _session);
 220 }
 221
 222 void
 223 LuaWindow::session_going_away ()
 224 {
 225         ENSURE_GUI_THREAD (*this, &LuaWindow::session_going_away);
 226         reinit_lua (); // drop state (all variables, session references)
 227
 228         SessionHandlePtr::session_going_away ();
 229         _session = 0;
 230         update_title ();
 231
 232         lua_State* L = lua->getState();
 233         LuaBindings::set_session (L, _session);
 234 }
 235
 236 void
 237 LuaWindow::update_title ()
 238 {
 239         if (_session) {
 240                 string n;
 241
 242                 if (_session->snap_name() != _session->name()) {
 243                         n = _session->snap_name ();
 244                 } else {
 245                         n = _session->name ();
 246                 }
 247
 248                 if (_session->dirty ()) {
 249                         n = "*" + n;
 250                 }
 251
 252                 WindowTitle title (n);
 253                 title += S_("Window|Lua");
 254                 title += Glib::get_application_name ();
 255                 set_title (title.get_string());
 256
 257         } else {
 258                 WindowTitle title (S_("Window|Lua"));
 259                 title += Glib::get_application_name ();
 260                 set_title (title.get_string());
 261         }
 262 }
 263
 264 void
 265 LuaWindow::scroll_to_bottom ()
 266 {
 267         Gtk::Adjustment *adj;
 268         adj = scrollout.get_vadjustment();
 269         adj->set_value (MAX(0,(adj->get_upper() - adj->get_page_size())));
 270 }
 271
 272 void
 273 LuaWindow::run_script ()
 274 {
 275         Glib::RefPtr<Gtk::TextBuffer> tb (entry.get_buffer());
 276         std::string script = tb->get_text();
 277         const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
 278         if (bytecode.empty()) {
 279                 // plain script or faulty script -- run directly
 280                 try {
 281                         lua->do_command ("function ardour () end");
 282                         if (0 == lua->do_command (script)) {
 283                                 append_text ("> OK");
 284                         }
 285                 } catch (luabridge::LuaException const& e) {
 286                         append_text (string_compose (_("LuaException: %1"), e.what()));
 287                 }
 288         } else {
 289                 // script with factory method
 290                 try {
 291                         lua_State* L = lua->getState();
 292                         lua->do_command ("function ardour () end");
 293
 294                         LuaScriptParamList args = LuaScriptParams::script_params (script, "action_param", false);
 295                         luabridge::LuaRef tbl_arg (luabridge::newTable(L));
 296                         LuaScriptParams::params_to_ref (&tbl_arg, args);
 297                         lua->do_command (script); // register "factory"
 298                         luabridge::LuaRef lua_factory = luabridge::getGlobal (L, "factory");
 299                         if (lua_factory.isFunction()) {
 300                                 lua_factory(tbl_arg)();
 301                         }
 302                         lua->do_command ("factory = nil;");
 303                 } catch (luabridge::LuaException const& e) {
 304                         append_text (string_compose (_("LuaException: %1"), e.what()));
 305                 }
 306         }
 307 }
 308
 309 void
 310 LuaWindow::append_text (std::string s)
 311 {
 312         Glib::RefPtr<Gtk::TextBuffer> tb (outtext.get_buffer());
 313         tb->insert (tb->end(), s + "\n");
 314         scroll_to_bottom ();
 315 }
 316
 317 void
 318 LuaWindow::clear_output ()
 319 {
 320         Glib::RefPtr<Gtk::TextBuffer> tb (outtext.get_buffer());
 321         tb->set_text ("");
 322 }
 323
 324 void
 325 LuaWindow::new_script ()
 326 {
 327         char buf[32];
 328         snprintf (buf, sizeof (buf), "#%d", count_scratch_buffers () + 1);
 329         script_buffers.push_back (ScriptBufferPtr (new LuaWindow::ScriptBuffer (buf)));
 330         script_selection_changed (script_buffers.back ());
 331         refresh_scriptlist ();
 332 }
 333
 334 void
 335 LuaWindow::delete_script ()
 336 {
 337         assert ((_current_buffer->flags & Buffer_Scratch) || !(_current_buffer->flags & Buffer_ReadOnly));
 338         bool refresh = false;
 339         bool neednew = true;
 340         if (_current_buffer->flags & Buffer_HasFile) {
 341                 if (0 == ::g_unlink (_current_buffer->path.c_str())) {
 342                         append_text (X_("> ") + string_compose (_("Deleted %1"), _current_buffer->path));
 343                         refresh = true;
 344                 } else {
 345                         append_text (X_("> ") + string_compose (_("Failed to delete %1"), _current_buffer->path));
 346                 }
 347         }
 348         for (ScriptBufferList::iterator i = script_buffers.begin (); i != script_buffers.end (); ++i) {
 349                 if ((*i) == _current_buffer) {
 350                         script_buffers.erase (i);
 351                         break;
 352                 }
 353         }
 354
 355         for (ScriptBufferList::const_iterator i = script_buffers.begin (); i != script_buffers.end (); ++i) {
 356                 if ((*i)->flags & Buffer_Scratch) {
 357                         script_selection_changed (*i);
 358                         neednew = false;
 359                 }
 360         }
 361         if (neednew) {
 362                 new_script ();
 363         }
 364         if (refresh) {
 365                 LuaScripting::instance ().refresh (true);
 366         }
 367 }
 368
 369 void
 370 LuaWindow::revert_script ()
 371 {
 372         _current_buffer->flags &= BufferFlags(~Buffer_Valid);
 373         script_selection_changed (_current_buffer, true);
 374 }
 375
 376 void
 377 LuaWindow::import_script ()
 378 {
 379         // TODO: dialog to select file or enter URL
 380         // TODO convert a few URL (eg. pastebin) to raw.
 381 #if 0
 382         char *url = "http://pastebin.com/raw/3UMkZ6nV";
 383         char *rv = a3_curl_http_get (url, 0);
 384         if (rv) {
 385                 new_script ();
 386                 Glib::RefPtr<Gtk::TextBuffer> tb (entry.get_buffer());
 387                 tb->set_text (rv);
 388                 _current_buffer->flags &= BufferFlags(~Buffer_Dirty);
 389                 update_gui_state ();
 390         }
 391         free (rv);
 392 #endif
 393 }
 394
 395 void
 396 LuaWindow::save_script ()
 397 {
 398         Glib::RefPtr<Gtk::TextBuffer> tb (entry.get_buffer());
 399         std::string script = tb->get_text();
 400         std::string msg = "Unknown error";
 401
 402         std::string path;
 403         LuaScriptInfoPtr lsi = LuaScripting::script_info (script);
 404         ScriptBuffer & sb (*_current_buffer);
 405
 406         assert (sb.flags & Buffer_Dirty);
 407
 408         // 1) check if it has a valid header and factory
 409         const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
 410         if (bytecode.empty()) {
 411                 msg = _("Missing script header.\nThe script requires an '{ardour}' info table and a 'factory' function.");
 412                 goto errorout;
 413         }
 414
 415         if (!LuaScripting::try_compile (script, LuaScriptParams::script_params (script, "action_param", false))) {
 416                 msg = _("Script fails to compile.");
 417                 goto errorout;
 418         }
 419
 420         // 2) check script name & type
 421         lsi = LuaScripting::script_info (script);
 422         if (!lsi) {
 423                 msg = _("Invalid or missing script-name or script-type.");
 424                 goto errorout;
 425         }
 426
 427         if (lsi->type != LuaScriptInfo::Snippet && lsi->type != LuaScriptInfo::EditorAction) {
 428                 msg = _("Invalid script-type.\nValid types are 'EditorAction' and 'Snippet'.");
 429                 goto errorout;
 430         }
 431
 432         // 3) if there's already a writable file,...
 433         if ((sb.flags & Buffer_HasFile) && !(sb.flags & Buffer_ReadOnly)) {
 434                 try {
 435                         Glib::file_set_contents (sb.path, script);
 436                         sb.name = lsi->name;
 437                         sb.flags &= BufferFlags(~Buffer_Dirty);
 438                         update_gui_state (); // XXX here?
 439                         append_text (X_("> ") + string_compose (_("Saved as %1"), sb.path));
 440                         return; // OK
 441                 } catch (Glib::FileError e) {
 442                         msg = string_compose (_("Error saving file: %1"), e.what());
 443                         goto errorout;
 444                 }
 445         }
 446
 447         // 4) check if the name is unique for the given type; locally at least
 448         if (true /*sb.flags & Buffer_HasFile*/) {
 449                 LuaScriptList& lsl (LuaScripting::instance ().scripts (lsi->type));
 450                 for (LuaScriptList::const_iterator s = lsl.begin(); s != lsl.end(); ++s) {
 451                         if ((*s)->name == lsi->name) {
 452                                 msg = string_compose (_("Script with given name '%1' already exists.\nUse a different name in the descriptor."), lsi->name);
 453                                 goto errorout;
 454                         }
 455                 }
 456         }
 457
 458         // 5) construct filename -- TODO ask user for name, ask to replace file.
 459         do {
 460                 char buf[80];
 461                 time_t t = time(0);
 462                 struct tm * timeinfo = localtime (&t);
 463                 strftime (buf, sizeof(buf), "%s%d", timeinfo);
 464                 sprintf (buf, "%s%ld", buf, random ()); // is this valid?
 465                 MD5 md5;
 466                 std::string fn = md5.digestString (buf);
 467
 468                 switch (lsi->type) {
 469                         case LuaScriptInfo::EditorAction:
 470                                 fn = "a_" + fn;
 471                                 break;
 472                         case LuaScriptInfo::Snippet:
 473                                 fn = "s_" + fn;
 474                                 break;
 475                         default:
 476                                 break;
 477                 }
 478                 path = Glib::build_filename (LuaScripting::user_script_dir (), fn.substr(0, 11) + ".lua");
 479         } while (Glib::file_test (path, Glib::FILE_TEST_EXISTS));
 480
 481         try {
 482                 Glib::file_set_contents (path, script);
 483                 sb.path = path;
 484                 sb.name = lsi->name;
 485                 sb.flags |= Buffer_HasFile;
 486                 sb.flags &= BufferFlags(~Buffer_Dirty);
 487                 sb.flags &= BufferFlags(~Buffer_ReadOnly);
 488                 update_gui_state (); // XXX here? .refresh (true) may trigger this, too
 489                 LuaScripting::instance().refresh (true);
 490                 append_text (X_("> ") + string_compose (_("Saved as %1"), path));
 491                 return; // OK
 492         } catch (Glib::FileError e) {
 493                 msg = string_compose (_("Error saving file: %1"), e.what());
 494                 goto errorout;
 495         }
 496
 497 errorout:
 498                 MessageDialog am (msg);
 499                 am.run ();
 500 }
 501
 502 void
 503 LuaWindow::setup_buffers ()
 504 {
 505         if (script_buffers.size() > 0) {
 506                 return;
 507         }
 508         script_buffers.push_back (ScriptBufferPtr (new LuaWindow::ScriptBuffer("#1")));
 509         _current_buffer = script_buffers.front();
 510
 511         Glib::RefPtr<Gtk::TextBuffer> tb (entry.get_buffer());
 512         tb->set_text (_current_buffer->script);
 513
 514         refresh_scriptlist ();
 515         update_gui_state ();
 516 }
 517
 518 uint32_t
 519 LuaWindow::count_scratch_buffers () const
 520 {
 521         uint32_t n = 0;
 522         for (ScriptBufferList::const_iterator i = script_buffers.begin (); i != script_buffers.end (); ++i) {
 523                 if ((*i)->flags & Buffer_Scratch) {
 524                         ++n;
 525                 }
 526         }
 527         return n;
 528 }
 529
 530 void
 531 LuaWindow::refresh_scriptlist ()
 532 {
 533         for (ScriptBufferList::iterator i = script_buffers.begin (); i != script_buffers.end ();) {
 534                 if ((*i)->flags & Buffer_Scratch) {
 535                         ++i;
 536                         continue;
 537                 }
 538                 i = script_buffers.erase (i);
 539         }
 540         LuaScriptList& lsa (LuaScripting::instance ().scripts (LuaScriptInfo::EditorAction));
 541         for (LuaScriptList::const_iterator s = lsa.begin(); s != lsa.end(); ++s) {
 542                 script_buffers.push_back (ScriptBufferPtr (new LuaWindow::ScriptBuffer(*s)));
 543         }
 544
 545         LuaScriptList& lss (LuaScripting::instance ().scripts (LuaScriptInfo::Snippet));
 546         for (LuaScriptList::const_iterator s = lss.begin(); s != lss.end(); ++s) {
 547                 script_buffers.push_back (ScriptBufferPtr (new LuaWindow::ScriptBuffer(*s)));
 548         }
 549         rebuild_menu ();
 550 }
 551
 552 void
 553 LuaWindow::rebuild_menu ()
 554 {
 555         using namespace Menu_Helpers;
 556
 557         _menu_scratch = manage (new Menu);
 558         _menu_snippet = manage (new Menu);
 559         _menu_actions = manage (new Menu);
 560
 561         MenuList& items_scratch (_menu_scratch->items());
 562         MenuList& items_snippet (_menu_snippet->items());
 563         MenuList& items_actions (_menu_actions->items());
 564
 565         {
 566                 Menu_Helpers::MenuElem elem = Gtk::Menu_Helpers::MenuElem(_("New"),
 567                                 sigc::mem_fun(*this, &LuaWindow::new_script));
 568                 items_scratch.push_back(elem);
 569         }
 570
 571         items_scratch.push_back(SeparatorElem());
 572
 573         for (ScriptBufferList::const_iterator i = script_buffers.begin (); i != script_buffers.end (); ++i) {
 574                 std::string name;
 575                 if ((*i)->flags & Buffer_ReadOnly) {
 576                         name = "[R] " + (*i)->name;
 577                 } else {
 578                         name = (*i)->name;
 579                 }
 580                 Menu_Helpers::MenuElem elem = Gtk::Menu_Helpers::MenuElem(name,
 581                                 sigc::bind(sigc::mem_fun(*this, &LuaWindow::script_selection_changed), (*i), false));
 582
 583                 if ((*i)->flags & Buffer_Scratch) {
 584                         items_scratch.push_back(elem);
 585                 }
 586                 else if ((*i)->type == LuaScriptInfo::EditorAction) {
 587                                 items_actions.push_back(elem);
 588                 }
 589                 else if ((*i)->type == LuaScriptInfo::Snippet) {
 590                                 items_snippet.push_back(elem);
 591                 }
 592         }
 593
 594         script_select.clear_items ();
 595         script_select.AddMenuElem (Menu_Helpers::MenuElem ("Scratch", *_menu_scratch));
 596         script_select.AddMenuElem (Menu_Helpers::MenuElem ("Snippets", *_menu_snippet));
 597         script_select.AddMenuElem (Menu_Helpers::MenuElem ("Actions", *_menu_actions));
 598 }
 599
 600 void
 601 LuaWindow::script_selection_changed (ScriptBufferPtr n, bool force)
 602 {
 603         if (n == _current_buffer && !force) {
 604                 return;
 605         }
 606
 607         Glib::RefPtr<Gtk::TextBuffer> tb (entry.get_buffer());
 608
 609         if (_current_buffer->flags & Buffer_Valid) {
 610                 _current_buffer->script = tb->get_text();
 611         }
 612
 613         if (!(n->flags & Buffer_Valid)) {
 614                 if (!n->load()) {
 615                         append_text ("! Failed to load buffer.");
 616                 }
 617         }
 618
 619         if (n->flags & Buffer_Valid) {
 620                 _current_buffer = n;
 621                 _script_changed_connection.block ();
 622                 tb->set_text (n->script);
 623                 _script_changed_connection.unblock ();
 624         } else {
 625                 append_text ("! Failed to switch buffer.");
 626         }
 627         update_gui_state ();
 628 }
 629
 630 void
 631 LuaWindow::update_gui_state ()
 632 {
 633         const ScriptBuffer & sb (*_current_buffer);
 634         std::string name;
 635         if (sb.flags & Buffer_Scratch) {
 636                 name = string_compose (_("Scratch Buffer %1"), sb.name);
 637         } else if (sb.type == LuaScriptInfo::EditorAction) {
 638                 name = string_compose (_("Action: '%1'"), sb.name);
 639         } else if (sb.type == LuaScriptInfo::Snippet) {
 640                 name = string_compose (_("Snippet: %1"), sb.name);
 641         } else {
 642                 cerr << "Invalid Script type\n";
 643                 assert (0);
 644                 return;
 645         }
 646         if (sb.flags & Buffer_Dirty) {
 647                 name += " *";
 648         }
 649         script_select.set_text(name);
 650
 651         if (sb.flags & Buffer_ReadOnly) {
 652                 _btn_save.set_text (_("Save as"));
 653         } else {
 654                 _btn_save.set_text (_("Save"));
 655         }
 656         _btn_save.set_sensitive (sb.flags & Buffer_Dirty);
 657         _btn_delete.set_sensitive (sb.flags & Buffer_Scratch || ((sb.flags & (Buffer_ReadOnly | Buffer_HasFile)) == Buffer_HasFile));
 658         _btn_revert.set_sensitive ((sb.flags & Buffer_Dirty) && (sb.flags & Buffer_HasFile));
 659 }
 660
 661 void
 662 LuaWindow::script_changed () {
 663         if (_current_buffer->flags & Buffer_Dirty) {
 664                 return;
 665         }
 666         _current_buffer->flags |= Buffer_Dirty;
 667         update_gui_state ();
 668 }
 669
 670 LuaWindow::ScriptBuffer::ScriptBuffer (const std::string& n)
 671         : name (n)
 672         , flags (Buffer_Scratch | Buffer_Valid)
 673 {
 674         script =
 675                 "---- this header is (only) required to save the script\n"
 676                 "-- ardour { [\"type\"] = \"Snippet\", name = \"\" }\n"
 677                 "-- function factory () return function () -- -- end end\n";
 678 }
 679
 680 LuaWindow::ScriptBuffer::ScriptBuffer (LuaScriptInfoPtr p)
 681         : name (p->name)
 682         , path (p->path)
 683         , flags (Buffer_HasFile)
 684         , type (p->type)
 685 {
 686         if (!PBD::exists_and_writable (path)) {
 687                 flags |= Buffer_ReadOnly;
 688         }
 689         if (path.find (user_config_directory ()) != 0) {
 690                 // mark non-user scripts as read-only
 691                 flags |= Buffer_ReadOnly;
 692         }
 693 }
 694
 695 #if 0
 696 LuaWindow::ScriptBuffer::ScriptBuffer (const ScriptBuffer& other)
 697         : script (other.script)
 698         , name (other.name)
 699         , path (other.path)
 700         , flags (other.flags)
 701         , type (other.type)
 702 {
 703 }
 704 #endif
 705
 706 LuaWindow::ScriptBuffer::~ScriptBuffer ()
 707 {
 708 }
 709
 710 bool
 711 LuaWindow::ScriptBuffer::load ()
 712 {
 713         assert (!(flags & Buffer_Valid));
 714         if (!(flags & Buffer_HasFile)) return false;
 715         try {
 716                 script = Glib::file_get_contents (path);
 717                 flags |= Buffer_Valid;
 718                 flags &= BufferFlags(~Buffer_Dirty);
 719         } catch (Glib::FileError e) {
 720                 return false;
 721         }
 722         return true;
 723 }