ff_dialogs.h

/*
 * File:   ff_dialogs.h
 * Author: Jari Williamsson
 *
 * Created on den 24 januari 2011, 10:02
 */
 
#ifndef FF_DIALOGS_H
#define FF_DIALOGS_H
 
#include <set>
#include <map>
 
#include "ff_basecollection.h"
#if OPERATING_SYSTEM == MAC_OS
#include <finaleframework_cocoa.h>
#include <ff_cocoa_cppinterface.h>
#endif
#ifdef PDK_FRAMEWORK_CANVASCTRL
#include "ff_fcctrlcanvas.h"
#endif
 
#ifdef PDK_FRAMEWORK_DIALOGS
#include <variant>
#endif
 
#ifdef PDK_FRAMEWORK_FILEDIALOGS
 
#if OPERATING_SYSTEM == WINDOWS
#include <commdlg.h>
#include <richedit.h>
#include <vssym32.h>
#endif
 
/* Tech info: Since the file/folder dialogs on Windows requires the -lcomdlg32 and -lole32
 * linker options to be set in MinGW, these classes require a
 * dedicated #define.
 *
 *  */
 
 
class __FCFileDialogBase : public __FCBase
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    FCUI*       _pUI;
    FCStrings   _filters;               /* List of strings with filters, such as "*.txt" or "*.*" */
    FCStrings   _filterdescriptions;    /* The number of filter description match the filters */
    int         _defaultfilterindex;
    FCString    _windowtitle;
    FCString    _filename;
    FCString    _initfolder;
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
public:
    __FCFileDialogBase(FCUI* pUI) : __FCBase()
    {
        _pUI = pUI;
        _defaultfilterindex = 0;
    }
    const char* ClassName() const override { return "__FCFileDialogBase"; }
 
    void AddFilter(FCString* pFilter, FCString* pFilterDescription)
    {
        if (!pFilter) return;
        if (!pFilterDescription) return;
        FCString* pNewString = new FCString();
        pNewString->SetString(pFilter);
        _filters.Add(pNewString);
        pNewString = new FCString();
        pNewString->SetString(pFilterDescription);
        _filterdescriptions.Add(pNewString);
    }
 
    FCStrings* _GetFilters() { return &_filters; }
    
    void SetDefaultFilter(int index)
    {
        if (index < 0) return;
        if (index >= _filters.GetCount()) return;
        _defaultfilterindex = index;
    }
 
    void SetWindowTitle(FCString* pString)
    {
        _windowtitle.SetString(pString);
    }
 
    void SetFileName(FCString* pString)
    {
        _filename.SetString(pString);
    }
    
    void SetInitFolder(FCString* pString)
    {
        _initfolder.SetString(pString);
    }
 
    void GetWindowTitle(FCString* pString)
    {
        if (!pString) return;
        pString->SetString(&_windowtitle);
    }
 
     void GetFileName(FCString* pString)
    {
        if (!pString) return;
        pString->SetString(&_filename);
    }
 
    void GetInitFolder(FCString* pString)
    {
        if (!pString) return;
        pString->SetString(&_initfolder);
    }
 
    bool AssureFileExtension(const char* pszSuffix)
    {
        if (!pszSuffix) return false;
        if (pszSuffix[0] != '.') return false;
        FCString extension;
        extension.SetString(&_filename);
        extension.ExtractFileExtension();
        if (extension.IsEmpty()) _filename.AppendCString(pszSuffix);
        return true;
    }
 
    virtual bool Execute() = 0;
};
 
class FCFileOpenDialog : public __FCFileDialogBase
{
    FCStrings   _multifiles;
    bool        _multiselect;
    
    bool _Execute();
    
public:
    FCFileOpenDialog(FCUI* pUI) : __FCFileDialogBase(pUI)
    {
        _multiselect = false;
    }
    const char* ClassName() const override { return "FCFileOpenDialog"; }
 
    void SetMultiSelect(bool value) { _multiselect = value; }
 
    bool GetMultiSelect() const { return _multiselect; }
    
 
    void GetFileNames(FCStrings* pStrings)
    {
        if (!pStrings) return;
        pStrings->CopyFrom(&_multifiles);
    }
 
    void _SetFileNames(FCStrings* pStrings)
    {
        _multifiles.CopyFrom(pStrings);
    }
    
    bool Execute() override
    {
        _pUI->_NotifyModalWindowWillOpen();
        bool rslt = _Execute();
        _pUI->_NotifyModalWindowDidClose();
        return rslt;
    }
};
 
class FCFileSaveAsDialog : public __FCFileDialogBase
{
    bool _Execute();
 
public:
    FCFileSaveAsDialog(FCUI* pUI) : __FCFileDialogBase(pUI)
    {
    }
    const char* ClassName() const override { return "FCFileSaveAsDialog"; }
 
    bool Execute() override
    {
        _pUI->_NotifyModalWindowWillOpen();
        bool rslt = _Execute();
        _pUI->_NotifyModalWindowDidClose();
        return rslt;
    }
};
 
class FCFolderBrowseDialog : public __FCBase
{
    bool        _usefinaleapi;  /* Use the native Finale API on Finale 25+, defaults to ON. */
    FCString    _windowtitle;
    FCString    _folderpath;   /* The folder path (in/out) */
    FCUI*       _pUI;
 
    bool _Execute();
 
public:
    FCFolderBrowseDialog(FCUI* pUI)
    {
        _pUI = pUI;
        _usefinaleapi = true;
    }
    const char* ClassName() const override { return "FCFolderBrowseDialog"; }
 
    void SetFolderPath(FCString* pString) { _folderpath.SetString(pString); }
 
    void SetWindowTitle(FCString* pString) { _windowtitle.SetString(pString); }
    
    void SetUseFinaleAPI(bool state) { _usefinaleapi = state; }
 
    void GetFolderPath(FCString* pString)
    {
        if (!pString) return;
        pString->SetString(&_folderpath);
    }
 
    void GetWindowTitle(FCString* pString)
    {
        if (!pString) return;
        pString->SetString(&_windowtitle);
    }
 
    bool GetUseFinaleAPI() const { return _usefinaleapi; }
    
    bool Execute()
    {
        _pUI->_NotifyModalWindowWillOpen();
        bool rslt = _Execute();
        _pUI->_NotifyModalWindowDidClose();
        return rslt;
    }
};
 
#endif   /* #ifdef PDK_FRAMEWORK_FILEDIALOGS */
 
 
#ifdef PDK_FRAMEWORK_DIALOGS
 
/* Some forward class declarations */
class FCControl;
class FCCtrlDataList;
class FCCtrlSwitcher;
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
// _NONWINDOW_PROPERTY classes should really just be a std::optional, but
// refactoring them turns out to be not completely trivial. This template
// partially addresses the issue.
 
template <typename T>
struct _NONWINDOW_PROPERTY_BASE
{
    T value{};
    bool has_been_set{};
    
    _NONWINDOW_PROPERTY_BASE() = default;
};
 
template <typename T>
struct _NONWINDOW_PROPERTY : public _NONWINDOW_PROPERTY_BASE<T>
{
    _NONWINDOW_PROPERTY() = default;
    _NONWINDOW_PROPERTY(const T&& value) : _NONWINDOW_PROPERTY_BASE<T>()
    { SetValue(value);}
 
    void SetValue(const T& newvalue) {
        this->value = newvalue;
        this->has_been_set = true;
    }
};
 
struct _NONWINDOW_PROPERTY_FCSTRING : public _NONWINDOW_PROPERTY<FCString>
{
    _NONWINDOW_PROPERTY_FCSTRING() = default;
    
    void SetIntegerValue(int anint) {
        value.SetInteger(anint);
        has_been_set = true;
    }
    
#ifdef PDK_FRAMEWORK_PREFS
    void SetMeasurementValue(double measurement, twobyte measurementunit) {
        value.SetMeasurement(measurement, measurementunit);
        has_been_set = true;
    }
#endif //PDK_FRAMEWORK_PREFS
};
 
// inherit from _NONWINDOW_PROPERTY_BASE to prevent access to SetValue, which
// __FCCollection does not support. (I don't trust its operator=.)
struct _NONWINDOW_PROPERTY_FCSTRINGS : public _NONWINDOW_PROPERTY_BASE<FCStrings>
{
    _NONWINDOW_PROPERTY_FCSTRINGS() = default;
    
    void AppendString(FCString* pString)
    {
        value.AddCopy(pString);
        has_been_set = true;
    }
    
    void ClearAll()
    {
        value.ClearAll();
        has_been_set = true;
    }
};
 
// inherit from _NONWINDOW_PROPERTY_BASE to prevent access to SetValue, which
// __FCCollection does not support. (I don't trust its operator=.)
struct _NONWINDOW_PROPERTY_FCNUMBERS : public _NONWINDOW_PROPERTY_BASE<FCNumbers>
{
    _NONWINDOW_PROPERTY_FCNUMBERS() = default;
    
    void AppendInt(int anint)
    {
        value.AddInt(anint);
        has_been_set = true;
    }
    
    void AppendFloat(double afloat)
    {
        value.AddFloat(afloat);
        has_been_set = true;
    }
    
    void ClearAll()
    {
        value.ClearAll();
        has_been_set = true;
    }
};
 
struct __FCUserWindow_NONWINDOWSTORAGE
{
    _NONWINDOW_PROPERTY_FCSTRING    title;
    _NONWINDOW_PROPERTY<float>      width;
    _NONWINDOW_PROPERTY<float>      height;
    _NONWINDOW_PROPERTY<float>      clientheight;
    _NONWINDOW_PROPERTY<float>      clientwidth;
};
#endif  /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
 
class __FCUserWindow : public __FCCollection
{
    /* Storage for the modifier keys held down at the last HandleCommand() event. */
    FLAG_32 _lastcommandmodifierkeys;
    
    bool _preventclose;
 
#if OPERATING_SYSTEM == WINDOWS
    HFONT _shellfont;
    bool _is_dpi_aware;
    double _window_dpi_x;
    double _window_dpi_y;
#endif
 
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS    
    /* Storage for the variables that will be available when the window handle isn't: */
    __FCUserWindow_NONWINDOWSTORAGE nonwindow_store;
#if OPERATING_SYSTEM == WINDOWS
    bool _wants_dpi_awareness;
#endif // OPERATING_SYSTEM == WINDOWS
#endif // #ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
private:
    twobyte _modalresult;     /* The modal result ID (IDOK or IDCANCEL) */
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if OPERATING_SYSTEM == MAC_OS
protected:
    _FCWindowController_cocoa* _pCocoaLink;
#endif /* MAC_OS */
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
private:
    bool _pointsmeasurement;  /* If true, measurement/positioning is in points. Otherwise, in system-native units. */
#if OPERATING_SYSTEM == WINDOWS
    HWND _hwnd;                 // The standard Windows handle.
    HINSTANCE _hRichEditDll;     // If non-NULL, the dll handle for the Rich Edit control.
#endif
    float _maximumresizewidth;
    float _minimumresizewidth;
    float _maximumresizeheight;
    float _minimumresizeheight;
    float _oldresizewidth;
    float _oldresizeheight;
 
    // Members for window position storage:
    bool _positionstored;
    float _storedxpos;
    float _storedypos;
    bool _sizestored;
    float _storedwidth;
    float _storedheight;
 
    // Members for window shade handling:    
    bool _isinwindowshademode;
    float _nonwindowshadeheight;
 
    bool _bufferedcontrolmovement;
#if OPERATING_SYSTEM == WINDOWS
    bool _initwindowcalled;
#endif
    bool _restorepositioncalled;
 
#if PDK_FRAMEWORK_DIAGNOSE
        void _CheckControls();
#endif
    
    friend class _FCWindowController_cocoa;
 
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    
    void _CreateDynamicControls();
    
    virtual void _InitNonWindowHandleStates();
    
    void _StoreNonWindowHandleStates();
    
    bool _ismodal;
    
    bool _closewindowcalled;  /* To prevent multiple CloseWindow() calls
                               * which is bad on the Mac */
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
    
    twobyte GetModalResult() { return _modalresult; }
        
public:
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    FLAG_32 _GetLastCommandModifierKeys() const { return _lastcommandmodifierkeys; }
 
    void _SetLastCommandModifierKeys(FLAG_32 value) { _lastcommandmodifierkeys = value; }
 
#if OPERATING_SYSTEM == WINDOWS
    void _LoadRichEditDll();
#endif // OPERATING_SYSTEM == WINDOWS
 
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
    enum COMMAND_MOD_KEYS
    {
        CMDMODKEY_SHIFT = 0x00000001,
        
        CMDMODKEY_ALT = 0x00000002,
        
        CMDMODKEY_CTRL = 0x00000004,
        
        CMDMODKEY_COMMAND = 0x00000008,
        
        CMDMODKEY_FUNCTION = 0x00000010
    };
    
    enum MENU_COMMAND_TYPES
    {
        MENUCMDTYPE_SELECTION = 0,
        
        MENUCMDTYPE_ACCELERATOR = 1
    };
    
    
    __FCUserWindow() : __FCCollection()
    {
        _lastcommandmodifierkeys = 0x0;
        _preventclose = false;
        _pointsmeasurement = false;
#if OPERATING_SYSTEM == MAC_OS
        _pCocoaLink = NULL;
#else
        _shellfont = NULL;
        _wants_dpi_awareness = false;
        _is_dpi_aware = false;
        _window_dpi_x = 0;
        _window_dpi_y = 0;
        _hwnd = NULL;
        _hRichEditDll = NULL;
#endif
        _ismodal = false;
        _modalresult = 0;
        _closewindowcalled = false;
        _maximumresizewidth = _minimumresizewidth =
                _maximumresizeheight = _minimumresizeheight =
                _oldresizewidth = _oldresizeheight = 0;
        _positionstored = _sizestored = false;
        _isinwindowshademode = false;
        _nonwindowshadeheight = 0;
        WINCODE(_initwindowcalled = false;)
        _restorepositioncalled = false;
        _bufferedcontrolmovement = false;
    }
 
    ~__FCUserWindow()
    {
#if OPERATING_SYSTEM == WINDOWS
       DeleteObject(_shellfont); // doesn't matter if it's already null.
       _shellfont = NULL;
       if (_hRichEditDll)
       {
           FreeLibrary(_hRichEditDll);
           _hRichEditDll = NULL;
       }
#endif // OPERATING_SYSTEM == WINDOWS
    }
 
    const char* ClassName() const override { return "__FCUserWindow"; }
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    FCUI* CreateChildUI(lua_State* L) const
#else
    FCUI* CreateChildUI() const
#endif
    {
        if (!WindowExists()) return nullptr;
        FXWND hParent = WINCODE(GetWindowHandle()) MACCODE(nullptr);
        return new _NOLUACODE(FCUI(hParent)) _LUACODE(FCUI(hParent, L));
    }
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCUI> CreateChildUI_GC(lua_State* L)
    { return makeLuaSharedPtr(CreateChildUI(L)); }
#endif
 
    bool GetPointsMeasurement()
    {
        return _pointsmeasurement;
    }
    
    bool IsModal() { return _ismodal; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
         void _WinStoreModifierKeys();
 
    void _SetPointsMeasurement(bool use_points)
    {
        _pointsmeasurement = use_points;
    }
            
    void _SetModalResult(twobyte modalresultid) { _modalresult = modalresultid; }
    
    bool _GetCloseWindowCalled() { return _closewindowcalled; }
 
    void _HandleResizeChange(int newwidth, int newheight);
 
#if OPERATING_SYSTEM == WINDOWS
    void _SetModelessEnabledState();
 
    void _call_FX_Dialog(
       const twobyte nDlgID,                            // id for dialog template
       FF_DialogHandlerUPP lpCallBack,          // dialog handler routine
       const FXWND hParent,                                     // parent dialog
       const twobyte dlgFlags,                          // DIALOG_TYPE_MASK
       void* const data);
 
    bool _GetIsDpiAware() const { return _is_dpi_aware; }
    double _GetWindowDpiX() const { return _window_dpi_x; }
    double _GetWindowDpiY() const { return _window_dpi_y; }
    HFONT _GetShellFont() const { return _shellfont; }
    void _SetWindowDpiFromSystem();
 
    /* Conversion routines between pixels and points. These must be public, since they
    need to be accessible for FCCustomWindow and FCControl as well. */
 
    double _WinHorizPixelsToPoints(double value) const;
    double _WinVertPixelsToPoints(double value) const;
    double _WinHorizPointsToPixels(double value) const;
    double _WinVertPointsToPixels(double value) const;
#endif // OPERATING_SYSTEM == WINDOWS
#endif // #ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    void SetEnabled(bool state);
    
    FCControl* GetItemAt(int index) const { return (FCControl*) __FCCollection::GetItemAt(index); }
 
    void SetWidth(float newwidth);
    
    float GetWidth();
    
    void SetHeight(float newheight);
    
    float GetHeight();
    
    void SetClientWidth(float newwidth);
    
    float GetClientWidth();
    
    void SetClientHeight(float newheight);
    
    float GetClientHeight();
    
    bool IsDarkModeAppearance() const;
    
    void SetTitle(FCString* pTitle);
    
    void GetTitle(FCString* pTitle);
    
    bool QueryLastCommandModifierKeys(FLAG_32 modifiers)
    {
        return ((_lastcommandmodifierkeys & modifiers) == modifiers);
    }
    
    virtual void CloseWindow() = 0;
    
    bool TryToCloseWindow()
    {
        if (!CanClose()) return false;        
        CloseWindow();
        return true;
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if OPERATING_SYSTEM == MAC_OS
    _FCWindowController_cocoa* _GetCocoaLink() const
    {
        return _pCocoaLink;
    }
    
    virtual bool ModelessCancelCanEscape() const { return false; }
 
#else
    void _SetWindowHandle(EWND hwnd) {
        _hwnd = hwnd;
    }
 
    EWND GetWindowHandle() const { return _hwnd; }
#endif
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
    
    void SetMaximumResizeWidth(int width)
    {
        _maximumresizewidth = width;
#if OPERATING_SYSTEM == MAC_OS
        /* On Cocoa, use the built-in maxsize */
        _FCWindowController_cocoa* pCocoaLink = _GetCocoaLink();
        if (!pCocoaLink) return;
        pCocoaLink->SetMaximumResizeWidth(width);
#endif
    }
 
    void SetMaximumResizeHeight(int height)
    {
       _maximumresizeheight = height;
#if OPERATING_SYSTEM == MAC_OS
        /* On Cocoa, use the built-in maxsize */
        _FCWindowController_cocoa* pCocoaLink = _GetCocoaLink();
        if (!pCocoaLink) return;
        pCocoaLink->SetMaximumResizeHeight(height);
#endif
    }
 
    float GetMinimumResizeWidth()
    {
        return _minimumresizewidth;
    }
 
    float GetMinimumResizeHeight()
    {
        if (_isinwindowshademode) return 0;
        return _minimumresizeheight;
    }
 
    float GetMaximumResizeWidth()
    {
        return _maximumresizewidth;
    }
 
    float GetMaximumResizeHeight()
    {
       return _maximumresizeheight;
    }
 
    bool WindowExists() const;
 
    void Hide();
 
    void ShowAndActivate();
 
    virtual void InitWindow();
 
    virtual void WindowDestroyed() {}
    
    virtual void DarkModeIsChanging([[maybe_unused]]bool isDarkMode) {}
    
    virtual void OSMenuCommandExecuted([[maybe_unused]]EMENUID menuCommand, [[maybe_unused]]int menuCommandType) {}
 
    virtual void CloseButtonPressed()
    {
        _SetModalResult(0);
        if (!_GetCloseWindowCalled()) TryToCloseWindow();
    }
 
    virtual void OkButtonPressed()
    {
        _SetModalResult(IDOK);
        if (!_GetCloseWindowCalled()) TryToCloseWindow();
    }
 
    virtual void CancelButtonPressed()
    {
        _SetModalResult(IDCANCEL);
        if (!_GetCloseWindowCalled()) TryToCloseWindow();
    }
 
    virtual bool HandleCommand([[maybe_unused]]FCControl* pControl) { return false; }
 
    virtual void TextSelectionChanged([[maybe_unused]]FCControl* pControl) {}
 
    virtual void ScrollChanged([[maybe_unused]]FCControl* pControl) {}
    
    virtual bool HandleKeyboardCommand([[maybe_unused]]FCControl* pControl, [[maybe_unused]]eUniChar16 character) { return false; }
 
    virtual void HandleSwitcherSelect(FCCtrlSwitcher* pControl, int switchindex);
    
    virtual void HandleUpDownPressed([[maybe_unused]]FCControl* pControl, [[maybe_unused]]int delta) {}
 
        virtual void HandleDataListSelect([[maybe_unused]]FCCtrlDataList* pControl, [[maybe_unused]]int lineindex) {}
 
        virtual void HandleDataListCheck([[maybe_unused]]FCCtrlDataList* pControl, [[maybe_unused]]int lineindex, [[maybe_unused]]bool checkstate) {}
 
   virtual void HandleListDoubleClick([[maybe_unused]]FCControl* pControl) {}
 
    virtual bool HandleListEnterKey([[maybe_unused]]FCControl* pControl) { return false; }
 
    virtual void HandleTimer([[maybe_unused]]twobyte timerID) {}
 
    virtual void HandleActivate([[maybe_unused]]bool activated) {}
 
    virtual void HandleResize([[maybe_unused]]int newwidth, [[maybe_unused]]int newheight, [[maybe_unused]]int oldwidth, [[maybe_unused]]int oldheight) {}
 
    virtual void MouseTrackingStarted([[maybe_unused]]FCControl* pControl) {}
 
    virtual void MouseTrackingStopped([[maybe_unused]]FCControl* pControl) {}
 
    FCControl* FindControl(int controlid);
 
    void SetTimer(twobyte timerID, ufourbyte msInterval);
    
    void StopTimer(twobyte timerID);
 
    void Activate();
    
    bool GetPreventClosing() const { return _preventclose; }
    
    void SetPreventClosing(bool state) { _preventclose = state; }
 
    virtual bool CanClose() { return !_preventclose; }
 
    bool IsVisible();
 
    void StorePosition(bool storesize);
 
    bool RestorePosition();
 
    void SetRestorePositionData(float x, float y, float width, float height);
 
    void SetRestorePositionOnlyData(float x, float y);
 
    float GetStoredX() const;
 
    float GetStoredY() const;
 
    float GetStoredWidth() const;
 
    float GetStoredHeight() const;
 
    bool IsWindowshade() { return _isinwindowshademode; }
 
    void Windowshade(bool windowshade);
    
    void SetWindowAlpha(twobyte alphapercent);
 
    void StartBufferControlMovement();
 
    bool EndBufferControlMovement();
 
    bool IsInBufferMode() { return _bufferedcontrolmovement; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetRestorePositionCalled(bool value)
    {
        _restorepositioncalled = value;
    }
 
#if OPERATING_SYSTEM == WINDOWS
    void _WinSetInitWindowCalled(bool value)
    {
        _initwindowcalled = value;
    }
 
    void _WinPostRestorePosition()
    {
        if (!_initwindowcalled) return;
        if (!_restorepositioncalled) return;
        RestorePosition();
    }
#endif // OPERATING_SYSTEM == WINDOWS
#endif // DOXYGEN_SHOULD_IGNORE_THIS
};
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
struct __FCControl_NONWINDOWSTORAGE
{
    _NONWINDOW_PROPERTY_FCSTRING    text;
    _NONWINDOW_PROPERTY<bool>       enabled;
    _NONWINDOW_PROPERTY<bool>       visible;
    _NONWINDOW_PROPERTY<float>      left;
    _NONWINDOW_PROPERTY<float>      top;
    _NONWINDOW_PROPERTY<float>      width;
    _NONWINDOW_PROPERTY<float>      height;
};
 
class FCCtrlUpDown;
class FCCtrlDataList;
class FCCtrlTree;
class FCCtrlButton;
class FCCtrlCheckbox;
class FCCtrlRadioButton;
class FCCtrlEdit;
class FCCtrlTextEditor;
class FCCtrlStatic;
class FCCtrlPopup;
class FCCtrlComboBox;
class FCCtrlLine;
class FCCtrlHorizontalLine;
class FCCtrlVerticalLine;
class FCCtrlSlider;
class FCCtrlListBox;
class FCCtrlSwitcher;
#ifdef PDK_FRAMEWORK_IMAGECTRL
class FCCtrlImage;
#endif
#ifdef PDK_FRAMEWORK_CANVASCTRL
class FCCtrlCanvas;
#endif
 
using __FCControlTypedPtr = std::variant<
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                                FCControl *,    // allow C++ code to bypass __FCControlTypedPtr feature
#endif
#ifdef PDK_FRAMEWORK_CANVASCTRL
                                FCCtrlCanvas *,
#endif
#ifdef PDK_FRAMEWORK_IMAGECTRL
                                FCCtrlImage *,
#endif
                                FCCtrlUpDown *,
                                FCCtrlDataList *,
                                FCCtrlTree *,
                                FCCtrlButton *,
                                FCCtrlCheckbox *,
                                FCCtrlRadioButton *,
                                FCCtrlEdit *,
                                FCCtrlTextEditor *,
                                FCCtrlStatic *,
                                FCCtrlPopup *,
                                FCCtrlComboBox *,
                                FCCtrlLine *,
                                FCCtrlHorizontalLine *,
                                FCCtrlVerticalLine *,
                                FCCtrlSlider *,
                                FCCtrlListBox *,
                                FCCtrlSwitcher *
                            >;
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
 
class FCControl : public __FCBase
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS    
    const __FCControlTypedPtr _subtypeptr; // used for calling Lua with the fully typed control
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
   std::unique_ptr<FCFontInfo> _fontinfo; // used for SetFont
#if OPERATING_SYSTEM == WINDOWS
        HFONT _storednewfont;  /* If the control has a custom font */
#endif // OPERATING_SYSTEM == WINDOWS
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
public:
    enum CONTROL_ACTIONS {
        ACTION_NONE = 0,
        ACTION_OK = 1,
        ACTION_CLOSE = 2,
        ACTION_CANCEL = 3
    };
 
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS    
    /* States for when the control handle isn't available: */
    __FCControl_NONWINDOWSTORAGE nonwindow_store;
 
#if OPERATING_SYSTEM == WINDOWS
    int _WinCalcFontHeightFromSize(HDC hDC, int size);
    
    virtual double _CalcNonTextWidth() const { return 0.0; }
    double _CalcNonTextWidthFromTheme(int partID, int stateID, double additionalHardcodedValue, double fallbackHardcodedValue) const;
#endif // OPERATING_SYSTEM == WINDOWS
#endif // #ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
private:
    bool _pointsmeasurement;   /* If true, all measurements and positioning is in points. If false,
                            measurement is system native. */
    bool _programmaticallycreate; /* True - create the control in code. False - control is available in resource. */
    bool _autoresizewidth; // True - autoresize the width whenever SetText is called. Only supported on some controls.
    std::map<int, int> _nooverlapControls; // collection of control IDs and corresponding pad values for no-overlap controls
    int _alignwithID; // if non-zero, the control ID to horizontally align with
    bool _alignwithRight; // if true, align the control to the right.
    double _alignwithOffset; // if non-zero, offsets the control by this amount
    bool _stretchtofit; // if true, extend the width of the control to align with the furthest right control
    
    bool _bufferedmove, _bufferedresize;
    float _bufferedx{}, _bufferedy{}, _bufferedwidth{}, _bufferedheight{};
    twobyte _id{};
    __FCUserWindow *_pParent{};
 
    CONTROL_ACTIONS _controlaction;
    
    void _init()
    {
        WINCODE(_storednewfont = 0;)
        _pointsmeasurement = false;
        _programmaticallycreate = false;  /* Default to resource-loaded control. */
        _autoresizewidth = false;
        _alignwithID = 0;
        _alignwithRight = false;
        _alignwithOffset = 0.0;
        _stretchtofit = false;
        _controlaction = ACTION_NONE;
        _pParent = NULL;
        _ResetBufferedMovement();
    }
    
public:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    enum _CONTROL_TYPE
    {
        CONTROLTYPE_UNDEFINED = 0,
        CONTROLTYPE_UPDOWN,
        CONTROLTYPE_DATALIST,
        CONTROLTYPE_TREE,
        CONTROLTYPE_BUTTON,
        CONTROLTYPE_CHECKBOX,
        CONTROLTYPE_RADIOBUTTON,
        CONTROLTYPE_EDIT,
        CONTROLTYPE_STATIC,
        CONTROLTYPE_POPUP,
        CONTROLTYPE_COMBOBOX,
        CONTROLTYPE_LINE,
        CONTROLTYPE_SLIDER,
        CONTROLTYPE_LISTBOX,
        CONTROLTYPE_SWITCHER,
        CONTROLTYPE_CANVAS,
        CONTROLTYPE_IMAGE,
        CONTROLTYPE_TEXTEDITOR
    };
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
        
    const char* ClassName() const override { return "FCControl"; }
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    static int FCControl_tostring(lua_State* L)
    {
        FCControl* pThis = luabridge::Stack<FCControl*>::get(L, 1) LB3(.value());
        std::string s = std::string(pThis->ClassName()) + ": (ID " + std::to_string(pThis->GetControlID()) + ")";
        luabridge::Stack<std::string>::push(L, s).throw_on_error();
        return 1;
    }
#endif
 
        FCControl(twobyte id, const __FCControlTypedPtr &subclassPtr) : __FCBase(), _id(id), _subtypeptr(subclassPtr)
    { _init(); }
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCControl(twobyte id) : __FCBase(), _id(id), _subtypeptr(this)
    { _init(); }
#endif
 
        virtual ~FCControl()
        {
                WINCODE(DeleteObject(_storednewfont);)
        }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    template<class F, typename... Args>
    luabridge::LuaResult _LuaCallEventHandler(luabridge::LuaRef luaRef, F&& errorHandler, Args... args)
    {
        assert(luaRef.isFunction());
        return std::visit([&](auto const &ptr)
        {
            return luaRef.callWithHandler(errorHandler, ptr, args...);
        }, _subtypeptr);
    }
#endif // PDK_FRAMEWORK_LUAFRIENDLY_CPP
#endif // DOXYGEN_SHOULD_IGNORE_THIS
    
    bool GetPointsMeasurement() { return _pointsmeasurement; }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetPointsMeasurement(bool use_points) { _pointsmeasurement = use_points; }
            
    virtual _CONTROL_TYPE _GetControlType() { return CONTROLTYPE_UNDEFINED; }
 
    virtual double _GetAutoCreateWidth() { return 70; }
    
    virtual float _GetAutoCreateMultilineHeight() { return 150; }
 
    virtual bool _TextColorSet() const { return false; }
    
    bool _GetAutoResizeWidth() const { return _autoresizewidth; }
 
    std::map<int, int> _GetNoOverlapControls() const { return _nooverlapControls; }
    
    FCControl* _GetHorizontallyAlignWith() const
    {
        return (_pParent && _alignwithID) ? _pParent->FindControl(_alignwithID) : nullptr;
    }
    
    bool _GetHorizontallyAlignWithRight() const { return _alignwithRight; }
 
    double _GetAlignLeft() { return std::round(GetLeft() - _alignwithOffset); }
    
    double _GetAlignRight() { return std::round(GetLeft() + GetWidth() - _alignwithOffset); }
 
    bool _GetStretchToAlignRight() const { return _stretchtofit; }
 
#if OPERATING_SYSTEM == WINDOWS
    /* For internal use only! 
     *
     * Creates controls on Windows.
     */
    bool _WinCreateUIControl(int height_DU, LPCSTR classnameA, LPCWSTR classnameW, DWORD style, DWORD exstyle);
 
    virtual COLORREF _GetWindowsColor() const { return RGB(0, 0, 0); }
 
#ifdef PDK_FRAMEWORK_DPIAWARE
    virtual void _OnDpiChanged();
#endif // PDK_FRAMEWORK_DPIAWARE
#endif // OPERATING_SYSTEM == WINDOWS
    
    bool _CreateUIControl();
    
    virtual void _InitNonWindowHandleStates();
    
    virtual void _StoreNonWindowHandleStates();
 
         virtual void SetParent(__FCUserWindow* parentptr)
    {
       _pParent = parentptr;
    }
    
    void _SetProgrammaticallyCreate(bool state) {  _programmaticallycreate = state;  }
    
    bool _GetProgrammaticallyCreate() {  return _programmaticallycreate;  }
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
        __FCUserWindow* GetParent() const { return _pParent; }
    
    bool WindowExists() const
    {
        if (!_pParent) return false;            
#if OPERATING_SYSTEM == WINDOWS
        if (_GetWinControlHandle() == 0) return false;
#else
        if (!_GetCocoaLink()) return false;
#endif
                return _pParent->WindowExists();                
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if OPERATING_SYSTEM == MAC_OS
    /* For internal use. Gets the parent's link to the Cocoa interface. This might be NULL. */
    _FCWindowController_cocoa* _GetCocoaLink() const
    {
        return _pParent ? _pParent->_GetCocoaLink() : NULL;
    }
#else
        HWND GetWindowHandle() const { return _pParent ? _pParent->GetWindowHandle() : 0; }
#endif
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
#if OPERATING_SYSTEM == WINDOWS
        HWND _GetWinControlHandle() const
        {
                        if (!GetWindowHandle()) return 0;
            return GetDlgItem(GetWindowHandle(), GetControlID());
        }
#endif
 
        virtual void Repaint()
        {
#if OPERATING_SYSTEM == WINDOWS
            InvalidateRect(_GetWinControlHandle(), NULL, false);
#endif
        }
 
        int GetControlID() const
        {
            return _id;
        }
 
        int GetAssignedID() const { return _id; }
 
        CONTROL_ACTIONS GetAction() const { return _controlaction; }
 
        void SetAction(CONTROL_ACTIONS action) { _controlaction = action; }
 
        virtual void SetEnable(bool state);
 
        virtual bool GetEnable() const;
 
        virtual void SetVisible(bool bShow);
    
        virtual void SetBold(bool state);
    
        virtual void SetFont(const FCFontInfo *fontInfo);
    
        virtual FCFontInfo* CreateFontInfo() const;
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
        luabridge::RefCountedPtr<FCFontInfo> CreateFontInfo_GC()
        { return makeLuaSharedPtr(CreateFontInfo()); }
#endif
 
        virtual void SetKeyboardFocus();
 
#if OPERATING_SYSTEM == MAC_OS
        void SetTextAndResize(FCString* pString);
#endif
        virtual bool AssureWidthForText();
    
        void AssureNoHorizontalOverlap(const FCControl& control, int padding)
        {
            if (control.GetControlID())
                _nooverlapControls[control.GetControlID()] = padding;
        }
    
        void HorizontallyAlignLeftWith(const FCControl* pControl, double offset = 0)
        {
            _alignwithID = pControl ? pControl->GetControlID() : 0;
            _alignwithRight = false;
            _alignwithOffset = pControl ? offset : 0;
        }
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
        int HorizontallyAlignLeftWith_CFunc(lua_State *L)
        {
            const int numArgs = lua_gettop(L);
            // argument 1 is `this`
            const FCControl* pControl = luabridge::Stack<const FCControl*>::get(L, 2) LB3(.value());
            double offset = (numArgs < 3) ? 0 : luabridge::Stack<double>::get(L, 3) LB3(.value());;
            HorizontallyAlignLeftWith(pControl, offset);
            return 0;
        }
#endif
 
        void HorizontallyAlignRightWith(const FCControl* pControl, double offset = 0)
        {
            _alignwithID = pControl ? pControl->GetControlID() : 0;
            _alignwithRight = pControl ? true : false;
            _alignwithOffset = pControl ? offset : 0;
        }
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
        int HorizontallyAlignRightWith_CFunc(lua_State *L)
        {
            const int numArgs = lua_gettop(L);
            // argument 1 is `this`
            const FCControl* pControl = luabridge::Stack<const FCControl*>::get(L, 2) LB3(.value());
            double offset = (numArgs < 3) ? 0 : luabridge::Stack<double>::get(L, 3) LB3(.value());;
            HorizontallyAlignRightWith(pControl, offset);
            return 0;
        }
#endif
 
        void HorizontallyAlignRightWithFurthest(double offset = 0)
        {
            _alignwithID = 0;
            _alignwithRight = true;
            _alignwithOffset = offset;
        }
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
        static int HorizontallyAlignRightWithFurthest_CFunc(lua_State *L)
        {
            return _CFunctionOneOptionalParameter<FCControl, void, double, &FCControl::HorizontallyAlignRightWithFurthest>(L, 0);
        }
#endif
 
        void DoAutoResizeWidth(std::optional<double> minimumwidth = std::nullopt)
        {
            _autoresizewidth = true;
            if (minimumwidth.has_value())
                SetWidth(minimumwidth.value());
        }
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
        static int DoAutoResizeWidth_CFunc(lua_State *L)
        {
            return _CFunctionOneOptionalParameter<FCControl, void, std::optional<double>, &FCControl::DoAutoResizeWidth>(L, std::nullopt);
        }
#endif
 
        void StretchToAlignWithRight() { _stretchtofit = true; }
 
        virtual void SetText(const FCString* pString);
    
        virtual void GetText(FCString* pString) const;
 
        void SetLeft(float pos);
    
        float GetLeft();
 
        void SetTop(float pos);
    
        float GetTop();
        
        float GetHeight();
 
        float GetWidth();
 
        bool GetVisible();
 
        void SetWidth(float width);
    
        void SetHeight(float height);
 
        void MoveRelative(float horizmove, float vertmove);
 
        void MoveAbsolute(float x, float y);
 
        virtual void ResizeRelative(float horizresize, float vertresize);
    
        bool RedrawImmediate() const;
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        bool _HasBufferedMovement()
        {
            return (_bufferedmove || _bufferedresize);
        }
 
        void _ResetBufferedMovement()
        {
            _bufferedmove = _bufferedresize = false;
        }
 
        void _GetBufferedMovement(bool *pshouldmove, bool *pshouldresize,
                float *px, float *py, float *pwidth, float *pheight)
        {
            *pshouldmove = _bufferedmove;
            *pshouldresize = _bufferedresize;
            *px = _bufferedx;
            *py = _bufferedy;
            *pwidth = _bufferedwidth;
            *pheight = _bufferedheight;
        }
 
        void _BufferMove(float x, float y)
        {
            _bufferedmove = true;
            _bufferedx = x;
            _bufferedy = y;
        }
 
        void _BufferResize(float width, float height)
        {
            _bufferedresize = true;
            _bufferedwidth = width;
            _bufferedheight = height;
        }
 
#ifdef PDK_FRAMEWORK_DIAGNOSE
                bool _ControlExists();
 
                void _ControlClassCheck();
 
#endif // PDK_FRAMEWORK_DIAGNOSE
 
        virtual const char* _WinGetUIClassName() const = 0;
    
        virtual const char* _MacGetUIClassName() const = 0;
    
#endif // DOXYGEN_SHOULD_IGNORE_THIS
};
 
class FCCtrlEdit;
 
class FCCtrlUpDown : public FCControl
{
    struct __FCCtrlUpDown_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY<int>        steppervalue;
        _NONWINDOW_PROPERTY<int>        min;
        _NONWINDOW_PROPERTY<int>        max;
    } updown_nonwindow_store;
    
    /* For internal use only! */
    void _InitNonWindowHandleStates() override;
    
    /* For internal use only */
    void _StoreNonWindowHandleStates() override;
    
    enum {
        CONNECTED_NONE,
        CONNECTED_INT,
        CONNECTED_MEASUREMENT
    } _connectededitmode;
 
    FCCtrlEdit* _pConnectedEditControl;
    int _minInt;
    int _maxInt;
    double _minMeasurement;
    double _maxMeasurement;
    int _value;
public:
    FCCtrlUpDown(twobyte id) : FCControl(id, this)
    {
        _connectededitmode = CONNECTED_NONE;
        _pConnectedEditControl = NULL;
        _minInt = _maxInt = 0;
        _minMeasurement = _maxMeasurement = 0;
        _value = 0;
    }
 
    const char* ClassName() const override { return "FCCtrlUpDown"; }
 
      void SetValue(int value);
    
      int GetValue();
    
      void SetRange(int min, int max);
 
      int GetMinimum();
 
      int GetMaximum();
 
      FCCtrlEdit* GetConnectedEdit() { return _pConnectedEditControl; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
      _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_UPDOWN; }
    
      double _GetAutoCreateWidth() override { return WINCODE(14;) MACCODE(19;) }
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
      bool ConnectIntegerEdit(FCCtrlEdit* pControl, int min, int max)
      {
          if (!pControl) return false;
          if (max < min) return false;
          _connectededitmode = CONNECTED_INT;
          _pConnectedEditControl = pControl;
          _minInt = min;
          _maxInt = max;
#if OPERATING_SYSTEM == MAC_OS
          SetRange(min, max);
#endif
          return true;
      }
 
      bool ConnectMeasurementEdit(FCCtrlEdit* pControl, double min, double max)
      {
          if (!pControl) return false;
          if (max < min) return false;
          _connectededitmode = CONNECTED_MEASUREMENT;
          _pConnectedEditControl = pControl;
          _minMeasurement = min;
          _maxMeasurement = max;
#if OPERATING_SYSTEM == MAC_OS
          SetRange((int) min, (int) max);
#endif
          return true;
      }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
      void _HandleConnectedEditEvent(int delta);
#endif
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
          const char* _WinGetUIClassName() const override { return "msctls_updown32"; }
      const char* _MacGetUIClassName() const override { return "NSStepper"; }
#endif
};
 
class FCCtrlLine : public FCControl
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_LINE; }
    
    double _GetAutoCreateWidth() override { return 150; }
    
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
    
    bool _horizontal;  /* Only for programmatically created controls. */
    
protected:
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    FCCtrlLine(twobyte id, const __FCControlTypedPtr &subclassPtr, bool horizontal)
        : FCControl(id, subclassPtr), _horizontal(horizontal) {}
#endif
 
public:
    const char* ClassName() const override { return "FCCtrlLine"; }
 
        FCCtrlLine(twobyte id) : FCControl(id, this)
    {
        _horizontal = true;
    }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void SetEnable(bool WINCODE(state)) override
    {
#if OPERATING_SYSTEM == WINDOWS
        FCControl::SetEnable(state);
#endif
    }
    
    bool GetEnable() const override
    {
#if OPERATING_SYSTEM == WINDOWS
        return FCControl::GetEnable();
#endif
        return true;
    }
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
        bool GetHorizontal() { return _horizontal; }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        const char* _WinGetUIClassName() const override { return "Static"; }
    const char* _MacGetUIClassName() const override { return "NSBox"; }
#endif
};
 
class FCCtrlHorizontalLine : public FCCtrlLine
{
public:
    const char* ClassName() const override { return "FCCtrlHorizontalLine"; }
 
    FCCtrlHorizontalLine(twobyte id) : FCCtrlLine(id, this, true) {}
};
 
class FCCtrlVerticalLine : public FCCtrlLine
{
public:
    const char* ClassName() const override { return "FCCtrlVerticalLine"; }
 
    FCCtrlVerticalLine(twobyte id) : FCCtrlLine(id, this, false) {}
};
 
class FCCtrlStatic : public FCControl
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    _NONWINDOW_PROPERTY<int>        _textColorRed;
    _NONWINDOW_PROPERTY<int>        _textColorGreen;
    _NONWINDOW_PROPERTY<int>        _textColorBlue;
 
    _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_STATIC; }
    
    double _GetAutoCreateWidth() override { return 100; }
 
protected:
    void _InitNonWindowHandleStates() override
    {
        FCControl::_InitNonWindowHandleStates();
        if (_TextColorSet()) SetTextColor(_textColorRed.value, _textColorGreen.value, _textColorBlue.value);
    }
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
public:
       const char* ClassName() const override { return "FCCtrlStatic"; }
 
       FCCtrlStatic(twobyte id) : FCControl(id, this) {}
 
       void Clear();
 
       void SetInteger(int anint);
    
       void SetTextColor(int red, int green, int blue);
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
       bool _TextColorSet() const override { return _textColorRed.has_been_set; }
#if OPERATING_SYSTEM == WINDOWS
       COLORREF _GetWindowsColor() const override { return RGB(_textColorRed.value, _textColorGreen.value, _textColorBlue.value); }
#endif // OPERATING_SYSTEM == WINDOWS
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        const char* _WinGetUIClassName() const override { return "Static"; }
        const char* _MacGetUIClassName() const override { return "NSTextField"; }
#endif
};
 
class FCCtrlEdit : public FCControl
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_EDIT; }
    
    double _GetAutoCreateWidth() override { return 70; }
    
#if OPERATING_SYSTEM == WINDOWS
    double _CalcNonTextWidth() const override { return 4.0; }
#endif // OPERATING_SYSTEM == WINDOWS
    
#endif // #ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
protected:
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    FCCtrlEdit(twobyte id, const __FCControlTypedPtr &subclassPtr) : FCControl(id, subclassPtr) {}
#endif
 
public:
    const char* ClassName() const override { return "FCCtrlEdit"; }
 
        FCCtrlEdit(twobyte id) : FCControl(id, this) {}
    
        int GetInteger();
    
        int GetRangeInteger(int minimum, int maximum);
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void SetEnable(bool state) override
    {
#if OPERATING_SYSTEM == MAC_OS
        if (WindowExists() && !state)
        {
            // macOS does not capture edited text until you tab out of an edit field. Therefore,
            // in certain situations disabling the edit control causes the text to revert to its
            // previous contents. This fixes it. See:
            // https://stackoverflow.com/questions/2271908/nstextfield-setenabled
            FCString editText;
            GetText(&editText);
            SetText(&editText);
        }
#endif
        FCControl::SetEnable(state);
    }
#endif
 
#ifdef PDK_FRAMEWORK_PREFS
    double GetMeasurement(_ENUMCODE(MEASUREMENTUNITS) _LUACODE(twobyte) measurementunit);
    
    double GetRangeMeasurement(_ENUMCODE(MEASUREMENTUNITS) _LUACODE(twobyte)  measurementunit, double min, double max);
 
    float GetMeasurementEfix(_ENUMCODE(MEASUREMENTUNITS) _LUACODE(twobyte)  measurementunit)
    {
        /* Since this method calls GetMeasurement(), it supports controls without window handles. */
        float f = GetMeasurement(measurementunit);
        f *= 64;
        return f;
    }
 
    
    float GetRangeMeasurementEfix(_ENUMCODE(MEASUREMENTUNITS) _LUACODE(twobyte)  measurementunit, float min, float max)
    {
        /* Since this method ultimately calls GetMeasurement(), it supports controls without window handles. */
        float f = GetRangeMeasurement(measurementunit, min / 64, max / 64);
        f *= 64;
        return f;
    }
 
    void SetMeasurement(double value, _ENUMCODE(MEASUREMENTUNITS) _LUACODE(twobyte) measurementunit);
 
    void SetMeasurementEfix(float value, _ENUMCODE(MEASUREMENTUNITS) _LUACODE(twobyte) measurementunit)
    {
        value /= 64;
        SetMeasurement(value, measurementunit);
    }
 
    double GetMeasurementInteger(_ENUMCODE(MEASUREMENTUNITS) _LUACODE(twobyte) measurementunit);
    
    double GetRangeMeasurementInteger(_ENUMCODE(MEASUREMENTUNITS) _LUACODE(twobyte) measurementunit, int min, int max);
 
    void SetMeasurementInteger(double value, _ENUMCODE(MEASUREMENTUNITS) _LUACODE(twobyte) measurementunit);
#endif
 
    void SetInteger(int anint);
 
    void SetFloat(double value);
 
    double GetFloat(double min, double max);
 
    void AdjustIntegerWithin(int min, int max);
 
    [[deprecated]] void SetFocus() { SetKeyboardFocus(); }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if OPERATING_SYSTEM == WINDOWS
    void SetKeyboardFocus() override
    { FX_SetDlgFocus(GetWindowHandle(), GetControlID()); }
#endif
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
    void SelectAll();
 
    void SetMaxLength(twobyte maxlength);
 
    void SetReadOnly(bool readonly);
 
    void ScrollToBottom();
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        const char* _WinGetUIClassName() const override { return "Edit"; }
    const char* _MacGetUIClassName() const override { return "NSTextField;NSSearchField"; }
#endif
};
 
class FCCtrlPopup : public FCControl
{
    _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_POPUP; }
    
    double _GetAutoCreateWidth() override { return 100; }
    
    struct __FCCtrlPopup_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY<int>        selecteditem;
        _NONWINDOW_PROPERTY_FCSTRINGS   items;
    } popup_nonwindow_store;
    
#if OPERATING_SYSTEM == WINDOWS
    double _CalcNonTextWidth() const override;
#endif // OPERATING_SYSTEM == WINDOWS
 
    /* For internal use only! */
    void _InitNonWindowHandleStates() override;
    
    /* For internal use only */
    void _StoreNonWindowHandleStates() override;
public:
       const char* ClassName() const override { return "FCCtrlPopup"; }
 
        FCCtrlPopup(twobyte id) : FCControl(id, this) {}
    
    bool AssureWidthForText() override;
 
    void Clear();
 
    void AddString(FCString* pString);
 
        void InsertString(int index, FCString* pString);
 
    void SetStrings(FCStrings* pStrings)
    {
        Clear();
        if (!pStrings) return;
        for (int i = 0; i < pStrings->GetCount(); i++)
        {
            FCString* pString = pStrings->GetItemAt(i);
            AddString(pString);
        }
    }
 
    void DeleteItem(int index);
 
    int GetCount() const;
        
        int GetSelectedItem() const;
 
    void SetSelectedItem(int index);
    
    bool GetItemText(int index, FCString* pString);
 
        void SetItemText(int index, FCString* pString);
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        const char* _WinGetUIClassName() const override { return "ComboBox"; }
    const char* _MacGetUIClassName() const override { return "NSPopUpButton"; }
#endif
};
 
 
class FCCtrlComboBox : public FCCtrlEdit
{
    _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_COMBOBOX; }
    
    double _GetAutoCreateWidth() override { return 100; }
    
    struct __FCCtrlPopup_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY<int>        selecteditem;
        _NONWINDOW_PROPERTY_FCSTRINGS   items;
    } cbobox_nonwindow_store;
    
#if OPERATING_SYSTEM == WINDOWS
    double _CalcNonTextWidth() const override;
#endif // OPERATING_SYSTEM == WINDOWS
 
    /* For internal use only! */
    void _InitNonWindowHandleStates() override;
    
    /* For internal use only */
    void _StoreNonWindowHandleStates() override;
 
public:
    const char* ClassName() const override { return "FCCtrlComboBox"; }
    
    FCCtrlComboBox(twobyte id) : FCCtrlEdit(id, this) {}
        
    bool AssureWidthForText() override;
 
    void Clear();
    
    void AddString(FCString* pString);
    
    void SetStrings(FCStrings* pStrings)
    {
        Clear();
        if (!pStrings) return;
        for (int i = 0; i < pStrings->GetCount(); i++)
        {
            FCString* pString = pStrings->GetItemAt(i);
            AddString(pString);
        }
    }
    
    int GetCount();
    
    int GetSelectedItem();
 
    void SetSelectedItem(int index);
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    const char* _WinGetUIClassName() const override { return "ComboBox"; }
    const char* _MacGetUIClassName() const override { return "NSComboBox"; }
#endif
};
 
class FCCtrlTextEditor : public FCControl
{
    _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_TEXTEDITOR; }
    
    double _GetAutoCreateWidth() override { return 200; }
    
    float _GetAutoCreateMultilineHeight() override { return 150; }
    
    struct __FCCtrlTextEditor_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY<bool>       readonly;
        _NONWINDOW_PROPERTY<bool>       wordwrap;
        _NONWINDOW_PROPERTY<bool>       richtext;
        _NONWINDOW_PROPERTY<bool>       autoediting;
        _NONWINDOW_PROPERTY<double>     tabwidth;
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
        _NONWINDOW_PROPERTY_FCSTRING    enigmastring;
#endif
        _NONWINDOW_PROPERTY<int>        parseextag;
        _NONWINDOW_PROPERTY<double>     linespacing;
 
        __FCCtrlTextEditor_NONWINDOWSTORAGE()
        : wordwrap(true), richtext(true), autoediting(true), parseextag(tx_TextBlock) {}
    } edittext_nonwindow_store;
    
    int _tabspaces;
    bool _autoindent;
    
    /* For internal use only! */
    void _InitNonWindowHandleStates() override;
    
    /* For internal use only */
    void _StoreNonWindowHandleStates() override;
    
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
    bool _ReplaceTextInRangeWithEnigmaString(const FCString* pString, const FCRange* pRange = nullptr);
#endif
    
    bool _SetColorInRange(int red, int green, int blue, bool reset, bool background, const FCRange* pRange);
    std::tuple<int, int, int> _GetColorAtIndex(int index, bool background) const;
    FCRanges* _CreateColorChanges(bool background) const;
 
    std::unique_ptr<FCRange> _CreateAdjustedRange(const FCRange* pRange) const
    {
        std::unique_ptr<FCRange> adjustedRange = std::make_unique<FCRange>();
        GetTotalTextRange(adjustedRange.get());
        adjustedRange->SetStart((std::max)(adjustedRange->GetStart(), pRange->GetStart()));
        adjustedRange->SetLength((std::min)(adjustedRange->GetLength(), pRange->GetLength()));
        return adjustedRange;
    }
    
#if OPERATING_SYSTEM == WINDOWS
    std::pair<bool, POINT> FCCtrlTextEditor::_SetNotifySelectionChanges(bool newStatus, const std::optional<POINT> oldScrollPos = std::nullopt) const;
#endif //OPERATING_SYSTEM == WINDOWS
    
public:
    const char* ClassName() const override { return "FCCtrlTextEditor"; }
    
    FCCtrlTextEditor(twobyte id) : FCControl(id, this), _tabspaces(0), _autoindent(false)
    {
        // NSTextView has no concept of enabled, so we have to mimic it with
        // color changes. For this reason, we also have to track whether we are
        // actually disabled vs just in no-edit mode.
        // It turns out this is handy in Windows as well.
        FCControl::nonwindow_store.enabled.SetValue(true);
    }
    
    void SetParent(__FCUserWindow* parentptr) override
    {
        FCControl::SetParent(parentptr);
        WINCODE(parentptr->_LoadRichEditDll());
    }
    
    // CAUTION: STRINGFINDOPTIONS are bitwise constants. Future values should be 0x04, 0x08, 0x10, etc.
    
    enum STRINGFINDOPTIONS
    {
        STRFINDOPT_IGNORECASE = 0x01,
        
        STRFINDOPT_WHOLEWORDS = 0x02,
        
        STRFINDOPT_REGEX = 0x04
    };
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void SetFont(const FCFontInfo* fontInfo) override;
#if OPERATING_SYSTEM == WINDOWS
    FCFontInfo* CreateFontInfo() const override;
    void GetText(FCString* pText) const override;
#endif // OPERATING_SYSTEM == WINDOWS
#endif // DOXYGEN_SHOULD_IGNORE_THIS
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void SetEnable(bool state) override
    {
        FCControl::nonwindow_store.enabled.SetValue(state);
#if OPERATING_SYSTEM == WINDOWS
        if (!WindowExists()) return;
        HWND hCtrl = GetDlgItem(GetWindowHandle(), GetControlID());
        EnableWindow(hCtrl, state);
#else
        FCControl::SetEnable(state);
        if (state)
            SetReadOnly(edittext_nonwindow_store.readonly.value);
#endif
    }
    
    bool GetEnable() const override
    {
#if OPERATING_SYSTEM == WINDOWS
        if (!WindowExists()) return nonwindow_store.enabled.value;
        HWND hCtrl = GetDlgItem(GetWindowHandle(), GetControlID());
        return IsWindowEnabled(hCtrl);
#else
        return FCControl::nonwindow_store.enabled.value;
#endif
    }
#endif // DOXYGEN_SHOULD_IGNORE_THIS
    
    bool GetTotalTextRange(FCRange* pRange) const;
    
    int GetLineForPosition(int pos) const;
 
    int GetCurrentLine() const
    {
        FCRange currSel;
        GetSelection(&currSel);
        return GetLineForPosition(currSel.GetStart());
    }
    
    bool GetLineRangeForLine(int line, FCRange* pRange) const;
    
    FCRanges* CreateLineRanges(const FCRange *pRange = nullptr) const;
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    int CreateLineRanges_GC(lua_State *L)
    {
        const int numArgs = lua_gettop(L);
        // argument 1 is `this`
        const FCRange * pRange = (numArgs < 2) ? nullptr : luabridge::Stack<const FCRange *>::get(L, 2) LB3(.value());;
        luabridge::Stack<luabridge::RefCountedPtr<FCRanges>>::push(L, makeLuaSharedPtr(CreateLineRanges(pRange))) LB3(.throw_on_error());
        return 1;
    }
#endif
 
    bool GetLineRangeForPosition(int pos, FCRange* pRange) const;
 
    bool GetSelection(FCRange *pRange) const;
    
    bool SetSelection(const FCRange* pRange);
    
    bool SelectAll()
    {
        FCRange totalRange;
        if (! GetTotalTextRange(&totalRange))
            return false;
        return SetSelection(&totalRange);
    }
    
    bool GetTextInRange(FCString *pText, const FCRange* pRange) const;
    
    bool ReplaceTextInRange(const FCString *pText, const FCRange* pRange);
    
    bool ReplaceTextInRangeWithFormat(const FCString *pText, const FCEnigmaTextStyle* pStyle, const FCRange* pRange);
    
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
    bool ReplaceTextInRangeWithEnigmaString(const FCString* pString, const FCRange* pRange)
    {
        if (!pString || !pRange) return false;
        return _ReplaceTextInRangeWithEnigmaString(pString, pRange);
    }
#endif
    
    bool GetSelectedText(FCString *pText) const
    {
        FCRange range;
        if (! GetSelection(&range)) return false;
        return GetTextInRange(pText, &range);
    }
    
    bool ReplaceSelectedText(const FCString *pText)
    {
        FCRange range;
        if (! GetSelection(&range)) return false;
        return ReplaceTextInRange(pText, &range);
    }
    
    void InsertTextAtCursor(const FCString *pText);
    
    void AppendText(const FCString *pText);
    
    void AppendTextWithFormat(const FCString *pText, const FCEnigmaTextStyle* pStyle);
    
    FCString* CreateRTFString() const;
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateRTFString_GC()
    { return makeLuaSharedPtr(CreateRTFString()); }
#endif
 
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
    
    FCString* CreateEnigmaString(const FCRange* pRange = nullptr) const;
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
private:
    luabridge::RefCountedPtr<FCString>CreateEnigmaString_GC(const FCRange* pRange)
    { return makeLuaSharedPtr(CreateEnigmaString(pRange)); }
public:
    static int CreateEnigmaString_CFunc(lua_State* L)
    {
        return _CFunctionOneOptionalParameter<FCCtrlTextEditor, luabridge::RefCountedPtr<FCString>, const FCRange*, &FCCtrlTextEditor::CreateEnigmaString_GC>(L, nullptr);
    }
#endif
    
    bool SetRTFString(const FCString* pString);
    
    bool SetEnigmaString(const FCString* pString, int rawtexttype = 0)
    {
        edittext_nonwindow_store.parseextag.SetValue(FCRawText::_exTagFromRawTextType(static_cast<FCRawText::RAWTEXTTYPES>(rawtexttype)));
        return _ReplaceTextInRangeWithEnigmaString(pString);
    }
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    int SetEnigmaString_CFunc(lua_State* L)
    {
        const int numArgs = lua_gettop(L);
        // argument 1 is `this`
        const FCString * pString = luabridge::Stack<const FCString *>::get(L, 2) LB3(.value());
        const int rawtexttype = (numArgs < 3) ? 0 : luabridge::Stack<int>::get(L, 3) LB3(.value());
        luabridge::Stack<bool>::push(L, SetEnigmaString(pString, rawtexttype)) LB3(.throw_on_error());
        return 1;
    }
#endif
    
#endif // PDK_FRAMEWORK_ENIGMASTRINGS
    
    FCFontInfo* CreateFontInfoAtIndex(int index) const;
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFontInfo> CreateFontInfoAtIndex_GC(int index)
    { return makeLuaSharedPtr(CreateFontInfoAtIndex(index)); }
#endif
    
    bool SetFontInRange(const FCFontInfo* pFont, const FCRange* pRange);
    
    bool SetFontForSelection(const FCFontInfo* pFont);
    
    bool SetFontSizeInRange(int size, const FCRange* pRange);
    
    bool SetFontSizeForSelection(int size);
    
    bool SetFontBoldInRange(bool state, const FCRange* pRange);
    
    bool SetFontBoldForSelection(bool state);
    
    bool SetFontItalicInRange(bool state, const FCRange* pRange);
    
    bool SetFontItalicForSelection(bool state);
    
    void SetReadOnly(bool readonly);
    
    bool GetReadOnly() const;
    
    void SetWordWrap(bool wordwrap);
    
    bool GetWordWrap() const { return edittext_nonwindow_store.wordwrap.value; }
    
    void SetUseRichText(bool state);
    
    bool GetUseRichText() const;
    
    void SetAutomaticEditing(bool state);
    
    bool GetAutomaticEditing() const { return edittext_nonwindow_store.autoediting.value; }
    
    void SetTabstopWidth(double value);
    
    int GetConvertTabsToSpaces() const { return _tabspaces; }
    
    void SetConvertTabsToSpaces(int value) { _tabspaces = value; }
    
    bool GetAutomaticallyIndent() const { return _autoindent; }
 
    void SetAutomaticallyIndent(bool state) { _autoindent = state; }
 
 
    FCRanges* CreateRangesForString(const FCString* pSearchString, FLAG_32 options, const FCRange* pRange = nullptr) const;
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    int CreateRangesForString_CFunc(lua_State *L) const
    {
        const int numArgs = lua_gettop(L);
        // argument 1 is `this`
        const FCString * pString = luabridge::Stack<const FCString *>::get(L, 2) LB3(.value());
        const FLAG_32 options = luabridge::Stack<FLAG_32>::get(L, 3) LB3(.value());
        const FCRange * pRange = (numArgs < 4) ? nullptr : luabridge::Stack<const FCRange *>::get(L, 4) LB3(.value());;
        luabridge::Stack<luabridge::RefCountedPtr<FCRanges>>::push(L, makeLuaSharedPtr(CreateRangesForString(pString, options, pRange))) LB3(.throw_on_error());
        return 1;
    }
#endif
    
    void ResetUndoState();
    
    bool SetTextColorInRange(int red, int green, int blue, const FCRange* pRange)
    {
        return _SetColorInRange(red, green, blue, false, false, pRange);
    }
    
    bool SetBackgroundColorInRange(int red, int green, int blue, const FCRange* pRange)
    {
        return _SetColorInRange(red, green, blue, false, true, pRange);
    }
 
    bool ResetTextColorInRange(const FCRange* pRange)
    {
        return _SetColorInRange(0, 0, 0, true, false, pRange);
    }
    
    bool ResetBackgroundColorInRange(const FCRange* pRange)
    {
        return _SetColorInRange(0, 0, 0, true, true, pRange);
    }
 
    bool ResetColors()
    {
        FCRange range;
        GetTotalTextRange(&range);
        bool retval = true;
        if (!ResetTextColorInRange(&range)) retval = false;
        if (!ResetBackgroundColorInRange(&range)) retval = false;
        return retval;
    }
 
    std::tuple<int, int, int> GetTextColorAtIndex(int index) const
    {
        return _GetColorAtIndex(index, false);
    }
 
    std::tuple<int, int, int> GetBackgroundColorAtIndex(int index) const
    {
        return _GetColorAtIndex(index, true);
    }
 
    FCRanges* CreateTextColorChanges() const
    {
        return _CreateColorChanges(false);
    }
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCRanges> CreateTextColorChanges_GC() const
    { return makeLuaSharedPtr(CreateTextColorChanges()); }
#endif
 
    FCRanges* CreateBackgroundColorChanges() const
    {
        return _CreateColorChanges(true);
    }
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCRanges> CreateBackgroundColorChanges_GC() const
    { return makeLuaSharedPtr(CreateBackgroundColorChanges()); }
#endif
 
    int GetNumberOfLines() const;
    
    double GetVerticalScrollPosition() const;
 
    void ScrollToTop();
    
    void ScrollToBottom();
    
    void ScrollToVerticalPosition(double vpos);
    
    void ScrollLineIntoView(int line);
    
    double GetLineSpacing() const;
 
    void SetLineSpacing(double value);
 
    FCString* CreateCharacterAtIndex(int pos) const;
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateCharacterAtIndex_GC(int pos)
    { return makeLuaSharedPtr(CreateCharacterAtIndex(pos)); }
#endif
 
    bool TextToClipboard() const;
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    const char* _WinGetUIClassName() const override { return "RICHEDIT50W"; }
    const char* _MacGetUIClassName() const override { return "NSTextView"; }
#endif
};
 
class FCCtrlDataList;
 
class FCDataListRow : public FCStrings
{
    bool _checked;
    int _connectedlineindex;
    FCCtrlDataList* _connectedlist;
public:
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _MakeConnection(FCCtrlDataList* pCtrl, int lineindex);
 
    void _SetCheckState(bool state) { _checked = state; }
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCDataListRow() : FCStrings()
    {
        _checked = false;
        _connectedlineindex = -1;
        _connectedlist = NULL;
    }
    const char* ClassName() const override { return "FCDataListRow"; }
 
    void SetCheck(bool state);
 
    bool GetCheck() const { return _checked; }
 
    int GetConnectedLineIndex() { return _connectedlineindex; }
 
    FCCtrlDataList* GetConnectedList() { return _connectedlist; }
};
 
class FCCtrlDataList : public FCControl
{
        bool _usecheckboxes;    // Used for programmatically-created dialog boxes only.
    bool _showheader;       // not meaningful for macOS FCCtrlListBox (which inherits from this class)
    bool _expandlast;       // not meaningful for macOS FCCtrlListBox (which inherits from this class)
    bool _multiselect;      // not meaningful for macOS FCCtrlListBox (which inherits from this class)
#if OPERATING_SYSTEM == MAC_OS
    int _fontsize;
#endif
    
    class __FCDataList_NONWINDOWSELECTION
    {
        _NONWINDOW_PROPERTY<int>    focusindex;
        std::set<int>               selectedindices;
    public:
        __FCDataList_NONWINDOWSELECTION()
        {
            focusindex.value = -1; // avoid setting has_been_set
        }
        bool has_been_set() const { return focusindex.has_been_set; }
        int get_focus_index() const { return focusindex.value; }
        void select_line(int index)
        {
            if (index < 0) return;
            selectedindices.insert(index);
            focusindex.SetValue(index);
        }
        void select_line_exclusive(int index)
        {
            selectedindices.clear();
            select_line(index);
        }
        void unselect_line(int index)
        {
            if (index < 0) return;
            selectedindices.erase(index);
            if (!is_line_selected(get_focus_index()))
            {
                if (selectedindices.size() <= 0)
                    focusindex.SetValue(-1);
                else
                    focusindex.SetValue(*selectedindices.begin());
            }
        }
        void unselect_all()
        {
            selectedindices.clear();
            focusindex.SetValue(-1);
        }
        bool is_line_selected(int index) const
        {
            return selectedindices.find(index) != selectedindices.end();
        }
    } datalist_nonwindow_selection;
 
    struct __FCDataList_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY_FCSTRINGS   columntexts;
        _NONWINDOW_PROPERTY_FCNUMBERS   columnwidths;
        _NONWINDOW_PROPERTY<bool>       usealternatingrows;
    } datalist_nonwindow_store;
    
    __FCCollection _rows;  /* The collection of pointer references to the
                            * rows, so they can be deleted when the lines
                            * are deleted. */
 
    /* For internal use only! */
    void _InitNonWindowHandleStates() override;
    
    /* For internal use only */
    void _StoreNonWindowHandleStates() override;
    
    /* Builds the list */
    void _BuildList();
    
    /* initializer called in ctors */
    void _init()
    {
        _usecheckboxes = false;
        _showheader = true;
        _expandlast = false;
        _multiselect = false;
#if OPERATING_SYSTEM == MAC_OS
        _fontsize = 12;
#endif
    }
    
protected:
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    // FCCtrlListBox inherits FCCtrlDataList on Mac (not on Windows), but it does not call
    // base class versions of _InitNonWindowHandleStates or _SaveNonWindowHandleStates.
    // These functions are used to process the values that need to be processed for
    // both this class and any subclasses it may have.
    void _DataListInitNonWindowHandleStates();
    void _DataListStoreNonWindowHandleStates();
#endif
    
public:
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_DATALIST; }
    
    double _GetAutoCreateWidth() override { return 200; }
    
    float _GetAutoCreateMultilineHeight() override { return 150; }
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
    const char* ClassName() const override { return "FCCtrlDataList"; }
 
    FCCtrlDataList(twobyte id) : FCControl(id, this)
    { _init(); }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if OPERATING_SYSTEM == MAC_OS
    FCCtrlDataList(twobyte id, const __FCControlTypedPtr &subclassPtr) : FCControl(id, subclassPtr)
    { _init(); }
#endif
#endif
    
    virtual ~FCCtrlDataList()
    {
        //_rows.ClearAll();
    }
 
    void SetFontSize(int fontsize)
    {
#if OPERATING_SYSTEM == MAC_OS
        _fontsize = fontsize;
#endif
    }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    const eUniChar16* _GetCellUnicodeText(FCDataListRow* pRow, int columnindex);
 
    const char* _GetCellCText(FCDataListRow* pRow, int columnindex);
#endif  /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
    void SetColumnTitle(int columnindex, FCString* pTitle);
    
    bool AddColumn(FCString* pTitle, float columnwidth);
    
    int AddRow(FCDataListRow* pRow);
    
    bool InsertRowAt(FCDataListRow* pRow, int);
 
    FCDataListRow* CreateRow();
    
    bool DeleteRow(int lineindex);
    
    void DeleteAll();
 
    void DeleteAllColumns();
 
    bool GetUseCheckboxes() const { return _usecheckboxes; }
    
    void SetUseCheckboxes(bool state) { _usecheckboxes = state; }
    
    bool UseLeftCheckboxColumn();
 
    bool GetAllowsMultipleSelection() const { return _multiselect; }
    
    void SetAllowsMultipleSelection(bool state) { _multiselect = state; }
 
    bool GetShowHeader() const { return _showheader; }
    
    void SetShowHeader(bool state) { _showheader = state; }
 
    void UseGrid();
 
    void UseFullRowSelect();
 
    bool GetAlternatingBackgroundRowColors() const;
 
    void SetAlternatingBackgroundRowColors(bool state);
 
    [[deprecated]] void UseAlternatingBackgroundRowColors() { SetAlternatingBackgroundRowColors(true); }
 
    int GetCount();
 
    FCDataListRow* GetItemAt(int lineindex);
 
    void Redraw();
 
    bool SelectLine(int lineindex, bool ensurevisible = false);
 
    bool AddSelectedLine(int lineindex, bool ensurevisible = false);
 
    bool IsLineSelected(int lineindex);
    
    bool UnselectLine(int lineindex);
    
    bool UnselectAll();
 
    void ScrollToTop();
 
    bool GetExpandLastColumn() const { return _expandlast; }
    
    void SetExpandLastColumn(bool state) { _expandlast = state; }
 
    void ExpandLastColumn();
 
    int GetSelectedLine();
 
    virtual void HandleSelectChange(int lineindex);
 
    virtual void HandleUnselect();
 
    virtual void HandleCheckChange(int lineindex, bool state)
    {
        FCDataListRow* pRow = GetItemAt(lineindex);
        if (!pRow) return;
        pRow->_SetCheckState(state);
        GetParent()->HandleDataListCheck(this, lineindex, state);
    }
 
    virtual void HandleDoubleClick() { GetParent()->HandleListDoubleClick(this); }
 
    void ReconnectAll();
 
    bool HasCheckboxes();
 
    int GetDetailedColumnCount(bool includecheckboxcolumn);
 
    int GetColumnCount() { return GetDetailedColumnCount(false); }
 
    float GetColumnWidth(int columnindex);
 
    bool Swap(int rowindex1, int rowindex2, bool redraw);
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    const char* _WinGetUIClassName() const override { return "SysListView32"; }
    const char* _MacGetUIClassName() const override { return "NSTableView"; }
#endif
};
 
#if OPERATING_SYSTEM == WINDOWS
class FCCtrlListBox : public FCControl
#else
class FCCtrlListBox : public FCCtrlDataList
#endif
{
public:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_LISTBOX; }
    
    double _GetAutoCreateWidth() override { return 150; }
    
    float _GetAutoCreateMultilineHeight() override { return 170; }
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
private:
    
    struct __FCCtrlListBox_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY<int>        selecteditem;
        _NONWINDOW_PROPERTY_FCSTRINGS   items;
    } listbox_nonwindow_store;
    
    /* For internal use only! */
    void _InitNonWindowHandleStates() override;
    
    /* For internal use only */
    void _StoreNonWindowHandleStates() override;
    
#if OPERATING_SYSTEM == MAC_OS
        void _MacSetupListboxColumn();
#endif
public:
    const char* ClassName() const override { return "FCCtrlListBox"; }
 
        FCCtrlListBox(twobyte id);
 
    void Clear();
 
    void AddString(FCString* pString);
 
    int GetSelectedItem();
 
    int GetCount();
 
    void SetSelectedItem(int index);
 
    bool SetSelectedLast()
    {
        /* Both GetCount() and SetSelectedItem() has non-window support. */
        int count = GetCount();
        if (count < 1) return false;
        SetSelectedItem(count - 1);
        return true;
    }
    
    void ClearSelection();
 
    void SetItemText(int index, FCString* pString);
 
    void GetItemText(int index, FCString* pString);
 
    void DeleteItem(int index);
 
    void InsertItem(int index, FCString* pString);
 
    void SetStrings(FCStrings* pStrings);
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    const char* _WinGetUIClassName() const override { return "ListBox"; }
#if OPERATING_SYSTEM == WINDOWS
    // the mac side picks up _MacGetUIClassName from FCCtrlDataList, but
    // we need a definition here for Windows to satisfy the virtual pure function.
    const char* _MacGetUIClassName() const override { return "NSTableView"; }
#endif
#endif
};
 
 
class FCCtrlTree;
 
class FCTreeNode : public __FCCollection
{
 
#if OPERATING_SYSTEM == WINDOWS
    /* Windows - a tree view item handle */
    HANDLE
#else
    /* Cocoa - a NSValue that contains a pointer to the FCTreeNode */
    void*
#endif
        _itemhandle;
 
                bool _isselected;
        bool _iscontainer;
        bool _expanded;
        FCString _thetext;
        FCCtrlTree* _pTreeControl;
        FCTreeNode* _pParentNode;
 
        void UpdateText();
    public:
        FCTreeNode(FCString* pText);
 
        virtual ~FCTreeNode();
 
        const char* ClassName() const override { return "FCTreeNode"; }
 
        FCTreeNode* GetItemAt(int index) const { return (FCTreeNode*) __FCCollection::GetItemAt(index); }
    
        void SetText(FCString* pText) {
            if (pText)
                _thetext.SetString(pText);
            else
                _thetext.Clear();
 
            UpdateText();
        }
 
        void GetText(FCString* pString) const
        {
                        if (!pString) return;
            pString->SetString(&_thetext);
        }
 
                FCString* GetTextPtr()
                {                       
                        return &_thetext;
                }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        void _SetIsContainer(bool state) { _iscontainer = state; }
    
        void _SetExpanded(bool state) { _expanded = state; }
    
        bool _GetExpanded() { return _expanded; }
#endif
 
        bool GetIsContainer() const { return _iscontainer; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        void _SetTreeControl(FCCtrlTree* pTree) { _pTreeControl = pTree; }
 
        FCCtrlTree* _GetTreeControl() { return _pTreeControl; }
 
        void _SetParentNode(FCTreeNode* pNode) { _pParentNode = pNode; }
 
                /* Only used when creating a tree view programmatically before the window displays... */
                void _SetSelected(bool selected) { _isselected = selected; }
 
                /* Only used when creating a tree view programmatically before the window displays... */
                bool _GetSelected() { return _isselected; }
#endif
 
        FCTreeNode* GetParentNode() { return _pParentNode; }
    
        int GetIndex()
        {
            if (!_pParentNode) return -1;
            return _pParentNode->GetIndexOf(this);
        }
    
        int GetSiblingCount()
        {
            if (!_pParentNode) return 0;
            return _pParentNode->GetCount();
        }
 
#if OPERATING_SYSTEM == WINDOWS
    /* Windows - a tree view item handle */
    HANDLE
#else
    /* Cocoa - a NSValue that contains a pointer to the FCTreeNode */
    void*
#endif
        _GetItemHandle() { return _itemhandle; }
 
        void _SetItemHandle(
#if OPERATING_SYSTEM == WINDOWS
                            /* Windows - a tree view item handle */
                            HANDLE
#else
                            /* Cocoa */
                            void*
#endif
                            item);
 
#ifdef PDK_FRAMEWORK_DEBUG
        void DebugDump() override
        {
            DebugOutBool("Is Container: ", _iscontainer);
                        FCString astring;
                        GetText(&astring);
            DebugOutString("Text: ", &astring);
        }
 
#endif
};
 
 
class FCCtrlTree : public FCControl
{
        /*
        IMPLEMENTATION INFO:
        Since the tree is mirrored in internal data already, there's no need to use additional storage for
        programmatically created controls. Instead, the existing data structure is used.
        */
 
 
#if OPERATING_SYSTEM == MAC_OS
        void _MacSetupTreeColumn();
    int _fontsize;
#endif
 
       FCTreeNode* _pRootNode;
 
       FCTreeNode* _MapItem(WINCODE(HANDLE) MACCODE(FCTreeNode*) htreeitem,
                                        FCTreeNode *pBaseNode = NULL);
 
       void _DeleteAllSubNodes(FCTreeNode* pBaseNode);            
    public:
 
    /* Windows constructor */
        FCCtrlTree(twobyte id) : FCControl(id, this)
    {
#if OPERATING_SYSTEM == MAC_OS
        _fontsize = 12;
#endif
        _pRootNode = new FCTreeNode(NULL);
    }
    
    virtual ~FCCtrlTree()
    {
        _DeleteAllSubNodes(_pRootNode);        
        delete _pRootNode;        
    }
    const char* ClassName() const override { return "FCCtrlTree"; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_TREE; }
    
    double _GetAutoCreateWidth() override { return 150; }
    
    float _GetAutoCreateMultilineHeight() override { return 170; }
 
        /* For internal use only! */
        void _InitNonWindowHandleStates() override;
 
        /* For internal use only */
        void _StoreNonWindowHandleStates() override;
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
                void _BuildTree();
 
                void _MarkSelectedNode(FCTreeNode* pNode);
#endif
 
                FCTreeNode* AddNode(FCTreeNode *pParentNode, bool isContainer, FCString* pText);
    
        FCTreeNode* InsertNodeAt(FCTreeNode *pParentNode, FCString* pText, int index);
 
        bool DeleteNode(FCTreeNode *pNode);
 
        bool SwapNodes(FCTreeNode* pNode1, FCTreeNode* pNode2);
 
        void ExpandNode(FCTreeNode *pNode);
 
        void CollapseNode(FCTreeNode *pNode);
 
        bool IsNodeAttached(FCTreeNode *pNode2Find, FCTreeNode *pBaseNode);
 
        FCTreeNode* FindUserDataNode(void* userdata, FCTreeNode *pBaseNode);
 
        FCTreeNode* GetSelectedNode();
 
        int CalcRootIndex(FCTreeNode* pNode);
 
        int CalcNodeIndex(FCTreeNode* pNode, FCTreeNode* pParentNode);
    
        void SetFontSize(int size)
        {
#if OPERATING_SYSTEM == MAC_OS
            _fontsize = size;
#endif            
        }
 
        bool SetSelectedNode(FCTreeNode* pNode);
 
        void Clear();
 
        void ExpandAllContainers();
    
        void CollapseAllContainers();
 
        int GetRootCount() { return _pRootNode->GetCount(); }
 
        FCTreeNode* GetRootItemAt(int index)
        {
            return (FCTreeNode*) _pRootNode->GetItemAt(index);
        }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
                FCTreeNode* _GetRootNode()
                {
                        return _pRootNode;
                }
#endif
 
        int GetRootIndexOf(FCTreeNode* pNode)
        {
            return _pRootNode->GetIndexOf(pNode);
        }
    
        void Repaint() override;
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
                const char* _WinGetUIClassName() const override { return "SysTreeView32"; }
                const char* _MacGetUIClassName() const override { return "NSOutlineView"; }
#endif
};
 
class FCCtrlSwitcher : public FCControl
{
    __FCCollection _pagecontrolids;  /* Collection of FCNumbers objects.
                                      The number of collections should be identical
                                      to the number of pages. */
    
    struct __FCCtrlSwitcher_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY<int>        selectedindex;
        _NONWINDOW_PROPERTY_FCSTRINGS   items;
    } switcher_nonwindow_store;
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    double _GetAutoCreateWidth() override { return 200; }
    
        /* For internal use only! */
        void _InitNonWindowHandleStates() override;
    
        /* For internal use only */
        void _StoreNonWindowHandleStates() override;
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
    
        bool _FindControlIDReference(int theid);
public:
    FCCtrlSwitcher(twobyte id) : FCControl(id, this) {}
        
    const char* ClassName() const override { return "FCCtrlSwitcher"; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_SWITCHER; }
#endif
    
    void AddPage(FCString* pString);
 
    bool AttachControl(FCControl* pControl, int pageindex);
 
    void HandleVisibleStates(int index);
 
    int GetPageCount();
 
    int GetSelectedPage();
 
    void SetSelectedPage(int index);
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    const char* _WinGetUIClassName() const override { return "SysTabControl32"; }
    const char* _MacGetUIClassName() const override { return "NSSegmentedControl"; }
#endif
};
 
//---------------------------------------------------------------------------
 
class FCCtrlRadioButtonGroup;
 
class FCCtrlRadioButton : public FCControl
{
    struct __FCCtrlRadioButton_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY<bool>           checkstate;
    } radiobutton_nonwindow_store;
    
    FCCtrlRadioButtonGroup* _pButtonGroup;
    int _buttonindex; // -1 means this control is not part of a FCCtrlRadioButtonGroup.
    
        _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_RADIOBUTTON; }
 
    double _GetAutoCreateWidth() override { return 100; }
    
#if OPERATING_SYSTEM == WINDOWS
    double _CalcNonTextWidth() const override
    { return _CalcNonTextWidthFromTheme(BP_RADIOBUTTON, RBS_UNCHECKEDNORMAL, 3.0, 16.0); }
#endif // OPERATING_SYSTEM == WINDOWS
 
    /* For internal use only! */
    void _InitNonWindowHandleStates() override;
    
    /* For internal use only */
    void _StoreNonWindowHandleStates() override;
public:
    
    FCCtrlRadioButton(twobyte id, FCCtrlRadioButtonGroup* pButtonGroup, int buttonIndex)
            : FCControl(id, this), _pButtonGroup(pButtonGroup), _buttonindex(buttonIndex)
    {
        assert(!pButtonGroup || buttonIndex >= 0);
    }
    
    FCCtrlRadioButton(twobyte id)
            : FCControl(id, this), _pButtonGroup(nullptr), _buttonindex(-1)
    {}
 
    const char* ClassName() const override { return "FCCtrlRadioButton"; }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    int _GetButtonIndex() const { return _buttonindex; }
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
    void SetCheck(bool checked);
 
    bool GetCheck();
    
    FCCtrlRadioButtonGroup * GetRadioButtonGroup() const { return _pButtonGroup; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        const char* _WinGetUIClassName() const override { return "Button"; }
    const char* _MacGetUIClassName() const override { return "NSButton"; }
#endif
};
 
class FCCtrlRadioButtonGroup : public __FCBase
{
    __FCCollection _buttons; // can't inherit __FCCollection due to LuaBridge issues with keeping it private.
    int _groupid;
    
public:
        FCCtrlRadioButtonGroup(int groupID) : __FCBase(), _buttons(), _groupid(groupID) {}
    
    ~FCCtrlRadioButtonGroup()
    {
        // The dialog box owns the buttons, so it will delete them. We just have copies.
        _buttons.DetachAll();
    }
 
    const char* ClassName() const override { return "FCCtrlRadioButtonGroup"; }
    
    int GetGroupID() const { return _groupid; }
    
    int GetCount() const { return _buttons.GetCount(); }
 
    void Add(FCCtrlRadioButton* button) { _buttons.Add(button); }
    
    FCCtrlRadioButton* GetItemAt(int index) const { return (FCCtrlRadioButton*) _buttons.GetItemAt(index); }
 
    void SetText(FCStrings* pStrings);
    
    void SetWidth(float width)
    {
        for (int index = 0; index < GetCount(); index++)
            GetItemAt(index)->SetWidth(width);
        
    }
    
    FCCtrlRadioButton* GetSelectedButton()
    {
        for (int index = 0; index < GetCount(); index++)
        {
            FCCtrlRadioButton* pButton = GetItemAt(index);
            if (pButton->GetCheck()) return pButton;
        }
        return nullptr;
    }
 
    int GetSelectedItem()
    {
        for (int index = 0; index < GetCount(); index++)
            if (GetItemAt(index)->GetCheck()) return index;
        return -1;
    }
 
    void SetSelectedItem(int index)
    {
        if (index < 0 || index >= GetCount()) return;
        for (int next = 0; next < GetCount(); next++)
            GetItemAt(next)->SetCheck(next == index);
    }
 
    void MoveAllRelative(float horizoffset, float vertoffset)
    {
        for (int index = 0; index < GetCount(); index++)
            GetItemAt(index)->MoveRelative(horizoffset, vertoffset);
    }
};
 
class FCCtrlCheckbox : public FCControl
{
    struct __FCCtrlCheckbox_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY<int>        checkstate;
        _NONWINDOW_PROPERTY<bool>       threestate;
    } checkbox_nonwindow_store;
    
    _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_CHECKBOX; }
    
    double _GetAutoCreateWidth() override { return 100; }
    
#if OPERATING_SYSTEM == WINDOWS
    double _CalcNonTextWidth() const override
    { return _CalcNonTextWidthFromTheme(BP_CHECKBOX, CBS_UNCHECKEDNORMAL, 3.0, 16.0); }
#endif // OPERATING_SYSTEM == WINDOWS
 
    /* For internal use only! */
    void _InitNonWindowHandleStates() override;
    
    /* For internal use only */
    void _StoreNonWindowHandleStates() override;
public:
        FCCtrlCheckbox(twobyte id) : FCControl(id, this) {}
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    FCCtrlCheckbox(twobyte id, const __FCControlTypedPtr &subclassPtr) : FCControl(id, subclassPtr) {}
#endif
    
    const char* ClassName() const override { return "FCCtrlCheckbox"; }
 
    virtual void SetCheck(twobyte checked);
 
    virtual twobyte GetCheck();
    
    void SetThreeStatesMode(bool allow3states)
    {
        checkbox_nonwindow_store.threestate.value = allow3states;
    }
    
    bool GetThreeStatesMode() const
    {
        return checkbox_nonwindow_store.threestate.value;
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        const char* _WinGetUIClassName() const override { return "Button"; }
    const char* _MacGetUIClassName() const override { return "NSButton"; }
#endif
};
 
class FCCtrlButton : public FCCtrlCheckbox
{
    WINCODE(HFONT _storednewfont{};)
    
    _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_BUTTON; }
    
    double _GetAutoCreateWidth() override { return 60; }
    
#if OPERATING_SYSTEM == MAC_OS
    double _originalheight{};
#endif
    
#if OPERATING_SYSTEM == WINDOWS
    double _CalcNonTextWidth() const override { return 24.0; }
#endif // OPERATING_SYSTEM == WINDOWS
 
public:
    FCCtrlButton(twobyte id) : FCCtrlCheckbox(id, this) {}
    
    /* Destructor */
    virtual ~FCCtrlButton();
    
    const char* ClassName() const override { return "FCCtrlButton"; }
    
    void ClearShortcutKey();
    
    void SetFontSize(int fontsize);
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if OPERATING_SYSTEM == MAC_OS
    double _GetOriginalHeight() const { return _originalheight; }
    void _SetOriginalHeight(double value) { _originalheight = value; }
#endif
#endif
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        const char* _WinGetUIClassName() const override { return "Button"; }
    const char* _MacGetUIClassName() const override { return "NSButton"; }
#endif
};
 
 
class FCCtrlSlider : public FCControl
{
    _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_SLIDER; }
    
    double _GetAutoCreateWidth() override { return 150; }
    
    struct __FCCtrlSlider_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY<int>         minvalue;
        _NONWINDOW_PROPERTY<int>         maxvalue;
        _NONWINDOW_PROPERTY<int>         thumbpos;
    } slider_nonwindow_store;
 
#if OPERATING_SYSTEM == WINDOWS
    bool trackingStarted;
#endif
    
    /* For internal use only! */
    void _InitNonWindowHandleStates() override;
    
    /* For internal use only */
    void _StoreNonWindowHandleStates() override;
public:
        FCCtrlSlider(twobyte id) : FCControl(id, this)
    {
#if OPERATING_SYSTEM == WINDOWS
        trackingStarted = false;
#endif
    }
 
    const char* ClassName() const override { return "FCCtrlSlider"; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if OPERATING_SYSTEM == WINDOWS
    bool _GetTrackingStartedWin() const { return trackingStarted; }
    void _SetTrackingStartedWin(bool state) { trackingStarted = state; }
#endif // OPERATING_SYSTEM == WINDOWS
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
    int GetMinValue();
    
        void SetMinValue(int min);
 
        int GetMaxValue();
    
        void SetMaxValue(int max);
 
        void SetThumbPosition(int position);
 
        int GetThumbPosition(); 
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        const char* _WinGetUIClassName() const override { return "msctls_trackbar32"; }
    const char* _MacGetUIClassName() const override { return "NSSlider"; }
#endif
};
 
#ifdef PDK_FRAMEWORK_IMAGECTRL
class FCCtrlImage : public FCControl
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if OPERATING_SYSTEM == WINDOWS
    HBITMAP _image;
#endif
#if OPERATING_SYSTEM == MAC_OS
    void * _image; //NSImage in Objective-C
#endif
 
    _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_IMAGE; }
    
    double _GetAutoCreateWidth() override { return 100; }
    
    void _ReleaseImage()
    {
#if OPERATING_SYSTEM == WINDOWS
        DeleteObject(_image);
#else
        _cocoalink_ReleaseImage(_image);
#endif
        _image = 0;
    }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
public:
    enum IMAGESOURCE
    {
        FCCTRLIMAGE_FILEPATH,
        FCCTRLIMAGE_BITMAP
    };
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
private:
    void _AttachAssignedImageToControl();
    
    bool _SetImage(IMAGESOURCE source, const char *data, long dataLength, bool preserveControlSize);
 
protected:
    void _InitNonWindowHandleStates() override
    {
        FCControl::_InitNonWindowHandleStates();
        // this must come after FCControl::_InitNonWindowHandleStates() so that GetTop, GetWidth, GetHeight work correctly.
        _AttachAssignedImageToControl();
    }
 
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCCtrlImage"; }
 
    FCCtrlImage(twobyte id) : FCControl(id, this), _image(0) {}
    ~FCCtrlImage() { _ReleaseImage(); }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if OPERATING_SYSTEM == WINDOWS
#ifdef PDK_FRAMEWORK_DPIAWARE
    void _OnDpiChanged() override;
#endif // PDK_FRAMEWORK_DPIAWARE
#endif // OPERATING_SYSTEM == WINDOWS
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
    bool SetImageFromFilePath(const char *path, bool preserveControlSize = false)
    { return _SetImage(FCCTRLIMAGE_FILEPATH, path, 0, preserveControlSize); }
    
    bool SetImageFromBuffer(const onebyte *data, long dataLength, bool preserveControlSize = false)
    { return _SetImage(FCCTRLIMAGE_BITMAP, data, dataLength, preserveControlSize); }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    const char* _WinGetUIClassName() const override { return "Static"; }
    const char* _MacGetUIClassName() const override { return "NSImageView"; }
#endif
};
#endif // PDK_FRAMEWORK_IMAGECTRL
 
#ifdef PDK_FRAMEWORK_CANVASCTRL
class FCCtrlCanvas : public FCControl
{
    struct __FCCtrlSlider_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY<void*>         instructions;
    } canvas_nonwindow_store;
 
    _CONTROL_TYPE _GetControlType() override { return CONTROLTYPE_CANVAS; }
    
    double _GetAutoCreateWidth() override { return 80; }
    
    float _GetAutoCreateMultilineHeight() override { return 80; }
    
    /* For internal use only! */
    void _InitNonWindowHandleStates() override;
    
    /* For internal use only */
    void _StoreNonWindowHandleStates() override;
public:
    FCCtrlCanvas(twobyte id) : FCControl(id, this) {}
    
    void RebuildInstructions(FCVirtualCanvasInstructions* pInstructions);
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    const char* _WinGetUIClassName() const override { return "Static"; }
    const char* _MacGetUIClassName() const override { return "NSFCCtrlCanvas"; }
#endif
 
};
#endif /* #ifdef PDK_FRAMEWORK_CANVASCTRL */
 
class FCResourceWindow : public __FCUserWindow {
        int _resourceid;
#if OPERATING_SYSTEM == WINDOWS
        FF_DialogHandlerUPP _handler;
#endif
        __FCUserWindow* _pParent;
 
public:
    
    enum EXECMODAL_RETURNS {
        EXECMODAL_CLOSE = 0,
        
        EXECMODAL_OK = 1,
        
        EXECMODAL_CANCEL = 2
    };
    
    FCResourceWindow(int resid);
    
    virtual ~FCResourceWindow();
 
    const char* ClassName() const override { return "FCResourceWindow"; }
 
    void DestroyWindow();
 
    void InitWindow() override;
    
    void CloseWindow() override;
 
    __FCUserWindow* GetParent() { return _pParent; }
 
    void ShowModeless(EWND WINCODE(hParent));
    
    void ShowModeless(__FCUserWindow* pParent);
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    EXECMODAL_RETURNS
#else
    twobyte
#endif
        ExecuteModal_EWND(EWND hParent);
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    EXECMODAL_RETURNS
#else
    virtual twobyte
#endif
    ExecuteModal(__FCUserWindow *pParent = nullptr);
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    int ExecuteModal_CFunc(lua_State *L);
#endif // DOXYGEN_SHOULD_IGNORE_THIS
#endif // PDK_FRAMEWORK_LUAFRIENDLY
    
#if OPERATING_SYSTEM == WINDOWS
    virtual bool HandleWMNotify(WPARAM wparam, LPARAM lparam);
#endif
 
 
    void _SetupInternalWindowCode();
 
#ifdef PDK_FRAMEWORK_DPIAWARE
    bool GetWantsDpiAwareness() const
    {
       return WINCODE(_wants_dpi_awareness) MACCODE(false);
    }
 
    void SetWantsDpiAwareness(bool WINCODE(state))
    {
#if OPERATING_SYSTEM == WINDOWS
       if (!WindowExists()) _wants_dpi_awareness = state;
#endif // OPERATING_SYSTEM == WINDOWS
    }
#endif // PDK_FRAMEWORK_DPIAWARE
 
    FCControl* AddCtrl(FCControl* pControl)
    {
                Add(pControl);   // Add must be before SetParent (for the Mac)
        pControl->SetParent(this);
        return pControl;
    }
 
    FCCtrlLine* AddLine(twobyte id) {
        return (FCCtrlLine*) AddCtrl(new FCCtrlLine(id));
    }
 
    FCCtrlStatic* AddStatic(twobyte id)
    {
        return (FCCtrlStatic*) AddCtrl(new FCCtrlStatic(id));
    }
 
#ifdef PDK_FRAMEWORK_IMAGECTRL
    FCCtrlImage* AddImage(twobyte id)
    {
        return (FCCtrlImage*) AddCtrl(new FCCtrlImage(id));
    }
#endif
    
    FCCtrlComboBox* AddComboBox(twobyte id)
    {
        return (FCCtrlComboBox*) AddCtrl(new FCCtrlComboBox(id));
    }
 
    FCCtrlEdit* AddEdit(twobyte id) {
        return (FCCtrlEdit*) AddCtrl(new FCCtrlEdit(id));
    }
 
    FCCtrlTextEditor* AddTextEditor(twobyte id) {
        return (FCCtrlTextEditor*) AddCtrl(new FCCtrlTextEditor(id));
    }
 
    FCCtrlPopup* AddPopup(twobyte id) {
        return (FCCtrlPopup*) AddCtrl(new FCCtrlPopup(id));
    }
 
    FCCtrlListBox* AddListBox(twobyte id) {
        return (FCCtrlListBox*) AddCtrl(new FCCtrlListBox(id));
    }
 
    FCCtrlButton* AddButton(twobyte id) {
        return (FCCtrlButton*) AddCtrl(new FCCtrlButton(id));
    }
 
        FCCtrlSlider* AddSlider(twobyte id) {
                return (FCCtrlSlider*)AddCtrl(new FCCtrlSlider(id));
        }
 
    FCCtrlRadioButton* AddRadioButton(twobyte id) {
        return (FCCtrlRadioButton*) AddCtrl(new FCCtrlRadioButton(id));
    }
 
    FCCtrlCheckbox* AddCheckbox(twobyte id) {
        return (FCCtrlCheckbox*) AddCtrl(new FCCtrlCheckbox(id));
    }
 
    FCCtrlUpDown* AddUpDown(twobyte id) {
        return (FCCtrlUpDown*) AddCtrl(new FCCtrlUpDown(id));
    }
 
    FCCtrlDataList* AddDataList(twobyte id)
    {
        return (FCCtrlDataList*) AddCtrl(new FCCtrlDataList(id));
    }
 
    FCCtrlTree* AddTree(twobyte id)
    {
        return (FCCtrlTree*) AddCtrl(new FCCtrlTree(id));
    }
};
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#define __IDRESOURCE_CUSTOMWINDOW 5001
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
 
class FCCustomWindow : public FCResourceWindow
{
    bool _okbuttoncanclose;
    bool _okbuttoninprogress;
    
    std::vector<FCCtrlRadioButtonGroup*> _radioButtonGroups;
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool CanClose() override { return (_okbuttoncanclose || !_okbuttoninprogress) && FCResourceWindow::CanClose(); }
#endif
    
    FCControl* _AddCreatedCtrl_NoPos(FCControl* pControl)
    {
        if (!pControl) return pControl;
        Add(pControl);   // Add must be before SetParent (for the Mac)
        pControl->_SetPointsMeasurement(true);
        pControl->SetParent(this);
        pControl->_SetProgrammaticallyCreate(true);
        return pControl;
    }
    
    
    void _MoveAllControls(int horizoffset, int vertoffset);
    
    void _CalcControlsExtent(float *pLeftMin, float* pTopMin, float* pRightMax, float* pBottomMax);
    
    void _InitNonWindowHandleStates() override;
public:
    FCCustomWindow() : FCResourceWindow(__IDRESOURCE_CUSTOMWINDOW), _okbuttoncanclose(true), _okbuttoninprogress(false)
    {
        _SetPointsMeasurement(true);
    }
    ~FCCustomWindow()
    {
        for (FCCtrlRadioButtonGroup * group : _radioButtonGroups)
            delete group;
        _radioButtonGroups.clear();
    }
 
    const char* ClassName() const override { return "FCCustomWindow"; }
 
    int _CalcAvailableCtrlID()
    {
        int tryid = 10001;
        for (int i = 0; i < GetCount(); i++)
        {
            FCControl* pControl = GetItemAt(i);
            int testid = pControl->GetControlID();
            if ((testid >= tryid) && (testid < 20000))
            {
                tryid = testid + 1;
            }
        }
        return tryid;
    }
    
    FCControl* _AddCreatedCtrl(FCControl* pControl, float x, float y)
    {
        if (!pControl) return pControl;
        Add(pControl);   // Add must be before SetParent (for the Mac)
        pControl->_SetPointsMeasurement(true);
        pControl->SetParent(this);
        pControl->_SetProgrammaticallyCreate(true);
        pControl->SetLeft(x);
        pControl->SetTop(y);
        return pControl;
    }
    
    void SetOkButtonCanClose(bool value) {_okbuttoncanclose = value;}
    
    bool GetOkButtonCanClose() const {return _okbuttoncanclose;}
 
    void OkButtonPressed() override
    {
        _okbuttoninprogress = true;
        FCResourceWindow::OkButtonPressed();
        _okbuttoninprogress = false;
    }
 
    FCCtrlStatic* CreateStatic(float x, float y) { return (FCCtrlStatic*) _AddCreatedCtrl(new FCCtrlStatic(_CalcAvailableCtrlID()), x, y); }
 
#ifdef PDK_FRAMEWORK_IMAGECTRL
    FCCtrlImage* CreateImage(float x, float y)
    {
#ifdef PDK_FRAMEWORK_DPIAWARE
        SetWantsDpiAwareness(true);
#endif
        return (FCCtrlImage*) _AddCreatedCtrl(new FCCtrlImage(_CalcAvailableCtrlID()), x, y);
    }
#endif
    
    FCCtrlEdit* CreateEdit(float x, float y) { return (FCCtrlEdit*) _AddCreatedCtrl(new FCCtrlEdit(_CalcAvailableCtrlID()), x, y); }
    
    FCCtrlTextEditor* CreateTextEditor(float x, float y) { return (FCCtrlTextEditor*) _AddCreatedCtrl(new FCCtrlTextEditor(_CalcAvailableCtrlID()), x, y); }
 
    FCCtrlComboBox* CreateComboBox(float x, float y) { return (FCCtrlComboBox*) _AddCreatedCtrl(new FCCtrlComboBox(_CalcAvailableCtrlID()), x, y); }
 
    FCCtrlButton* CreateButton(float x, float y) { return (FCCtrlButton*) _AddCreatedCtrl(new FCCtrlButton(_CalcAvailableCtrlID()), x, y); }
 
    FCCtrlCheckbox* CreateCheckbox(float x, float y) { return (FCCtrlCheckbox*) _AddCreatedCtrl(new FCCtrlCheckbox(_CalcAvailableCtrlID()), x, y); }
    
 
        FCCtrlRadioButton* CreateRadioButton(float x, float y) { return (FCCtrlRadioButton*)_AddCreatedCtrl(new FCCtrlRadioButton(_CalcAvailableCtrlID()), x, y); }
 
 
    FCCtrlButton* CreateOkButton()
    {
        if (FindControl(1)) return NULL;
        FCCtrlButton* pOkButton = (FCCtrlButton*) _AddCreatedCtrl_NoPos(new FCCtrlButton(1));
        pOkButton->SetAction(FCControl::ACTION_OK);
        FCString oktext("OK");
        pOkButton->SetText(&oktext);
        return pOkButton;
    }
    
    FCCtrlButton* CreateCancelButton()
    {
        if (FindControl(2)) return NULL;
        FCCtrlButton* pCancelButton = (FCCtrlButton*) _AddCreatedCtrl_NoPos(new FCCtrlButton(2));
        pCancelButton->SetAction(FCControl::ACTION_CANCEL);
        FCString canceltext("Cancel");
        pCancelButton->SetText(&canceltext);
        return pCancelButton;
    }
    
    FCCtrlButton* CreateCloseButton(float x, float y)
    {
        FCCtrlButton* pCloseButton =  (FCCtrlButton*) _AddCreatedCtrl(new FCCtrlButton(_CalcAvailableCtrlID()), x, y);
        pCloseButton->SetAction(FCControl::ACTION_CLOSE);
        FCString closetext("Close");
        pCloseButton->SetText(&closetext);
        return pCloseButton;
    }
 
    FCCtrlPopup* CreatePopup(float x, float y) { return (FCCtrlPopup*) _AddCreatedCtrl(new FCCtrlPopup(_CalcAvailableCtrlID()), x, y); }
    
    FCCtrlHorizontalLine* CreateHorizontalLine(float x, float y, float width)
    {
        FCCtrlHorizontalLine* pLine = (FCCtrlHorizontalLine*) _AddCreatedCtrl(new FCCtrlHorizontalLine(_CalcAvailableCtrlID()), x, y);
        pLine->SetWidth(width);
        return pLine;
    }
    
    FCCtrlVerticalLine* CreateVerticalLine(float x, float y, float height)
    {
        FCCtrlVerticalLine* pLine = (FCCtrlVerticalLine*) _AddCreatedCtrl(new FCCtrlVerticalLine(_CalcAvailableCtrlID()), x, y);
        pLine->SetHeight(height);
        return pLine;
    }
    
    FCCtrlSlider* CreateSlider(float x, float y) { return (FCCtrlSlider*) _AddCreatedCtrl(new FCCtrlSlider(_CalcAvailableCtrlID()), x, y); }
 
    FCCtrlListBox* CreateListBox(float x, float y) { return (FCCtrlListBox*) _AddCreatedCtrl(new FCCtrlListBox(_CalcAvailableCtrlID()), x, y); }
 
    FCCtrlUpDown* CreateUpDown(float x, float y) { return (FCCtrlUpDown*) _AddCreatedCtrl(new FCCtrlUpDown(_CalcAvailableCtrlID()), x, y); }
 
    FCCtrlRadioButtonGroup* CreateRadioButtonGroup(float x, float y, int no_of_items)
    {
        if (no_of_items < 1) return NULL;
        if (no_of_items > 20) return NULL;
        const size_t index = _radioButtonGroups.size();
        _radioButtonGroups.emplace_back(new FCCtrlRadioButtonGroup(static_cast<int>(index)+1)); //group ids start with 1
        static const float kYSeparation = 16; // This default is empirically determined to be about the same on Win and macOS.
        for (int next = 0; next < no_of_items; next++)
        {
            FCCtrlRadioButton* button = new FCCtrlRadioButton(_CalcAvailableCtrlID(), _radioButtonGroups[index], next);
            _AddCreatedCtrl(button, x, y + next*kYSeparation);
            _radioButtonGroups[index]->Add(button);
        }
        if (_radioButtonGroups[index]->GetCount() > 0)
            _radioButtonGroups[index]->SetSelectedItem(0);
        return _radioButtonGroups[index];
    }
    
    FCCtrlTree* CreateTree(float x, float y) { return (FCCtrlTree*) _AddCreatedCtrl(new FCCtrlTree(_CalcAvailableCtrlID()), x, y); }
    
    FCCtrlSwitcher* CreateSwitcher(float x, float y) { return (FCCtrlSwitcher*) _AddCreatedCtrl(new FCCtrlSwitcher(_CalcAvailableCtrlID()), x, y); }
    
#ifdef PDK_FRAMEWORK_CANVASCTRL
    FCCtrlCanvas* CreateCanvas(float x, float y) { return (FCCtrlCanvas*) _AddCreatedCtrl(new FCCtrlCanvas(_CalcAvailableCtrlID()), x, y); }
#endif
    
    FCCtrlDataList* CreateDataList(float x, float y) { return (FCCtrlDataList*) _AddCreatedCtrl(new FCCtrlDataList(_CalcAvailableCtrlID()), x, y); }
    
    void MoveAllControls(int horizoffset, int vertoffset)
    { _MoveAllControls(horizoffset, vertoffset); }
 
};
 
#endif  /* #ifdef PDK_FRAMEWORK_DIALOGS */
 
#endif  /* FF_DIALOGS_H */