fflua_customluawindow.h

/*
 * File: fflua_customluawindow.h
 *
 *  Created by Jari Williamsson on 2015-11-01.
 *
 * ******* IMPORTANT!!! ******
 * Although this file is available in the PDK Framework folder, it should NOT be used in
 * the PDK Framework umbrella. This file is placed in the framework folder purely ONLY to
 * provide online documentation for the FCCustomLuaWindow class!
 *
 * (The file will ONLY make sense in the context of the specific
 * LuaBridge connection implementation.)
 *
 * The following class implementation is for the special FCCustomLuaWindow class in JW and RGP Lua. Since
 * a limitation of LuaBridge is that the include file can only be included at one place,
 * this work-around is used.
 *
 * If you include this header you must provide a LuaRun_ExceptionAbort function that prints the error
 * in the Lua output stream, disconnects and disposes of the Lua state, and displays the message to the user.
 * You can use lua_getstack to determine if LuaRun_ExceptionAbort is running under Lua and should throw the exception
 * up the chain rather than taking other actions.
 */
 
 
#ifndef jwlua_fflua_customluawindow_h
#define jwlua_fflua_customluawindow_h
 
#include <unordered_map>
#include <functional>
 
class FCCustomLuaWindow : public FCCustomWindow
{
    /* Lua event handlers */
        luabridge::LuaRef _handleCommand;
    luabridge::LuaRef _textSelectionChanged;
    luabridge::LuaRef _handleUpDownPressed;
        luabridge::LuaRef _handleDataListSelect;
        luabridge::LuaRef _handleDataListCheck;
    luabridge::LuaRef _handleListDoubleClick;
    luabridge::LuaRef _handleListEnterKey;
    luabridge::LuaRef _handleCancelButtonPressed;
    luabridge::LuaRef _handleOkButtonPressed;
    luabridge::LuaRef _handleInitWindow;
    luabridge::LuaRef _handleCloseWindow;
    luabridge::LuaRef _handleActivate;
    luabridge::LuaRef _handleTimer;
    luabridge::LuaRef _handleDarkModeIsChanging;
    luabridge::LuaRef _handleOSMenuCommandExecuted;
    luabridge::LuaRef _scrollChanged;
    luabridge::LuaRef _handleSaveRequest;
    luabridge::LuaRef _handleMouseTrackingStarted;
    luabridge::LuaRef _handleMouseTrackingStopped;
    std::unordered_map<FCControl *, luabridge::LuaRef> _controlHandles;
    std::function<void(lua_State *)> _disconnector;
    bool _inErrorRecovery;
#if OPERATING_SYSTEM == WINDOWS
    std::unique_ptr<luabridge::LuaException> _forwardedException;
#endif
    
    bool _RegisterHandler(luabridge::LuaRef &class_storage, luabridge::LuaRef &lua_callback_function)
    {
        if (!lua_callback_function.isFunction()) return false;
        class_storage = lua_callback_function;
        return true;
    }
    
#if OPERATING_SYSTEM == MAC_OS
    bool ModelessCancelCanEscape() const override { return true; }
#endif
    
    void WindowDestroyed() override
    {
        if (_disconnector && !IsModal())
            _disconnector(_handleCommand.state());
        FCCustomWindow::WindowDestroyed();
    }
    
    template<typename RT>
    auto _MakeLuaFunctionResult(bool success)
    {
        if constexpr (std::is_void<RT>::value)
            return std::pair(success, static_cast<void*>(nullptr));
        else
            return std::pair(success, RT{});
    }
 
    template<typename RT = void, typename... Args>
    auto CallLuaFunction(luabridge::LuaRef &luafunc, FCControl *pControl, Args... args)
    {
        auto retval = _MakeLuaFunctionResult<RT>(true);
        if (!_inErrorRecovery && luafunc.isFunction())
        {
            try
            {
                luabridge::LuaResult result = [&]()
                {
                    return pControl ? pControl->_LuaCallEventHandler(luafunc, LuaRun_ErrorFunction, args...)
                                    : luafunc.callWithHandler(LuaRun_ErrorFunction, args...);
                }();
                if (!result) result.raiseException();
                if constexpr (!std::is_void<RT>::value)
                {
                    if (result.size() > 0)
                    {
                        auto casted = result[0].cast<RT>();
                        if (casted)
                            retval.second = casted.value();
                    }
                }
            }
            catch (luabridge::LuaException &e)
            {
                _inErrorRecovery = true;
                retval.first = false;
#if OPERATING_SYSTEM == WINDOWS
                // Windows has to unwind modals differently than Mac,
                // due to a crash that seems to be related to throwing out of FX_Dialog when it is running a modal.
                if (IsModal() || luafunc == _handleInitWindow)
                {
                    _forwardedException.reset(new luabridge::LuaException(e));
                    if (luafunc == _handleCloseWindow || luafunc == _handleInitWindow) // we can't close while in init window event, unfortunately
                        retval.first = true;
                    else
                        CloseButtonPressed();
                }
                else
                    LuaRun_ExceptionAbort(e);
#else
                LuaRun_ExceptionAbort(e);
#endif
            }
        }
        return retval;
    }
 
    template<typename RT = void, typename... Args>
    auto CallLuaFunction(luabridge::LuaRef &luafunc, Args... args)
    {
        return CallLuaFunction<RT>(luafunc, static_cast<FCControl*>(nullptr), args...);
    }
 
    
public:
        FCCustomLuaWindow(lua_State * L) : FCCustomWindow(),
            _handleCommand(L),
            _textSelectionChanged(L),
            _handleUpDownPressed(L),
            _handleDataListSelect(L),
            _handleDataListCheck(L),
            _handleListDoubleClick(L),
            _handleListEnterKey(L),
            _handleCancelButtonPressed(L),
            _handleOkButtonPressed(L),
            _handleInitWindow(L),
            _handleCloseWindow(L),
            _handleActivate(L),
            _handleTimer(L),
            _handleDarkModeIsChanging(L),
            _handleOSMenuCommandExecuted(L),
            _scrollChanged(L),
            _handleSaveRequest(L),
            _handleMouseTrackingStarted(L),
            _handleMouseTrackingStopped(L),
            _disconnector(nullptr),
            _inErrorRecovery(false)
    {}
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if OPERATING_SYSTEM == WINDOWS
    twobyte ExecuteModal(__FCUserWindow* pParent) override
    {
        const twobyte retval = FCCustomWindow::ExecuteModal(pParent);
        if (_forwardedException)
            LuaRun_ExceptionAbort(*_forwardedException);
        return retval;
    }
#endif // OPERATING_SYSTEM == WINDOWS
#endif // DOXYGEN_SHOULD_IGNORE_THIS
    
    const char* ClassName() const override { return "FCCustomLuaWindow"; }
 
    bool ShowModeless()
    {
        if (! _disconnector)
            return false;
        FXWND hParent = GetFinaleMainWindow();
#if OPERATING_SYSTEM == WINDOWS
        const FCLuaScriptItem* pLuaScriptItem = GetControllingLuaScriptItem(_handleCommand.state());
        if (pLuaScriptItem && pLuaScriptItem->GetControllingWindow())
            hParent = pLuaScriptItem->GetControllingWindow()->GetWindowHandle();
#endif
        FCCustomWindow::ShowModeless(hParent);
        return true;
    }
    
    bool ShowModelessWithGrabbyFocus()
    {
#if OPERATING_SYSTEM == MAC_OS
        _FCWindowController_cocoa* pCocoaLink = _GetCocoaLink();
        if (pCocoaLink) pCocoaLink->SetModelessCanBecomeMainWindow(true);
#endif
        return ShowModeless();
    }
    
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void SetDisconnector(std::function<void(lua_State *)> func)
    { _disconnector = func; }
#endif
 
        bool RegisterHandleCommand(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_handleCommand, lua_callback_function);
    }
 
    bool RegisterHandleControlEvent(FCControl * pControl, luabridge::LuaRef lua_callback_function)
    {
        if (! lua_callback_function.isFunction()) return false;
        auto it = _controlHandles.find(pControl);
        if (it == _controlHandles.end())
            _controlHandles.emplace(pControl, lua_callback_function);
        else
            it->second = lua_callback_function;
        return true;
    }
 
    bool RegisterTextSelectionChanged(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_textSelectionChanged, lua_callback_function);
    }
 
    bool RegisterScrollChanged(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_scrollChanged, lua_callback_function);
    }
 
    bool RegisterHandleKeyboardCommand(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_handleSaveRequest, lua_callback_function);
    }
 
    bool RegisterHandleUpDownPressed(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_handleUpDownPressed, lua_callback_function);
    }
 
        bool RegisterHandleDataListSelect(luabridge::LuaRef lua_callback_function)
        {
                return _RegisterHandler(_handleDataListSelect, lua_callback_function);
        }
 
        bool RegisterHandleDataListCheck(luabridge::LuaRef lua_callback_function)
        {
                return _RegisterHandler(_handleDataListCheck, lua_callback_function);
        }
 
    bool RegisterHandleListDoubleClick(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_handleListDoubleClick, lua_callback_function);
    }
 
    bool RegisterHandleListEnterKey(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_handleListEnterKey, lua_callback_function);
    }
 
    bool RegisterHandleCancelButtonPressed(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_handleCancelButtonPressed, lua_callback_function);
    }
 
    bool RegisterHandleOkButtonPressed(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_handleOkButtonPressed, lua_callback_function);
    }
 
    bool RegisterInitWindow(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_handleInitWindow, lua_callback_function);
    }
 
    bool RegisterCloseWindow(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_handleCloseWindow, lua_callback_function);
    }
 
    bool RegisterHandleActivate(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_handleActivate, lua_callback_function);
    }
 
    bool RegisterHandleTimer(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_handleTimer, lua_callback_function);
    }
 
    bool RegisterDarkModeIsChanging(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_handleDarkModeIsChanging, lua_callback_function);
    }
    
    bool RegisterOSMenuCommandExecuted(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_handleOSMenuCommandExecuted, lua_callback_function);
    }
    
    bool RegisterMouseTrackingStarted(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_handleMouseTrackingStarted, lua_callback_function);
    }
    
    bool RegisterMouseTrackingStopped(luabridge::LuaRef lua_callback_function)
    {
        return _RegisterHandler(_handleMouseTrackingStopped, lua_callback_function);
    }
 
    bool HandleControlEvent(FCControl* pControl)
    {
        auto it = _controlHandles.find(pControl);
        if (it == _controlHandles.end()) return false;
        if (pControl)
            CallLuaFunction(it->second, pControl);
        return true; // return true even if exception, to avoid HandleCommand() trying it again
    }
 
        bool HandleCommand(FCControl* pControl) override
    {
        bool result = FCCustomWindow::HandleCommand(pControl);
        if (pControl && !HandleControlEvent(pControl))
            CallLuaFunction(_handleCommand, pControl);
        return result;
    }
    
    void TextSelectionChanged(FCControl* pControl) override
    {
        FCCustomWindow::TextSelectionChanged(pControl);
        if (pControl)
            CallLuaFunction(_textSelectionChanged, pControl);
    }
    
    void ScrollChanged(FCControl* pControl) override
    {
        FCCustomWindow::TextSelectionChanged(pControl);
        if (pControl)
            CallLuaFunction(_scrollChanged, pControl);
    }
    
    bool HandleKeyboardCommand(FCControl* pControl, eUniChar16 character) override
    {
        auto [success, funcResult] = CallLuaFunction<bool>(_handleSaveRequest, pControl, character);
        if (success && funcResult)
            return true;
        return FCCustomWindow::HandleKeyboardCommand(pControl, character);
    }
 
    void HandleUpDownPressed(FCControl* pControl, int delta) override
    {
        FCCustomWindow::HandleUpDownPressed(pControl, delta);
        if (pControl)
            CallLuaFunction(_handleUpDownPressed, pControl, delta);
    }
 
        void HandleDataListSelect(FCCtrlDataList* pControl, int lineindex) override
        {
                FCCustomWindow::HandleDataListSelect(pControl, lineindex);
        if (pControl)
            CallLuaFunction(_handleDataListSelect, pControl, lineindex);
        }
 
        void HandleDataListCheck(FCCtrlDataList* pControl, int lineindex, bool checkstate) override
        {
                FCCustomWindow::HandleDataListCheck(pControl, lineindex, checkstate);
        if (pControl)
            CallLuaFunction(_handleDataListCheck, pControl, lineindex, checkstate);
        }
 
    void HandleListDoubleClick(FCControl* pControl) override
    {
        FCCustomWindow::HandleListDoubleClick(pControl);
        if (pControl)
            CallLuaFunction(_handleListDoubleClick, pControl);
    }
 
    bool HandleListEnterKey(FCControl* pControl) override
    {
        if (pControl)
        {
            auto [success, funcResult] = CallLuaFunction<bool>(_handleListEnterKey, pControl);
            if (success && funcResult)
                return true;
        }
        return FCCustomWindow::HandleListEnterKey(pControl);
    }
    
    void CancelButtonPressed() override
    {
        auto [success, _] = CallLuaFunction(_handleCancelButtonPressed);
        if (success)
            FCCustomWindow::CancelButtonPressed();
    }
    
    void OkButtonPressed() override
    {
        auto [success, _] = CallLuaFunction(_handleOkButtonPressed);
        if (success)
            FCCustomWindow::OkButtonPressed();
    }
 
    void InitWindow() override
    {
        FCCustomWindow::InitWindow();
        CallLuaFunction(_handleInitWindow);
    }
 
    void CloseWindow() override
    {
        auto [success, _] = CallLuaFunction(_handleCloseWindow);
        if (success)
            FCCustomWindow::CloseWindow();
    }
 
    void HandleActivate(bool activated) override
    {
        FCCustomWindow::HandleActivate(activated);
        CallLuaFunction(_handleActivate, activated);
    }
 
    void HandleTimer(twobyte timerID) override
    {
        FCCustomWindow::HandleTimer(timerID);
        CallLuaFunction(_handleTimer, timerID);
    }
 
    void DarkModeIsChanging(bool isDarkMode) override
    {
        FCCustomWindow::DarkModeIsChanging(isDarkMode);
        CallLuaFunction(_handleDarkModeIsChanging, isDarkMode);
    }
    
    void OSMenuCommandExecuted(EMENUID menuCommand, int menuCommandType) override
    {
        FCCustomWindow::OSMenuCommandExecuted(menuCommand, menuCommandType);
        CallLuaFunction(_handleOSMenuCommandExecuted, menuCommand, menuCommandType);
    }
 
    void MouseTrackingStarted(FCControl* pControl) override
    {
        FCCustomWindow::MouseTrackingStarted(pControl);
        CallLuaFunction(_handleMouseTrackingStarted, pControl);
    }
 
    void MouseTrackingStopped(FCControl* pControl) override
    {
        FCCustomWindow::MouseTrackingStopped(pControl);
        CallLuaFunction(_handleMouseTrackingStopped, pControl);
    }
};
 
#endif