CEditWithoutIme

/*
CEditWithoutIme.h

zlib License:

Copyright (c) 2014 Egtra

This software is provided 'as-is', without any express or implied
warranty.  In no event will the authors be held liable for any damages
arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/

#pragma once

#include <windows.h>
#include <imm.h>
#include <oleacc.h>

#include <atlbase.h>
#include <atlwin.h>

#include <atlapp.h>
#include <atlctrls.h>
#include <atlcrack.h>

template<class T, class TBase = WTL::CEdit, class TWinTraits = ATL::CControlWinTraits>
class CEditWithoutImeT: public ATL::CWindowImpl<T, TBase, TWinTraits>
{
public:
	BEGIN_MSG_MAP(CEditWithoutImeT)
		MSG_WM_CREATE(OnCreate)
		MESSAGE_HANDLER_EX(WM_GETOBJECT, OnGetObject)
	END_MSG_MAP()

	BOOL SubclassWindow(HWND hwnd)
	{
		auto ret = CWindowImpl::SubclassWindow(hwnd);
		if (ret)
		{
			// http://support.microsoft.com/kb/171154/ja
			ImmAssociateContext(hwnd, nullptr);
		}
		return ret;
	}

private:
	// For WTL's superclassing
	LRESULT OnCreate(const CREATESTRUCT*)
	{
		ImmAssociateContext(m_hWnd, nullptr);
		SetMsgHandled(FALSE);
		return 0;
	}

	class ATL_NO_VTABLE Accessible
		: public ATL::CComObjectRootEx<ATL::CComSingleThreadModel>
		, public IAccessible
	{
	public:
		BEGIN_COM_MAP(Accessible)
			COM_INTERFACE_ENTRY(IAccessible)
			COM_INTERFACE_ENTRY(IDispatch)
		END_COM_MAP()

		IFACEMETHOD(GetTypeInfoCount)(__RPC__out UINT* pctinfo) override
		{
			return m_base->GetTypeInfoCount(pctinfo);
		}

		IFACEMETHOD(GetTypeInfo)(UINT iTInfo, LCID lcid, __RPC__deref_out_opt ITypeInfo** ppTInfo) override
		{
			return m_base->GetTypeInfo(iTInfo, lcid, ppTInfo);
		}

		IFACEMETHOD(GetIDsOfNames)(__RPC__in REFIID riid, __RPC__in_ecount_full(cNames) LPOLESTR* rgszNames, __RPC__in_range(0, 16384) UINT cNames, LCID lcid, __RPC__out_ecount_full(cNames) DISPID* rgDispId) override
		{
			return m_base->GetIDsOfNames(riid, rgszNames, cNames, lcid, rgDispId);
		}

		IFACEMETHOD(Invoke)(_In_ DISPID dispIdMember, _In_ REFIID riid, _In_ LCID lcid, _In_ WORD wFlags, _In_ DISPPARAMS* pDispParams, _Out_opt_ VARIANT* pVarResult, _Out_opt_ EXCEPINFO* pExcepInfo, _Out_opt_ UINT* puArgErr) override
		{
			return m_base->Invoke(dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
		}

		IFACEMETHOD(get_accParent)(__RPC__deref_out_opt IDispatch** ppdispParent) override
		{
			return m_base->get_accParent(ppdispParent);
		}

		IFACEMETHOD(get_accChildCount)(__RPC__out long* pcountChildren) override
		{
			return m_base->get_accChildCount(pcountChildren);
		}

		IFACEMETHOD(get_accChild)(VARIANT varChild, __RPC__deref_out_opt IDispatch** ppdispChild) override
		{
			return m_base->get_accChild(varChild, ppdispChild);
		}

		IFACEMETHOD(get_accName)(VARIANT varChild, __RPC__deref_out_opt BSTR* pszName) override
		{
			return m_base->get_accName(varChild, pszName);
		}

		IFACEMETHOD(get_accValue)(VARIANT varChild, __RPC__deref_out_opt BSTR* pszValue) override
		{
			return m_base->get_accValue(varChild, pszValue);
		}

		IFACEMETHOD(get_accDescription)(VARIANT varChild, __RPC__deref_out_opt BSTR* pszDescription) override
		{
			return m_base->get_accDescription(varChild, pszDescription);
		}

		IFACEMETHOD(get_accRole)(VARIANT varChild, __RPC__out VARIANT* pvarRole) override
		{
			return m_base->get_accRole(varChild, pvarRole);
		}

		IFACEMETHOD(get_accState)(VARIANT varChild, __RPC__out VARIANT* pvarState) override
		{
			ATLENSURE_RETURN_HR(pvarState != nullptr, E_POINTER);
			ATL::CComVariant state;
			auto hr = m_base->get_accState(varChild, &state);
			ATLENSURE_RETURN_HR(SUCCEEDED(hr), hr);
			ATL::CComVariant additionalState(STATE_SYSTEM_PROTECTED);
			return VarOr(&state, &additionalState, pvarState);
		}

		IFACEMETHOD(get_accHelp)(VARIANT varChild, __RPC__deref_out_opt BSTR* pszHelp) override
		{
			return m_base->get_accHelp(varChild, pszHelp);
		}

		IFACEMETHOD(get_accHelpTopic)(__RPC__deref_out_opt BSTR* pszHelpFile, VARIANT varChild, __RPC__out long* pidTopic) override
		{
			return m_base->get_accHelpTopic(pszHelpFile, varChild, pidTopic);
		}

		IFACEMETHOD(get_accKeyboardShortcut)(VARIANT varChild, __RPC__deref_out_opt BSTR* pszKeyboardShortcut) override
		{
			return m_base->get_accKeyboardShortcut(varChild, pszKeyboardShortcut);
		}

		IFACEMETHOD(get_accFocus)(__RPC__out VARIANT* pvarChild) override
		{
			return m_base->get_accFocus(pvarChild);
		}

		IFACEMETHOD(get_accSelection)(__RPC__out VARIANT* pvarChildren) override
		{
			return m_base->get_accSelection(pvarChildren);
		}

		IFACEMETHOD(get_accDefaultAction)(VARIANT varChild, __RPC__deref_out_opt BSTR* pszDefaultAction) override
		{
			return m_base->get_accDefaultAction(varChild, pszDefaultAction);
		}

		IFACEMETHOD(accSelect)(long flagsSelect, VARIANT varChild) override
		{
			return m_base->accSelect(flagsSelect, varChild);
		}

		IFACEMETHOD(accLocation)(__RPC__out long* pxLeft, __RPC__out long* pyTop, __RPC__out long* pcxWidth, __RPC__out long* pcyHeight, VARIANT varChild) override
		{
			return m_base->accLocation(pxLeft, pyTop, pcxWidth, pcyHeight, varChild);
		}

		IFACEMETHOD(accNavigate)(long navDir, VARIANT varStart, __RPC__out VARIANT* pvarEndUpAt) override
		{
			return m_base->accNavigate(navDir, varStart, pvarEndUpAt);
		}

		IFACEMETHOD(accHitTest)(long xLeft, long yTop, __RPC__out VARIANT* pvarChild) override
		{
			return m_base->accHitTest(xLeft, yTop, pvarChild);
		}

		IFACEMETHOD(accDoDefaultAction)(VARIANT varChild) override
		{
			return m_base->accDoDefaultAction(varChild);
		}

		IFACEMETHOD(put_accName)(VARIANT varChild, __RPC__in BSTR szName) override
		{
			return m_base->put_accName(varChild, szName);
		}

		IFACEMETHOD(put_accValue)(VARIANT varChild, __RPC__in BSTR szValue) override
		{
			return m_base->put_accValue(varChild, szValue);
		}

		static HRESULT Create(_In_ HWND hwnd, _COM_Outptr_ IAccessible** out)
		{
			ATLENSURE_RETURN_HR(out != nullptr, E_POINTER);
			ATL::CComObject<Accessible>* p = nullptr;
			auto hrCreate = ATL::CComObject<Accessible>::CreateInstance(&p);
			ATLENSURE_RETURN_HR(SUCCEEDED(hrCreate), hrCreate);
			auto hrInit = p->Initialize(hwnd);
			if (SUCCEEDED(hrInit))
			{
				*out = p;
				p->AddRef();
			}
			return hrInit;
		}

	private:
		HRESULT Initialize(_In_ HWND hwnd)
		{
			return CreateStdAccessibleObject(hwnd, OBJID_CLIENT, IID_PPV_ARGS(&m_base));
		}

		ATL::CComPtr<IAccessible> m_base;
	};

	LRESULT OnGetObject(UINT, WPARAM wParam, LPARAM lParam)
	{
		if (lParam == OBJID_CLIENT)
		{
			if (m_acc == nullptr)
			{
				Accessible::Create(*this, &m_acc);
			}
			return LresultFromObject(__uuidof(*m_acc), wParam, m_acc);
		}
		else
		{
			SetMsgHandled(FALSE);
			return 0;
		}
	}

	ATL::CComPtr<IAccessible> m_acc;
};

class CEditWithoutIme : public CEditWithoutImeT<CEditWithoutIme> {};