A Gtk::manage()d widget will be deleted when its parent container
is destroyed. Top-level context menus are not inside a container and
hence need to be manually deallocated.
The solution here is to use a shared Gtk::Menu pointer that is
centrally de/re-allocated.
This works because the GUI is single-threaded and at most one
context menu is visible at a time.
A Gtk::manage()d widget will be deleted when its parent container
is destroyed. Top-level context menus are not inside a container and
hence need to be manually deallocated.
This adds explicit delete calls for menus where there is a
member variable reference to the Menu.
Fixes occasional crash when Menu is re-used.
PluginSelector::plugin_menu() is called every time the processor box
shows the context-menu. The provided menu needs to remain valid
regardless of usage.
Listen positions are already correctly set when the route state
is restored. The Route directly uses the Config.
This skips duplicate calls to re-configure all processors on all Routes
during RCConfiguration::map_parameters() on session-load, twice
(pfl-position, listen-position)
Delaylines are not saved in the XML and internal-return is an
invisible processor not explicitly re-added when the state is restored.
They are [re]inserted during Route::setup_invisible_processors().
So this method need to be called after restoring processor state
(indirectly via configure_processors_unlocked as needed).
PS. During route creation this call happens explicitly and on session load
hookup_io() -> Route::output_change_handler() implicitly sets this up.
Speed up route creation: add_processor() takes a process-lock
and calls configure_processors() but this is done explicitly at the
end of init() already.
This fixes a bug on some modern mac systems. Related to
setup_logging() changing stderr to use ASL and write to com.apple.console.
When a forked application writes to stderr while ASL is used,
the child is terminated for some reason.
Route::processors_changed() signal connects to a same thread session-slot
Session::route_processors_changed() which can end up iterating over
Routes and Processors to re-calculate latency.
This takes a ReadLock after WriteLock, which eventually leads a duplicate
unlock and segfault.
