ren-ui-python 0.1.0__py3-none-any.whl

ren_ui/native/bridge.cpp

@@ -0,0 +1,764 @@
+// SPDX-License-Identifier: MIT
+// ABI v5. Only opaque application pointers and integer object IDs cross the ABI.
+#include <Alert.h>
+#include <Application.h>
+#include <Button.h>
+#include <Bitmap.h>
+#include <Entry.h>
+#include <File.h>
+#include <FilePanel.h>
+#include <IconUtils.h>
+#include <Looper.h>
+#include <TranslationUtils.h>
+#include <CheckBox.h>
+#include <Clipboard.h>
+#include <FindDirectory.h>
+#include <GroupLayout.h>
+#include <GroupView.h>
+#include <Message.h>
+#include <Messenger.h>
+#include <Path.h>
+#include <Roster.h>
+#include <ScrollView.h>
+#include <Slider.h>
+#include <StringView.h>
+#include <TextControl.h>
+#include <TextView.h>
+#include <Window.h>
+
+#include <algorithm>
+#include <cmath>
+#include <vector>
+#include <atomic>
+#include <cstdint>
+#include <cstring>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <stdexcept>
+#include <string>
+
+namespace {
+thread_local std::string error;
+thread_local std::string result;
+using Callback = void (*)(int64_t, int64_t, const char*, const char*, int);
+constexpr uint32 kControl = 'renC';
+constexpr uint32 kCloseAccepted = 'renQ';
+
+void check(status_t status, const char* operation)
+{
+    if (status < B_OK)
+        throw std::runtime_error(std::string(operation) + ": " + strerror(status));
+}
+
+// Decode before replacing a live image, so errors keep the previous bitmap.
+std::unique_ptr<BBitmap> loadBitmap(const char* path, int vectorSize)
+{
+    BFile file(path, B_READ_ONLY);
+    check(file.InitCheck(), "Open image");
+    char magic[4];
+    bool vector = file.Read(magic, sizeof(magic)) == 4 && !memcmp(magic, "ncif", 4);
+    std::unique_ptr<BBitmap> bitmap;
+    if (vector) {
+        off_t size;
+        check(file.GetSize(&size), "Read HVIF size");
+        if (size < 7 || size > 64 * 1024)
+            throw std::runtime_error("HVIF must be between 7 bytes and 64 KiB");
+        std::vector<uint8> data(static_cast<size_t>(size));
+        if (file.ReadAt(0, data.data(), data.size()) != size)
+            throw std::runtime_error("Could not read HVIF");
+        bitmap.reset(new BBitmap(BRect(0, 0, vectorSize - 1, vectorSize - 1), B_RGBA32));
+        check(bitmap->InitCheck(), "HVIF bitmap");
+        check(BIconUtils::GetVectorIcon(data.data(), data.size(), bitmap.get()), "Decode HVIF");
+    } else {
+        bitmap.reset(BTranslationUtils::GetBitmapFile(path));
+        if (!bitmap) throw std::runtime_error(std::string("Cannot decode image: ") + path);
+        check(bitmap->InitCheck(), "Image bitmap");
+    }
+    if (bitmap->Bounds().Width() >= 16384 || bitmap->Bounds().Height() >= 16384
+        || bitmap->BitsLength() > 64 * 1024 * 1024)
+        throw std::runtime_error("Decoded image exceeds 16384 pixels or 64 MiB");
+    return bitmap;
+}
+
+BRect imageRect(BRect source, BRect target, const std::string& fit)
+{
+    if (fit == "stretch") return target;
+    float sx = (target.Width() + 1) / (source.Width() + 1);
+    float sy = (target.Height() + 1) / (source.Height() + 1);
+    float scale = fit == "cover" ? std::max(sx, sy) : std::min(sx, sy);
+    float width = (source.Width() + 1) * scale;
+    float height = (source.Height() + 1) * scale;
+    float x = target.left + (target.Width() + 1 - width) / 2;
+    float y = target.top + (target.Height() + 1 - height) / 2;
+    return BRect(x, y, x + width - 1, y + height - 1);
+}
+
+class ImageView : public BView {
+    std::unique_ptr<BBitmap> bitmap;
+    std::string fit;
+    int vectorSize;
+public:
+    ImageView(const char* name, const char* path, float width, float height, const char* mode)
+        : BView(name, B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE), fit(mode),
+          vectorSize(0)
+    {
+        if (width <= 0 || height <= 0 || width > 4096 || height > 4096
+            || !std::isfinite(width) || !std::isfinite(height)
+            || (fit != "contain" && fit != "cover" && fit != "stretch"))
+            throw std::runtime_error("Invalid image viewport");
+        vectorSize = static_cast<int>(std::ceil(std::max(width, height)));
+        bitmap = loadBitmap(path, vectorSize);
+        // Haiku's BSize uses coordinate distances (pixel count minus one).
+        BSize size(width - 1, height - 1);
+        SetExplicitMinSize(size);
+        SetExplicitPreferredSize(size);
+        SetExplicitMaxSize(size);
+        SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
+    }
+
+    void Replace(const char* path)
+    {
+        auto next = loadBitmap(path, vectorSize);
+        bitmap.swap(next);
+        Invalidate();
+    }
+
+    void Draw(BRect) override
+    {
+        SetDrawingMode(B_OP_COPY);
+        SetHighColor(ViewColor());
+        FillRect(Bounds());
+        SetDrawingMode(B_OP_ALPHA);
+        SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_OVERLAY);
+        DrawBitmap(bitmap.get(), bitmap->Bounds(), imageRect(bitmap->Bounds(), Bounds(), fit),
+            B_FILTER_BITMAP_BILINEAR);
+    }
+};
+
+std::unique_ptr<BBitmap> buttonBitmap(const char* path, int size)
+{
+    auto source = loadBitmap(path, size);
+    auto scaled = std::make_unique<BBitmap>(BRect(0, 0, size - 1, size - 1),
+        B_BITMAP_ACCEPTS_VIEWS, B_RGBA32);
+    check(scaled->InitCheck(), "Icon bitmap");
+    // Start transparent so non-square icons retain their aspect ratio.
+    memset(scaled->Bits(), 0, scaled->BitsLength());
+    auto painter = std::make_unique<BView>(scaled->Bounds(), "icon", B_FOLLOW_NONE, B_WILL_DRAW);
+    if (!scaled->Lock()) throw std::runtime_error("Cannot lock icon bitmap");
+    scaled->AddChild(painter.get());
+    painter->SetDrawingMode(B_OP_ALPHA);
+    painter->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
+    painter->DrawBitmap(source.get(), source->Bounds(),
+        imageRect(source->Bounds(), scaled->Bounds(), "contain"), B_FILTER_BITMAP_BILINEAR);
+    painter->Sync();
+    scaled->RemoveChild(painter.get());
+    scaled->Unlock();
+    return scaled;
+}
+
+struct Context {
+    BApplication* app = nullptr;
+    BMessenger messenger;
+    Callback callback = nullptr;
+    std::mutex mutex;
+    std::map<int64_t, BMessenger> windows;
+    std::atomic<int> live{0};
+    std::atomic<bool> destroying{false};
+    int64_t nextWindow = 1;
+};
+
+class Application : public BApplication {
+    Context* context;
+public:
+    Application(const char* signature, Context* c)
+        : BApplication(signature), context(c) {}
+
+    bool QuitRequested() override
+    {
+        if (context->live == 0 || context->destroying)
+            return true;
+        // BApplication's default stops at the first asynchronous window veto.
+        // Ask Python to request every window, then exit after the last closes.
+        context->callback(0, 0, "quit_requested", "", 0);
+        return false;
+    }
+};
+
+class TextArea : public BTextView {
+    Context* context;
+    int64_t windowID;
+    int64_t viewID;
+    bool silent = false;
+
+    void Changed()
+    {
+        // Only snapshot into Python's queue; never execute user code here.
+        if (!silent && BView::Window())
+            context->callback(windowID, viewID, "change", Text(), 0);
+    }
+
+protected:
+    void InsertText(const char* text, int32 length, int32 offset,
+        const text_run_array* runs) override
+    {
+        BTextView::InsertText(text, length, offset, runs);
+        Changed();
+    }
+
+    void DeleteText(int32 from, int32 to) override
+    {
+        BTextView::DeleteText(from, to);
+        Changed();
+    }
+
+public:
+    TextArea(const char* name, Context* c, int64_t wid, int64_t id, bool wrap)
+        : BTextView(name, B_WILL_DRAW | B_PULSE_NEEDED | B_NAVIGABLE),
+          context(c), windowID(wid), viewID(id)
+    {
+        SetWordWrap(wrap);
+        SetDoesUndo(true);
+        SetMaxBytes(1024 * 1024);
+        SetInsets(8, 8, 8, 8);
+        SetExplicitMinSize(BSize(240, 180));
+        SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED));
+    }
+
+    void ReplaceText(const char* text)
+    {
+        if (strlen(text) > static_cast<size_t>(MaxBytes()))
+            throw std::runtime_error("TextArea supports at most 1 MiB of UTF-8 text");
+        silent = true;
+        try {
+            SetText(text);
+        } catch (...) {
+            silent = false;
+            throw;
+        }
+        silent = false;
+        Changed(); // Exactly one snapshot for a programmatic replacement.
+    }
+};
+
+class Window : public BWindow {
+public:
+    Context* context;
+    int64_t id;
+    float initialWidth;
+    float initialHeight;
+    int64_t nextView = 1;
+    bool closePending = false;
+    std::map<int64_t, BView*> views;
+
+    Window(Context* c, int64_t n, const char* title, float width, float height, bool resize)
+        : BWindow(BRect(80, 80, 80 + width, 80 + height), title, B_TITLED_WINDOW,
+            B_ASYNCHRONOUS_CONTROLS | B_AUTO_UPDATE_SIZE_LIMITS
+                | (resize ? 0 : B_NOT_RESIZABLE | B_NOT_ZOOMABLE)), context(c), id(n),
+          initialWidth(width), initialHeight(height)
+    {
+        SetLayout(new BGroupLayout(B_VERTICAL, 0));
+        ++context->live;
+    }
+
+    ~Window() override
+    {
+        context->callback(id, 0, "closed", "", 0);
+        if (--context->live == 0 && !context->destroying)
+            context->messenger.SendMessage(B_QUIT_REQUESTED);
+    }
+
+    bool QuitRequested() override
+    {
+        // Decide on Python's dispatcher without holding this looper's lock.
+        // In particular, a synchronous BAlert::Go() must not run here.
+        if (!closePending) {
+            closePending = true;
+            context->callback(id, 0, "close_requested", "", 0);
+        }
+        return false;
+    }
+
+    void MessageReceived(BMessage* message) override
+    {
+        if (message->what == kCloseAccepted) {
+            Quit(); // Already approved; do not ask QuitRequested a second time.
+            return;
+        }
+        if (message->what != kControl) {
+            BWindow::MessageReceived(message);
+            return;
+        }
+        int64 viewID;
+        if (message->FindInt64("ren:id", &viewID) != B_OK)
+            return;
+        auto found = views.find(viewID);
+        if (found == views.end())
+            return;
+        BControl* control = dynamic_cast<BControl*>(found->second);
+        if (!control)
+            return;
+        BTextControl* text = dynamic_cast<BTextControl*>(control);
+        context->callback(id, viewID, dynamic_cast<BButton*>(control) ? "click" : "change",
+            text ? text->Text() : (control->Label() ? control->Label() : ""), control->Value());
+    }
+};
+
+// Lock through BMessenger, never dereference a raw pointer to a closed window.
+class WindowLock {
+public:
+    Window* window = nullptr;
+    WindowLock(Context* context, int64_t id)
+    {
+        BMessenger messenger;
+        {
+            std::lock_guard<std::mutex> lock(context->mutex);
+            auto found = context->windows.find(id);
+            if (found == context->windows.end())
+                throw std::runtime_error("Unknown window");
+            messenger = found->second;
+        }
+        check(messenger.LockTargetWithTimeout(5000000), "Window has closed or is busy");
+        BLooper* looper = nullptr;
+        messenger.Target(&looper);
+        window = dynamic_cast<Window*>(looper);
+        if (!window) {
+            if (looper) looper->Unlock();
+            throw std::runtime_error("Invalid window target");
+        }
+    }
+    ~WindowLock() { if (window) window->Unlock(); }
+    BView* view(int64_t id)
+    {
+        auto found = window->views.find(id);
+        if (found == window->views.end())
+            throw std::runtime_error("Unknown widget");
+        return found->second;
+    }
+    BControl* control(int64_t id)
+    {
+        auto control = dynamic_cast<BControl*>(view(id));
+        if (!control) throw std::runtime_error("Widget is not a control");
+        return control;
+    }
+};
+
+// Receives a file panel's reply on its own looper while the caller waits.
+class PanelReply : public BLooper {
+public:
+    std::string path;
+    sem_id done;
+
+    PanelReply() : BLooper("ren_file_panel"), done(create_sem(0, "ren_file_panel")) {}
+    ~PanelReply() override { delete_sem(done); }
+
+    void MessageReceived(BMessage* message) override
+    {
+        entry_ref ref;
+        const char* name;
+        switch (message->what) {
+        case B_REFS_RECEIVED:
+            if (message->FindRef("refs", &ref) == B_OK)
+                path = BPath(&ref).Path();
+            break;
+        case B_SAVE_REQUESTED:
+            if (message->FindRef("directory", &ref) == B_OK
+                && message->FindString("name", &name) == B_OK) {
+                BPath target(&ref);
+                if (target.Append(name) == B_OK) path = target.Path();
+            }
+            break;
+        case B_CANCEL:
+            // Sent whenever the panel hides, also after a selection.
+            release_sem(done);
+            break;
+        default:
+            BLooper::MessageReceived(message);
+        }
+    }
+};
+
+BMessage* controlMessage(int64_t id)
+{
+    auto message = new BMessage(kControl);
+    message->AddInt64("ren:id", id);
+    return message;
+}
+
+#define BEGIN_API error.clear(); try {
+#define END_API(failure) } catch (const std::exception& e) { error = e.what(); } \
+    catch (...) { error = "Unknown native exception"; } return failure;
+} // namespace
+
+extern "C" {
+int ren_abi() { return 5; }
+const char* ren_error() { return error.c_str(); }
+
+void* ren_app_create(const char* signature, Callback callback)
+{
+    BEGIN_API
+    if (be_app) throw std::runtime_error("A BApplication already exists");
+    auto context = std::make_unique<Context>();
+    auto app = std::make_unique<Application>(signature, context.get());
+    check(app->InitCheck(), "BApplication");
+    context->app = app.release();
+    context->messenger = BMessenger(context->app);
+    context->callback = callback;
+    return context.release();
+    END_API(nullptr)
+}
+
+int ren_app_run(Context* context)
+{
+    BEGIN_API
+    check(context->app->Run(), "BApplication::Run");
+    return 0;
+    END_API(-1)
+}
+
+int ren_app_quit(Context* context)
+{
+    BEGIN_API
+    check(context->messenger.SendMessage(B_QUIT_REQUESTED), "Application quit");
+    return 0;
+    END_API(-1)
+}
+
+int ren_app_destroy(Context* context)
+{
+    BEGIN_API
+    context->destroying = true;
+    for (auto& entry : context->windows) {
+        if (entry.second.LockTarget()) {
+            BLooper* looper = nullptr;
+            entry.second.Target(&looper);
+            if (looper) looper->Quit(); // Deletes and unlocks the looper.
+        }
+    }
+    delete context->app;
+    delete context;
+    return 0;
+    END_API(-1)
+}
+
+int64_t ren_window_create(Context* context, const char* title, float width, float height, int resize)
+{
+    BEGIN_API
+    std::lock_guard<std::mutex> lock(context->mutex);
+    int64_t id = context->nextWindow++;
+    auto window = new Window(context, id, title, width, height, resize);
+    context->windows.emplace(id, BMessenger(window));
+    // BLooper::Run starts the looper and releases its initial constructor lock.
+    // Starting hidden makes subsequent Show calls have ordinary locking rules.
+    thread_id thread = window->Run();
+    if (thread < B_OK) {
+        window->Quit();
+        check(thread, "BWindow::Run");
+    }
+    return id;
+    END_API(0)
+}
+
+int ren_window_show(Context* context, int64_t id)
+{
+    BEGIN_API
+    WindowLock lock(context, id);
+    if (lock.window->IsHidden()) {
+        // Auto size limits change while the Python tree is mounted one view
+        // at a time. Restore the requested size after the tree is complete.
+        lock.window->ResizeTo(lock.window->initialWidth, lock.window->initialHeight);
+        lock.window->CenterOnScreen();
+        lock.window->Show();
+    }
+    lock.window->Activate();
+    return 0;
+    END_API(-1)
+}
+
+int ren_window_close(Context* context, int64_t id)
+{
+    BEGIN_API
+    WindowLock lock(context, id);
+    check(lock.window->PostMessage(B_QUIT_REQUESTED), "Window close");
+    return 0;
+    END_API(-1)
+}
+
+int ren_window_close_reply(Context* context, int64_t id, int allow)
+{
+    BEGIN_API
+    WindowLock lock(context, id);
+    if (lock.window->closePending) {
+        if (allow)
+            check(lock.window->PostMessage(kCloseAccepted), "Approve window close");
+        else
+            lock.window->closePending = false;
+    }
+    return 0;
+    END_API(-1)
+}
+
+int ren_window_title(Context* context, int64_t id, const char* title)
+{
+    BEGIN_API
+    WindowLock lock(context, id);
+    lock.window->SetTitle(title);
+    return 0;
+    END_API(-1)
+}
+
+int64_t ren_view_create(Context* context, int64_t wid, int64_t parent,
+    const char* kind, const char* text, const char* label, float a, float b)
+{
+    BEGIN_API
+    WindowLock lock(context, wid);
+    BGroupLayout* layout = parent == 0
+        ? dynamic_cast<BGroupLayout*>(lock.window->GetLayout())
+        : dynamic_cast<BGroupLayout*>(lock.view(parent)->GetLayout());
+    if (!layout) throw std::runtime_error("Parent is not a group layout");
+    int64_t id = lock.window->nextView++;
+    std::string name = "ren_" + std::to_string(id);
+    std::unique_ptr<BView> view;
+    BView* exposed = nullptr;
+    if (!strcmp(kind, "column") || !strcmp(kind, "row")) {
+        auto group = new BGroupView(name.c_str(), !strcmp(kind, "row") ? B_HORIZONTAL : B_VERTICAL, a);
+        group->GroupLayout()->SetInsets(b, b, b, b);
+        // Rows of fixed-size controls must not cap the containing window at
+        // their preferred size. Honor Window's requested size and resizing.
+        group->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED,
+            !strcmp(kind, "row") ? B_SIZE_UNSET : B_SIZE_UNLIMITED));
+        view.reset(group);
+    } else if (!strcmp(kind, "image")) {
+        view.reset(new ImageView(name.c_str(), text, a, b, label));
+    } else if (!strcmp(kind, "label")) {
+        view.reset(new BStringView(name.c_str(), text));
+    } else if (!strcmp(kind, "button")) {
+        view.reset(new BButton(name.c_str(), text, controlMessage(id)));
+    } else if (!strcmp(kind, "checkbox")) {
+        view.reset(new BCheckBox(name.c_str(), text, controlMessage(id)));
+    } else if (!strcmp(kind, "text")) {
+        auto input = new BTextControl(name.c_str(), label, text, controlMessage(id));
+        input->SetModificationMessage(controlMessage(id));
+        view.reset(input);
+    } else if (!strcmp(kind, "textarea")) {
+        auto input = std::make_unique<TextArea>(name.c_str(), context, wid, id, a != 0);
+        input->ReplaceText(text);
+        exposed = input.get();
+        // The scroll view owns its target, but public property access uses the
+        // inner text view. Both are destroyed with the containing window.
+        view.reset(new BScrollView((name + "_scroll").c_str(), input.get(),
+            uint32(0), a == 0, true, B_FANCY_BORDER));
+        input.release();
+    } else if (!strcmp(kind, "slider")) {
+        auto slider = new BSlider(name.c_str(), text, controlMessage(id), (int32)a, (int32)b, B_HORIZONTAL);
+        slider->SetModificationMessage(controlMessage(id));
+        view.reset(slider);
+    } else {
+        throw std::runtime_error("Unsupported widget type");
+    }
+    BView* raw = view.get();
+    if (!layout->AddView(raw)) throw std::runtime_error("Could not attach widget");
+    view.release(); // The window hierarchy now owns the view.
+    lock.window->views.emplace(id, exposed ? exposed : raw);
+    if (auto control = dynamic_cast<BControl*>(raw))
+        check(control->SetTarget(lock.window), "Control target");
+    return id;
+    END_API(0)
+}
+
+int ren_image_source(Context* context, int64_t wid, int64_t id, const char* path)
+{
+    BEGIN_API
+    WindowLock lock(context, wid);
+    auto image = dynamic_cast<ImageView*>(lock.view(id));
+    if (!image) throw std::runtime_error("Widget is not an image");
+    image->Replace(path);
+    return 0;
+    END_API(-1)
+}
+
+int ren_button_icon(Context* context, int64_t wid, int64_t id, const char* path, int size)
+{
+    BEGIN_API
+    if (size < 1 || size > 256) throw std::runtime_error("Invalid button icon size");
+    WindowLock lock(context, wid);
+    auto button = dynamic_cast<BButton*>(lock.view(id));
+    if (!button) throw std::runtime_error("Widget is not a button");
+    auto bitmap = path[0] ? buttonBitmap(path, size) : std::unique_ptr<BBitmap>();
+    // BButton copies the bitmap and supplies its native disabled/pressed states.
+    check(button->SetIcon(bitmap.get()), "Set button icon");
+    return 0;
+    END_API(-1)
+}
+
+int ren_view_set_text(Context* context, int64_t wid, int64_t id, const char* text)
+{
+    BEGIN_API
+    WindowLock lock(context, wid);
+    BView* view = lock.view(id);
+    if (auto area = dynamic_cast<TextArea*>(view)) area->ReplaceText(text);
+    else if (auto input = dynamic_cast<BTextControl*>(view)) input->SetText(text);
+    else if (auto label = dynamic_cast<BStringView*>(view)) label->SetText(text);
+    else if (auto control = dynamic_cast<BControl*>(view)) control->SetLabel(text);
+    else throw std::runtime_error("Widget has no text");
+    return 0;
+    END_API(-1)
+}
+
+const char* ren_view_text(Context* context, int64_t wid, int64_t id)
+{
+    BEGIN_API
+    WindowLock lock(context, wid);
+    BView* view = lock.view(id);
+    if (auto area = dynamic_cast<TextArea*>(view)) result = area->Text();
+    else if (auto input = dynamic_cast<BTextControl*>(view)) result = input->Text();
+    else if (auto label = dynamic_cast<BStringView*>(view)) result = label->Text();
+    else if (auto control = dynamic_cast<BControl*>(view)) result = control->Label() ? control->Label() : "";
+    else throw std::runtime_error("Widget has no text");
+    return result.c_str();
+    END_API(nullptr)
+}
+
+int ren_view_set_value(Context* context, int64_t wid, int64_t id, int value)
+{
+    BEGIN_API
+    WindowLock lock(context, wid);
+    lock.control(id)->SetValue(value);
+    return 0;
+    END_API(-1)
+}
+
+int ren_view_value(Context* context, int64_t wid, int64_t id, int* value)
+{
+    BEGIN_API
+    WindowLock lock(context, wid);
+    *value = lock.control(id)->Value();
+    return 0;
+    END_API(-1)
+}
+
+int ren_view_enabled(Context* context, int64_t wid, int64_t id, int enabled)
+{
+    BEGIN_API
+    WindowLock lock(context, wid);
+    if (auto area = dynamic_cast<TextArea*>(lock.view(id))) area->MakeEditable(enabled != 0);
+    else lock.control(id)->SetEnabled(enabled != 0);
+    return 0;
+    END_API(-1)
+}
+
+int ren_view_invoke(Context* context, int64_t wid, int64_t id)
+{
+    BEGIN_API
+    WindowLock lock(context, wid);
+    auto control = lock.control(id);
+    if (control->IsEnabled()) check(control->Invoke(), "Control invocation");
+    return 0;
+    END_API(-1)
+}
+
+int ren_alert(const char* title, const char* text)
+{
+    BEGIN_API
+    (new BAlert(title, text, "OK"))->Go();
+    return 0;
+    END_API(-1)
+}
+
+int ren_confirm(const char* title, const char* text, const char* accept, const char* cancel)
+{
+    BEGIN_API
+    auto dialog = new BAlert(title, text, cancel, accept);
+    dialog->SetShortcut(0, B_ESCAPE);
+    return dialog->Go() == 1 ? 1 : 0;
+    END_API(-1)
+}
+
+const char* ren_file_panel(int save, const char* title, const char* directory, const char* name)
+{
+    BEGIN_API
+    result.clear();
+    entry_ref start;
+    if (directory[0]) check(get_ref_for_path(directory, &start), "File panel directory");
+    auto reply = new PanelReply();
+    if (reply->done < B_OK || reply->Run() < B_OK) {
+        reply->Quit(); // Still holds its constructor lock.
+        throw std::runtime_error("Cannot start file panel");
+    }
+    {
+        BMessenger target(reply);
+        BFilePanel panel(save ? B_SAVE_PANEL : B_OPEN_PANEL, &target, directory[0] ? &start : nullptr,
+            B_FILE_NODE, false, nullptr, nullptr, true, true);
+        if (save && name[0]) panel.SetSaveText(name);
+        if (title[0] && panel.Window()->Lock()) {
+            panel.Window()->SetTitle(title);
+            panel.Window()->Unlock();
+        }
+        panel.Show();
+        // The panel is modal; wait here without holding any looper lock.
+        while (acquire_sem(reply->done) == B_INTERRUPTED) {}
+    }
+    if (reply->Lock()) {
+        result = reply->path;
+        reply->Quit();
+    }
+    return result.c_str();
+    END_API(nullptr)
+}
+
+int ren_clipboard_set(const char* text)
+{
+    BEGIN_API
+    if (!be_clipboard->Lock()) throw std::runtime_error("Clipboard is busy");
+    status_t status = be_clipboard->Clear();
+    if (status == B_OK)
+        status = be_clipboard->Data()->AddData("text/plain", B_MIME_TYPE, text, strlen(text));
+    if (status == B_OK) status = be_clipboard->Commit();
+    be_clipboard->Unlock();
+    check(status, "Clipboard write");
+    return 0;
+    END_API(-1)
+}
+
+const char* ren_clipboard_get()
+{
+    BEGIN_API
+    if (!be_clipboard->Lock()) throw std::runtime_error("Clipboard is busy");
+    const void* data = nullptr;
+    ssize_t size = 0;
+    status_t status = be_clipboard->Data()->FindData("text/plain", B_MIME_TYPE, &data, &size);
+    try {
+        result.assign(status == B_OK ? static_cast<const char*>(data) : "", status == B_OK ? size : 0);
+    } catch (...) {
+        be_clipboard->Unlock();
+        throw;
+    }
+    be_clipboard->Unlock();
+    return result.c_str();
+    END_API(nullptr)
+}
+
+int ren_launch(const char* url)
+{
+    BEGIN_API
+    std::string scheme(url);
+    scheme.resize(scheme.find(':'));
+    for (char& c : scheme) if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
+    std::string mime = "application/x-vnd.Be.URL." + scheme;
+    const char* arguments[] = {url};
+    check(be_roster->Launch(mime.c_str(), 1, arguments), "BRoster::Launch");
+    return 0;
+    END_API(-1)
+}
+
+const char* ren_directory(int which)
+{
+    BEGIN_API
+    if (which != 0) throw std::runtime_error("Unsupported directory");
+    BPath path;
+    check(find_directory(B_USER_SETTINGS_DIRECTORY, &path, true), "find_directory");
+    result = path.Path();
+    return result.c_str();
+    END_API(nullptr)
+}
+} // extern C