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 "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_FILEDIALOGS

/* 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;
    }

    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;
public:
    FCFileOpenDialog(FCUI* pUI) : __FCFileDialogBase(pUI)
    {
        _multiselect = false;
    }

    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);
    }
    
    virtual bool Execute();
};

class FCFileSaveAsDialog : public __FCFileDialogBase
{
public:
    FCFileSaveAsDialog(FCUI* pUI) : __FCFileDialogBase(pUI)
    {
    }

    virtual bool Execute();
};

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;
public:
    FCFolderBrowseDialog(FCUI* pUI)
    {
        _pUI = pUI;
        _usefinaleapi = true;
    }

    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();
};

#endif   /* #ifdef PDK_FRAMEWORK_FILEDIALOGS */


#ifdef PDK_FRAMEWORK_DIALOGS

/* Some forward class declarations */
class FCControl;
class FCCtrlDataList;
class FCCtrlSwitcher;

#ifndef DOXYGEN_SHOULD_IGNORE_THIS


struct _NONWINDOW_PROPERTY_VOIDPTR
{
    void* pValue;
    bool has_been_set;
    
    _NONWINDOW_PROPERTY_VOIDPTR()
    {
        pValue = NULL;
        has_been_set = false;
    }
    
    void SetValue(void* pNewValue) {
        pValue = pNewValue;
        has_been_set = true;
    }
};

struct _NONWINDOW_PROPERTY_FCSTRING
{
    FCString value;
    bool has_been_set;
    
    _NONWINDOW_PROPERTY_FCSTRING()
    {
        value.Clear();
        has_been_set = false;
    }
    
    void SetValue(FCString* pNewString) {
        value.SetString(pNewString);
        has_been_set = true;
    }
    
    void SetIntegerValue(int anint) {
        value.SetInteger(anint);
        has_been_set = true;
    }
    
    void SetMeasurementValue(double measurement, twobyte measurementunit) {
        value.SetMeasurement(measurement, measurementunit);
        has_been_set = true;
    }
};

struct _NONWINDOW_PROPERTY_FCSTRINGS
{
    FCStrings value;
    bool has_been_set;
    
    _NONWINDOW_PROPERTY_FCSTRINGS()
    {
        value.ClearAll();
        has_been_set = false;
    }
    
    void AppendString(FCString* pString)
    {
        value.AddCopy(pString);
        has_been_set = true;
    }
    
    void ClearAll()
    {
        value.ClearAll();
        has_been_set = true;
    }
};

struct _NONWINDOW_PROPERTY_FCNUMBERS
{
    FCNumbers value;
    bool has_been_set;
    
    _NONWINDOW_PROPERTY_FCNUMBERS()
    {
        value.ClearAll();
        has_been_set = false;
    }
    
    void AppendInt(int anint)
    {
        value.AddInt(anint);
        has_been_set = true;
    }
    
    void AppendFloat(float afloat)
    {
        value.AddFloat(afloat);
        has_been_set = true;
    }
    
    void ClearAll()
    {
        value.ClearAll();
        has_been_set = true;
    }
};

struct _NONWINDOW_PROPERTY_BOOL
{
    bool value;
    bool has_been_set;
    
    _NONWINDOW_PROPERTY_BOOL()
    {
        value = false;
        has_been_set = false;
    }
    
    void SetValue(bool newvalue) {
        value = newvalue;
        has_been_set = true;
    }
};

struct _NONWINDOW_PROPERTY_INT
{
    int value;
    bool has_been_set;
    
    _NONWINDOW_PROPERTY_INT()
    {
        value = 0;
        has_been_set = false;
    }
    
    void SetValue(int newvalue) {
        value = newvalue;
        has_been_set = true;
    }
};

struct _NONWINDOW_PROPERTY_FLOAT
{
    float value;
    bool has_been_set;
    
    _NONWINDOW_PROPERTY_FLOAT()
    {
        value = 0.0f;
        has_been_set = false;
    }
    
    void SetValue(float newvalue) {
        value = newvalue;
        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;
    
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if OPERATING_SYSTEM == WINDOWS
        /* Conversion routines between pixels and points. These can't be private, since they
        need to be accessible for FCCustomWindow as well. */

        float _WinHorizPixelsToPoints(float value);

        float _WinVertPixelsToPoints(float value);

        float _WinHorizPointsToPixels(float value);

        float _WinVertPointsToPixels(float value);
#endif
    
    /* Storage for the variables that will be available when the window handle isn't: */
    __FCUserWindow_NONWINDOWSTORAGE nonwindow_store;
#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. */
#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;
    bool _restorepositioncalled;
#endif
    
#if PDK_FRAMEWORK_DIAGNOSE

        void _CheckControls();
#endif

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:
    void _SetLastCommandModifierKeys(FLAG_32 value) { _lastcommandmodifierkeys = value; }
    
    enum COMMAND_MOD_KEYS
    {
        CMDMODKEY_SHIFT = 0x00000001,
        
        CMDMODKEY_ALT = 0x00000002,
        
        CMDMODKEY_CTRL = 0x00000004,
        
        CMDMODKEY_COMMAND = 0x00000008,
        
        CMDMODKEY_FUNCTION = 0x00000008
    };
    
    
    __FCUserWindow() : __FCCollection()
    {
        _lastcommandmodifierkeys = 0x0;
        _pointsmeasurement = false;
#if OPERATING_SYSTEM == MAC_OS
        _pCocoaLink = NULL;
#else
        _hwnd = 0;
#endif
        _ismodal = false;
        _modalresult = 0;
        _closewindowcalled = false;
        _maximumresizewidth = _minimumresizewidth =
                _maximumresizeheight = _minimumresizeheight =
                _oldresizewidth = _oldresizeheight = 0;
        _positionstored = _sizestored = false;
        _isinwindowshademode = false;
        _nonwindowshadeheight = 0;
        WINCODE(_initwindowcalled = false;)
        WINCODE(_restorepositioncalled = false;)
        _bufferedcontrolmovement = false;
    }

    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);
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */

    void SetEnabled(bool state);
    
    FCControl* GetItemAt(int index) { return (FCControl*) __FCCollection::GetItemAt(index); }

#if OPERATING_SYSTEM == WINDOWS

    void _SetModelessEnabledState();
#endif

    void SetWidth(float newwidth);
    
    float GetWidth();
    
    void SetHeight(float newheight);
    
    float GetHeight();
    
    void SetClientWidth(float newwidth);
    
    float GetClientWidth();
    
    void SetClientHeight(float newheight);
    
    float GetClientHeight();
    
    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()
    {
        return _pCocoaLink;
    }
    
#else

    void _SetWindowHandle(EWND hwnd) {
        _hwnd = hwnd;
    }

    EWND GetWindowHandle() { 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();

    void Hide();

    void ShowAndActivate();

    virtual void InitWindow();

    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(FCControl* pControl) { return false; }

    virtual void HandleSwitcherSelect(FCCtrlSwitcher* pControl, int switchindex);
    
    virtual void HandleUpDownPressed(FCControl* pControl, int delta) {}

        virtual void HandleDataListSelect(FCCtrlDataList* pControl, int lineindex) {}

        virtual void HandleDataListCheck(FCCtrlDataList* pControl, int lineindex, bool checkstate) {}

    virtual void HandleTimer(twobyte timerID) {}

    virtual void HandleActivate(bool activated) {}

    virtual void HandleResize(int newwidth, int newheight, int oldwidth, int oldheight) {}

    FCControl* FindControl(int controlid);

    void SetTimer(twobyte timerID, ufourbyte msInterval);
    
    void StopTimer(twobyte timerID);

    void Activate();
    
    virtual bool CanClose() { return true; }

    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();

    float GetStoredY();

    float GetStoredWidth();

    float GetStoredHeight();

    bool IsWindowshade() { return _isinwindowshademode; }

    void Windowshade(bool windowshade);
    
    void SetWindowAlpha(twobyte alphapercent);

    void StartBufferControlMovement();

    bool EndBufferControlMovement();

    bool IsInBufferMode() { return _bufferedcontrolmovement; }

#if OPERATING_SYSTEM == WINDOWS

    void _WinSetInitWindowCalled(bool value)
    {
        _initwindowcalled = value;
    }

    void _WinSetRestorePositionCalled(bool value)
    {
        _restorepositioncalled = value;
    }

    void _WinPostRestorePosition()
    {
        if (!_initwindowcalled) return;
        if (!_restorepositioncalled) return;
        RestorePosition();
    }
#endif
};

#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;
};
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */


class FCControl : public __FCBase
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if OPERATING_SYSTEM == WINDOWS
        HFONT _storednewfont;  /* If the control has a custom font */

        float _WinHorizPixelsToPoints(float value);

        float _WinVertPixelsToPoints(float value);

        float _WinHorizPointsToPixels(float value);

        float _WinVertPointsToPixels(float value);
#endif
#endif
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;
#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 _bufferedmove, _bufferedresize;
    float _bufferedx, _bufferedy, _bufferedwidth, _bufferedheight;
        twobyte _id;
    __FCUserWindow *_pParent;

    CONTROL_ACTIONS _controlaction;
    
public:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    enum _CONTROL_TYPE
    {
        CONTROLTYPE_UNDEFINED,
        CONTROLTYPE_UPDOWN,
        CONTROLTYPE_DATALIST,
        CONTROLTYPE_TREE,
        CONTROLTYPE_BUTTON,
        CONTROLTYPE_CHECKBOX,
        CONTROLTYPE_EDIT,
        CONTROLTYPE_STATIC,
        CONTROLTYPE_POPUP,
        CONTROLTYPE_COMBOBOX,
        CONTROLTYPE_LINE,
        CONTROLTYPE_SLIDER,
        CONTROLTYPE_LISTBOX,
        CONTROLTYPE_RADIOBUTTONGROUP,
        CONTROLTYPE_SWITCHER,
        CONTROLTYPE_CANVAS
    };
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
        
    virtual const char* ClassName() { return "FCControl"; }

        FCControl(twobyte id) : __FCBase()
        {
                        WINCODE(_storednewfont = 0;)

            _pointsmeasurement = false;
            _programmaticallycreate = false;  /* Default toe resource-loaded control. */
            _id = id;
            _controlaction = ACTION_NONE;
            _pParent = NULL;
            _ResetBufferedMovement();
        }

        virtual ~FCControl()
        {
                WINCODE(DeleteObject(_storednewfont);)
        }
    
    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 float _GetAutoCreateWidth() { return 70; }
    
    virtual float _GetAutoCreateMultilineHeight() { return 150; }

#if OPERATING_SYSTEM == WINDOWS
    /* For internal use only! 
     *
     * Creates controls on Windows.
     */
    bool _WinCreateUIControl(int height_DU, LPCSTR classnameA, LPWSTR classnameW, DWORD style, DWORD exstyle);
#endif
    
    bool _CreateUIControl();
    
    virtual void _InitNonWindowHandleStates();
    
    virtual void _StoreNonWindowHandleStates();

        void SetParent(__FCUserWindow* parentptr)
        {
            _pParent = parentptr;
        }
    
    void _SetProgrammaticallyCreate(bool state) {  _programmaticallycreate = state;  }
    
    bool _GetProgrammaticallyCreate() {  return _programmaticallycreate;  }
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */

        __FCUserWindow* GetParent() { return _pParent; }
    
    bool WindowExists()
    {
        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()
    {
        return _pParent ? _pParent->_GetCocoaLink() : NULL;
    }
#else

        HWND GetWindowHandle() { return _pParent ? _pParent->GetWindowHandle() : 0; }
#endif
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */

#if OPERATING_SYSTEM == WINDOWS

        HWND _GetWinControlHandle()
        {
                        if (!GetWindowHandle()) return 0;
            return GetDlgItem(GetWindowHandle(), GetControlID());
        }
#endif

        virtual void Repaint()
        {
#if OPERATING_SYSTEM == WINDOWS
            InvalidateRect(_GetWinControlHandle(), NULL, false);
#endif
        }

        int GetControlID()
        {
            return _id;
        }

        int GetAssignedID() { return _id; }

        CONTROL_ACTIONS GetAction() { return _controlaction; }

        void SetAction(CONTROL_ACTIONS action) { _controlaction = action; }

        virtual void SetEnable(bool state);

        virtual bool GetEnable();

        virtual void SetVisible(bool bShow);
    
        virtual void SetBold(bool state);

        virtual void SetKeyboardFocus();

#if OPERATING_SYSTEM == MAC_OS

        void SetTextAndResize(FCString* pString);
#endif
    
        virtual void SetText(FCString* pString);
    
        virtual void GetText(FCString* pString);

        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);

#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();

                virtual const char* _WinGetUIClassName() { return "Undefined"; }
    
         virtual const char* _MacGetUIClassName() { return "Undefined"; }

#endif  /* PDK_FRAMEWORK_DIAGNOSE */
    
#endif /* #ifndef 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! */
    virtual void _InitNonWindowHandleStates();
    
    /* For internal use only */
    virtual void _StoreNonWindowHandleStates();
    
    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)
    {
        _connectededitmode = CONNECTED_NONE;
        _pConnectedEditControl = NULL;
        _minInt = _maxInt = 0;
        _minMeasurement = _maxMeasurement = 0;
        _value = 0;
    }

      virtual const char* ClassName() { 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
      virtual _CONTROL_TYPE _GetControlType() { return CONTROLTYPE_UPDOWN; }
    
      virtual float _GetAutoCreateWidth() { 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

#ifdef PDK_FRAMEWORK_DIAGNOSE
          virtual const char* _WinGetUIClassName() { return "msctls_updown32"; }    
      virtual const char* _MacGetUIClassName() { return "NSStepper"; }
#endif
};

class FCCtrlLine : public FCControl
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    virtual _CONTROL_TYPE _GetControlType() { return CONTROLTYPE_LINE; }
    
    virtual float _GetAutoCreateWidth() { return 150; }
    
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
    
    bool _horizontal;  /* Only for programmatically created controls. */
public:
    virtual const char* ClassName() { return "FCCtrlLine"; }

        FCCtrlLine(twobyte id) : FCControl(id)
    {
        _horizontal = true;
    }
    
    virtual void SetEnable(bool state)
    {
#if OPERATING_SYSTEM == WINDOWS
        FCControl::SetEnable(state);
#endif
    }
    
    virtual bool GetEnable()
    {
#if OPERATING_SYSTEM == WINDOWS
        return FCControl::GetEnable();
#endif
        return true;
    }
    
    void SetHorizontal(bool horiz) { _horizontal = horiz; }

        bool GetHorizontal() { return _horizontal; }
    
#ifdef PDK_FRAMEWORK_DIAGNOSE
        virtual const char* _WinGetUIClassName() { return "Static"; }
    virtual const char* _MacGetUIClassName() { return "NSBox"; }
#endif
};

class FCCtrlStatic : public FCControl
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    virtual _CONTROL_TYPE _GetControlType() { return CONTROLTYPE_STATIC; }
    
    virtual float _GetAutoCreateWidth() { return 100; }
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
public:
       virtual const char* ClassName() { return "FCCtrlStatic"; }

       FCCtrlStatic(twobyte id) : FCControl(id) {}

       void Clear();

       void SetInteger(int anint);

#ifdef PDK_FRAMEWORK_DIAGNOSE
           virtual const char* _WinGetUIClassName() { return "Static"; }
       virtual const char* _MacGetUIClassName() { return "NSTextField"; }
#endif
};

class FCCtrlEdit : public FCControl
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    virtual _CONTROL_TYPE _GetControlType() { return CONTROLTYPE_EDIT; }
    
    virtual float _GetAutoCreateWidth() { return 70; }
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
public:
        virtual const char* ClassName() { return "FCCtrlEdit"; }

        FCCtrlEdit(twobyte id) : FCControl(id) {
        }

        int GetInteger();
    
        int GetRangeInteger(int minimum, int maximum);

#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(float value);

        float GetFloat(float min, float max);

        void AdjustIntegerWithin(int min, int max);

        void SetFocus();

        void SelectAll();

        void SetMaxLength(twobyte maxlength);

        void SetReadOnly(bool readonly);

    void ScrollToBottom();

#ifdef PDK_FRAMEWORK_DIAGNOSE
        virtual const char* _WinGetUIClassName() { return "Edit"; }
    virtual const char* _MacGetUIClassName() { return "NSTextField;NSSearchField"; }
#endif
};

class FCCtrlPopup : public FCControl
{
    virtual _CONTROL_TYPE _GetControlType() { return CONTROLTYPE_POPUP; }
    
    virtual float _GetAutoCreateWidth() { return 100; }
    
    struct __FCCtrlPopup_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY_INT         selecteditem;
        _NONWINDOW_PROPERTY_FCSTRINGS   items;
    } popup_nonwindow_store;
    
    /* For internal use only! */
    virtual void _InitNonWindowHandleStates();
    
    /* For internal use only */
    virtual void _StoreNonWindowHandleStates();
public:
       virtual const char* ClassName() { return "FCCtrlPopup"; }

        FCCtrlPopup(twobyte id) : FCControl(id) {}

    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();
        
        int GetSelectedItem();

    void SetSelectedItem(int index);

        void SetItemText(int index, FCString* pString);

#ifdef PDK_FRAMEWORK_DIAGNOSE
        virtual const char* _WinGetUIClassName() { return "ComboBox"; }
    virtual const char* _MacGetUIClassName() { return "NSPopUpButton"; }
#endif
};


class FCCtrlComboBox : public FCCtrlEdit
{
    virtual _CONTROL_TYPE _GetControlType() { return CONTROLTYPE_COMBOBOX; }
public:
    virtual const char* ClassName() { return "FCCtrlComboBox"; }
    
    FCCtrlComboBox(twobyte id) : FCCtrlEdit(id) {}
    
    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();
    
#ifdef PDK_FRAMEWORK_DIAGNOSE
    virtual const char* _WinGetUIClassName() { return "ComboBox"; }
    virtual const char* _MacGetUIClassName() { return "NSComboBox"; }
#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;
    }

    void SetCheck(bool state);

    bool GetCheck() { return _checked; }

    int GetConnectedLineIndex() { return _connectedlineindex; }

    FCCtrlDataList* GetConnectedList() { return _connectedlist; }
};

class FCCtrlDataList : public FCControl
{
        bool _usecheckboxes;  /* Used for programmatically-created dialog boxes only. */
        
    struct __FCDataList_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY_FCSTRINGS   columntexts;
        _NONWINDOW_PROPERTY_FCNUMBERS   columnwidths;
                _NONWINDOW_PROPERTY_INT                 selectedindex;
    } 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! */
    virtual void _InitNonWindowHandleStates();
    
    /* For internal use only */
    virtual void _StoreNonWindowHandleStates();
    
    /* Builds the list */
    void _BuildList();
public:

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

#if OPERATING_SYSTEM == MAC_OS
    int _fontsize;
#endif

    virtual _CONTROL_TYPE _GetControlType() { return CONTROLTYPE_DATALIST; }
    
    virtual float _GetAutoCreateWidth() { return 200; }
    
    virtual float _GetAutoCreateMultilineHeight() { return 150; }
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */

    virtual const char* ClassName() { return "FCCtrlDataList"; }

        FCCtrlDataList(twobyte id) : FCControl(id)
    {
          _usecheckboxes = false;
                  datalist_nonwindow_store.selectedindex.value = -1;
#if OPERATING_SYSTEM == MAC_OS
        _fontsize = 12;
#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();

        void UseGrid();

        void UseFullRowSelect();

        int GetCount();

        FCDataListRow* GetItemAt(int lineindex);

        void Redraw();

        bool SelectLine(int lineindex, bool ensurevisible);

        void ScrollToTop();
    
        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);
        }

        virtual void HandleDoubleClick() {}

        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);

#ifdef PDK_FRAMEWORK_DIAGNOSE
    virtual const char* _WinGetUIClassName() { return "SysListView32"; }
    virtual const char* _MacGetUIClassName() { return "NSTableView"; }
#endif
};

#if OPERATING_SYSTEM == WINDOWS
class FCCtrlListBox : public FCControl
#else
class FCCtrlListBox : public FCCtrlDataList
#endif
{
public:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    virtual _CONTROL_TYPE _GetControlType() { return CONTROLTYPE_LISTBOX; }
    
    virtual float _GetAutoCreateWidth() { return 150; }
    
    virtual float _GetAutoCreateMultilineHeight() { 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! */
    virtual void _InitNonWindowHandleStates();
    
    /* For internal use only */
    virtual void _StoreNonWindowHandleStates();
    
#if OPERATING_SYSTEM == MAC_OS
        void _MacSetupListboxColumn();
#endif
public:
    virtual const char* ClassName() { 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);

#ifdef PDK_FRAMEWORK_DIAGNOSE
    virtual const char* _WinGetUIClassName() { return "ListBox"; }
#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();

        FCTreeNode* GetItemAt(int index) { return (FCTreeNode*) __FCCollection::GetItemAt(index); }
    
        void SetText(FCString* pText) {
            if (pText)
                _thetext.SetString(pText);
            else
                _thetext.Clear();

            UpdateText();
        }

        void GetText(FCString* pString)
        {
                        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() { 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
        virtual void DebugDump()
        {
            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)
        {
#if OPERATING_SYSTEM == MAC_OS
            _fontsize = 12;
#endif
            _pRootNode = new FCTreeNode(NULL);
        }
    
    virtual ~FCCtrlTree()
    {
        _DeleteAllSubNodes(_pRootNode);        
        delete _pRootNode;        
    }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    virtual _CONTROL_TYPE _GetControlType() { return CONTROLTYPE_TREE; }
    
    virtual float _GetAutoCreateWidth() { return 150; }
    
    virtual float _GetAutoCreateMultilineHeight() { return 170; }

        /* For internal use only! */
        virtual void _InitNonWindowHandleStates();

        /* For internal use only */
        virtual void _StoreNonWindowHandleStates();
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */

        virtual const char* ClassName() { return "FCCtrlTree"; }

#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);
        }
    
        virtual void Repaint();
    
#ifdef PDK_FRAMEWORK_DIAGNOSE
                virtual const char* _WinGetUIClassName() { return "SysTreeView32"; }
                virtual const char* _MacGetUIClassName() { 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
    virtual float _GetAutoCreateWidth() { return 200; }
    
        /* For internal use only! */
        virtual void _InitNonWindowHandleStates();
    
        /* For internal use only */
        virtual void _StoreNonWindowHandleStates();
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
    
        bool _FindControlIDReference(int theid);
    public:
        FCCtrlSwitcher(twobyte id) : FCControl(id) {}

#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual _CONTROL_TYPE _GetControlType() { return CONTROLTYPE_SWITCHER; }
#endif
    
        void AddPage(FCString* pString);

        bool AttachControl(FCControl* pControl, int index);
    
        void HandleVisibleStates(int index);

        int GetPageCount();

        int GetSelectedPage();

        void SetSelectedPage(int index);

#ifdef PDK_FRAMEWORK_DIAGNOSE
                virtual const char* _WinGetUIClassName() { return "SysTabControl32"; }
                virtual const char* _MacGetUIClassName() { return "NSSegmentedControl"; }
#endif
};

//---------------------------------------------------------------------------

class FCCtrlRadioButton : public FCControl
{
    struct __FCCtrlCheckbox_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY_BOOL         checkstate;
    } radiobutton_nonwindow_store;
    
    virtual float _GetAutoCreateWidth() { return 100; }

    /* For internal use only! */
    virtual void _InitNonWindowHandleStates();
    
    /* For internal use only */
    virtual void _StoreNonWindowHandleStates();
public:
    
    FCCtrlRadioButton(twobyte id) : FCControl(id) {}

    void SetCheck(bool checked);

    bool GetCheck();

#ifdef PDK_FRAMEWORK_DIAGNOSE
        virtual const char* _WinGetUIClassName() { return "Button"; }
    virtual const char* _MacGetUIClassName() { return "NSButton"; }
#endif
};

class FCCtrlRadioButtonGroup : public FCControl
{
    virtual _CONTROL_TYPE _GetControlType() { return CONTROLTYPE_RADIOBUTTONGROUP; }
public:
        FCCtrlRadioButtonGroup(twobyte id, int no_of_items) : FCControl(id)
    {
        
    }
};

class FCCtrlCheckbox : public FCControl
{
    struct __FCCtrlCheckbox_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY_INT         checkstate;
        _NONWINDOW_PROPERTY_BOOL        threestate;
    } checkbox_nonwindow_store;
    
    virtual _CONTROL_TYPE _GetControlType() { return CONTROLTYPE_CHECKBOX; }
    
    virtual float _GetAutoCreateWidth() { return 100; }
    
    /* For internal use only! */
    virtual void _InitNonWindowHandleStates();
    
    /* For internal use only */
    virtual void _StoreNonWindowHandleStates();
public:
        FCCtrlCheckbox(twobyte id) : FCControl(id) {}

    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;
    }

#ifdef PDK_FRAMEWORK_DIAGNOSE
        virtual const char* _WinGetUIClassName() { return "Button"; }
    virtual const char* _MacGetUIClassName() { return "NSButton"; }
#endif
};

class FCCtrlButton : public FCCtrlCheckbox
{
        WINCODE(HFONT _storednewfont;)

    virtual _CONTROL_TYPE _GetControlType() { return CONTROLTYPE_BUTTON; }
    
    virtual float _GetAutoCreateWidth() { return 60; }
public:
        FCCtrlButton(twobyte id) : FCCtrlCheckbox(id) 
        {
                WINCODE(_storednewfont = 0;)
        }

        /* Destructor */
        virtual ~FCCtrlButton();
    
    void ClearShortcutKey();

        void SetFontSize(int fontsize);

#ifdef PDK_FRAMEWORK_DIAGNOSE
        virtual const char* _WinGetUIClassName() { return "Button"; }
    virtual const char* _MacGetUIClassName() { return "NSButton"; }
#endif
};


class FCCtrlSlider : public FCControl
{
    virtual _CONTROL_TYPE _GetControlType() { return CONTROLTYPE_SLIDER; }
    
    virtual float _GetAutoCreateWidth() { return 150; }
    
    struct __FCCtrlSlider_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY_INT         minvalue;
        _NONWINDOW_PROPERTY_INT         maxvalue;
        _NONWINDOW_PROPERTY_INT         thumbpos;
    } slider_nonwindow_store;
    
    /* For internal use only! */
    virtual void _InitNonWindowHandleStates();
    
    /* For internal use only */
    virtual void _StoreNonWindowHandleStates();
public:
        FCCtrlSlider(twobyte id) : FCControl(id) {}

    int GetMinValue();
    
        void SetMinValue(int min);

        int GetMaxValue();
    
        void SetMaxValue(int max);

        void SetThumbPosition(int position);

        int GetThumbPosition(); 

#ifdef PDK_FRAMEWORK_DIAGNOSE   
        virtual const char* _WinGetUIClassName() { return "msctls_trackbar32"; }
    virtual const char* _MacGetUIClassName() { return "NSSlider"; }
#endif
};


#ifdef PDK_FRAMEWORK_CANVASCTRL

class FCCtrlCanvas : public FCControl
{
    struct __FCCtrlSlider_NONWINDOWSTORAGE
    {
        _NONWINDOW_PROPERTY_VOIDPTR         instructions;
    } canvas_nonwindow_store;

    virtual _CONTROL_TYPE _GetControlType() { return CONTROLTYPE_CANVAS; }
    
    virtual float _GetAutoCreateWidth() { return 80; }
    
    virtual float _GetAutoCreateMultilineHeight() { return 80; }
    
    /* For internal use only! */
    virtual void _InitNonWindowHandleStates();
    
    /* For internal use only */
    virtual void _StoreNonWindowHandleStates();
public:
    FCCtrlCanvas(twobyte id) : FCControl(id) {}
    
    void RebuildInstructions(FCVirtualCanvasInstructions* pInstructions);
    
#ifdef PDK_FRAMEWORK_DIAGNOSE
    virtual const char* _WinGetUIClassName() { return "Static"; }
    virtual const char* _MacGetUIClassName() { 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();

    void DestroyWindow();

    virtual void InitWindow();
    
    virtual void CloseWindow();

    __FCUserWindow* GetParent() { return _pParent; }

    void ShowModeless(EWND 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
    twobyte
#endif
        ExecuteModal(__FCUserWindow *pParent);
    
#if OPERATING_SYSTEM == WINDOWS

    virtual bool HandleWMNotify(WPARAM wparam, LPARAM lparam);
#endif


    void _SetupInternalWindowCode();

    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));
    }
    
    FCCtrlComboBox* AddComboBox(twobyte id)
    {
        return (FCCtrlComboBox*) AddCtrl(new FCCtrlComboBox(id));
    }

    FCCtrlEdit* AddEdit(twobyte id) {
        return (FCCtrlEdit*) AddCtrl(new FCCtrlEdit(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
{       
    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;
    }
    
    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);
    
    virtual void _InitNonWindowHandleStates();
public:
    FCCustomWindow() : FCResourceWindow(__IDRESOURCE_CUSTOMWINDOW)
    {
        _SetPointsMeasurement(true);
    }

    FCCtrlStatic* CreateStatic(float x, float y) { return (FCCtrlStatic*) _AddCreatedCtrl(new FCCtrlStatic(_CalcAvailableCtrlID()), x, y); }
    
    FCCtrlEdit* CreateEdit(float x, float y) { return (FCCtrlEdit*) _AddCreatedCtrl(new FCCtrlEdit(_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); }
    
    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;
    }
    
    FCCtrlPopup* CreatePopup(float x, float y) { return (FCCtrlPopup*) _AddCreatedCtrl(new FCCtrlPopup(_CalcAvailableCtrlID()), x, y); }
    
    FCCtrlLine* CreateHorizontalLine(float x, float y, float width)
    {
        FCCtrlLine* pLine = (FCCtrlLine*) _AddCreatedCtrl(new FCCtrlLine(_CalcAvailableCtrlID()), x, y);
        pLine->SetHorizontal(true);
        pLine->SetWidth(width);
        return pLine;
    }
    
    FCCtrlLine* CreateVerticalLine(float x, float y, float height)
    {
        FCCtrlLine* pLine = (FCCtrlLine*) _AddCreatedCtrl(new FCCtrlLine(_CalcAvailableCtrlID()), x, y);
        pLine->SetHorizontal(false);
        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;
        return (FCCtrlRadioButtonGroup*) _AddCreatedCtrl(new FCCtrlRadioButtonGroup(_CalcAvailableCtrlID(), no_of_items), x, y);
    }
    
    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); }
};

#endif  /* #ifdef PDK_FRAMEWORK_DIALOGS */

#endif  /* FF_DIALOGS_H */