ScopeEditCtrl.h

#pragma once

#include "helpers/ScopeValue.h"
#include "helpers/ScopeString.h"
#include "ScopeDefines.h"

namespace scope {
    namespace gui {

template <class ValT>
class CScopeEditCtrl
    : public CWindowImpl<CScopeEditCtrl<ValT>, CEdit> {

protected:
    bool created;

    ScopeValue<ValT>* const scope_val;

    boost::signals2::connection stateconnection;

    boost::signals2::connection valueconnection;

    bool shiftstate;

public:
    BEGIN_MSG_MAP_EX(CScopeEditCtrl)
        MESSAGE_HANDLER(WM_CHAR, OnChar)
        MESSAGE_HANDLER(WM_KEYDOWN, OnKeyDown)
        MESSAGE_HANDLER(WM_KEYUP, OnKeyUp)
        MESSAGE_HANDLER(WM_KILLFOCUS, OnKillFocus)
        MESSAGE_HANDLER(WM_UPDATECONTROL, OnUpdateControl)
        DEFAULT_REFLECTION_HANDLER()
    END_MSG_MAP()

    /*CScopeEditImpl()              Default constructor is dangerous!
        : m_shiftstate(false)
        , m_ScopeValPtr(nullptr)
    {}*/

    CScopeEditCtrl(ScopeValue<ValT>* _scopeval, const bool& _connectback = false, const bool& _connectcontrolstate = false)
        : created(false)
        , scope_val(_scopeval)
        , shiftstate(false){
        if ( _connectback )
            valueconnection = scope_val->ConnectGUI(std::bind(&CScopeEditCtrl<ValT>::UpdateControl, this));
        if ( _connectcontrolstate )
            stateconnection = scope_val->ConnectState(std::bind(&CScopeEditCtrl<ValT>::SetState, this, std::placeholders::_1));
    }

     ~CScopeEditCtrl() {
        valueconnection.disconnect();           // Does not throw if not connected
        stateconnection.disconnect();
    }

    bool AttachToDlgItem(HWND hWnd) {
        if ( SubclassWindow(hWnd) ) {
            created = true;
            UpdateControl();
            return true;
        }
        return false;
    }

    LRESULT OnChar(UINT uMsg, WPARAM wParam,LPARAM lParam, BOOL& bHandled) {
        //ignore without a beep
        switch (wParam) {
        case '\t': // tab
        case '\r': //Carriage return
            return 0;
            break;
        }
        return DefWindowProc(uMsg, wParam, lParam);
    }

    LRESULT OnKeyDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) {
        switch (wParam) {
        case VK_RETURN:
        case VK_TAB:
            UpdateValue();
            ::PostMessage(GetParent(), WM_NEXTDLGCTL, shiftstate, 0L);
            return FALSE;
        case VK_SHIFT:
            shiftstate = true;
        }
        return DefWindowProc(uMsg, wParam, lParam);
    }

    LRESULT OnKeyUp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) {
        switch (wParam) {
        case VK_SHIFT:
            shiftstate = false;
        }
        return DefWindowProc(uMsg, wParam, lParam);
    }

    LRESULT OnKillFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) {
        UpdateValue();
        return DefWindowProc(uMsg, wParam, lParam);
    }

    LRESULT OnUpdateControl(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) {
        if ( scope_val != nullptr )
            SetWindowText(scope_val->ToChar().c_str());
        return 0;
    }
    void UpdateControl() {
        ::PostMessage(m_hWnd, WM_UPDATECONTROL, NULL, NULL);
    }

    void UpdateValue() {
        if ( scope_val != nullptr ) {
            const int32_t length = GetWindowTextLength()+1;         // +1 since terminating \0 is not counter
            std::vector<WCHAR> buff(length, L' ');
            GetWindowText(buff.data(), length);                 // empty control gives only a \0
            scope_val->SetFromString(buff.data());
        }
    }

    void SetState(const bool& state) {
        if ( created )
            EnableWindow(state);
    }
};


}

}