mirror of
https://github.com/robbert-vdh/yabridge.git
synced 2026-05-15 13:00:02 +02:00
Robbert van der Helm
88 lines
3.5 KiB
C++
88 lines
3.5 KiB
C++
// yabridge: a Wine VST bridge
|
|
// Copyright (C) 2020 Robbert van der Helm
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
#pragma once
|
|
|
|
#include "../editor.h"
|
|
|
|
/**
|
|
* The base for the Wine plugin host bridge interface for all plugin types. This
|
|
* only has to be able to handle Win32 and X11 events. Implementations of this
|
|
* will actually host a plugin and do all the function call forwarding.
|
|
*/
|
|
class HostBridge {
|
|
protected:
|
|
HostBridge(boost::filesystem::path plugin_path);
|
|
|
|
public:
|
|
virtual ~HostBridge(){};
|
|
|
|
/**
|
|
* Handle events until the plugin exits. The actual events are posted to
|
|
* `main_context` to ensure that all operations to could potentially
|
|
* interact with Win32 code are run from a single thread, even when hosting
|
|
* multiple plugins. The message loop should be run on a timer within the
|
|
* same IO context.
|
|
*
|
|
* @note Because of the reasons mentioned above, for this to work the plugin
|
|
* should be initialized within the same thread that calls
|
|
* `main_context.run()`.
|
|
*/
|
|
virtual void run() = 0;
|
|
|
|
/**
|
|
* Handle X11 events for the editor window if it is open. This can safely be
|
|
* run from any thread.
|
|
*/
|
|
void handle_x11_events();
|
|
|
|
/**
|
|
* Run the message loop for this plugin. This is only used for the
|
|
* individual plugin host, so that we can filter out some unnecessary timer
|
|
* events. When hosting multiple plugins, a simple central message loop
|
|
* should be used instead. This is run on a timer in the same IO context as
|
|
* the one that handles the events, i.e. `main_context`.
|
|
*
|
|
* Because of the way the Win32 API works we have to process events on the
|
|
* same thread as the one the window was created on, and that thread is the
|
|
* thread that's handling dispatcher calls. Some plugins will also rely on
|
|
* the Win32 message loop to run tasks on a timer and to defer loading, so
|
|
* we have to make sure to always run this loop. The only exception is a in
|
|
* specific situation that can cause a race condition in some plugins
|
|
* because of incorrect assumptions made by the plugin. See the dostring for
|
|
* `HostBridge::editor` for more information.
|
|
*/
|
|
void handle_win32_events();
|
|
|
|
/**
|
|
* The path to the .dll being loaded in the Wine plugin host.
|
|
*/
|
|
const boost::filesystem::path plugin_path;
|
|
|
|
protected:
|
|
/**
|
|
* The plugin editor window. Allows embedding the plugin's editor into a
|
|
* Wine window, and embedding that Wine window into a window provided by the
|
|
* host. Should be empty when the editor is not open.
|
|
*
|
|
* TODO: This should be moved back to `Vst2Bridge`, `handle_x11_events()``
|
|
* and `handle_win32_events()` should be made pure virtual. A single
|
|
* `Vst3Bridge` instance will handle multiple plugin instances because
|
|
* of the way VST3 works.
|
|
*/
|
|
std::optional<Editor> editor;
|
|
};
|