//======================================================================
// NumPanel - A Windows CE example input method
//
// Written for the book Programming Windows CE
// Copyright (C) 1998 Douglas Boling
//======================================================================
#include <windows.h>                 // For all that Windows stuff
#include <commctrl.h>                // Command bar includes
#define INITGUID
#include <initguid.h>
#include <coguid.h>
#include <aygshell.h>                // Palm-size PC shell includes
#include <sip.h>                     // SIP includes

#include "NumPanel.h"                // Local program includes
#include "NPWnd.h"                   // My IM window includes
HINSTANCE hInst;                     // DLL instance handle
long g_DllCnt = 0;                   // Global DLL reference count

// Replace this GUID with your own!
static const TCHAR szCLSIDNumPanel[] = 
TEXT ("{C915FE81-24C0-11d2-93F7-204C4F4F5020}");
static const GUID CLSID_NumPanel = 
{0xc915fe81, 0x24c0, 0x11d2, {0x93,0xf7,0x20,0x4c,0x4f,0x4f,0x50,0x20}};
static const TCHAR szFriendlyName[] = TEXT ("Numeric Keypad");
//======================================================================
// DllMain - DLL initialization entry point
//
BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD dwReason, 
                     LPVOID lpvReserved) {
    hInst = hinstDLL;
    return TRUE;
}
//======================================================================
// DllGetClassObject - Exported function called to get pointer to 
// Class factory object
//
STDAPI DllGetClassObject (REFCLSID rclsid, REFIID riid, LPVOID *ppv) {
    MyClassFactory *pcf;
    HRESULT hr;

    // See if caller wants us...
    if (IsEqualCLSID (rclsid, CLSID_NumPanel)) {

        // Create IClassFactory object.
        pcf = new MyClassFactory();
        if (pcf == NULL)
            return E_OUTOFMEMORY;

        // Call class factory's query interface method.
        hr = pcf->QueryInterface (riid, ppv);
        // This will cause an obj delete unless interface found
        pcf->Release();
        return hr;
    }
    return CLASS_E_CLASSNOTAVAILABLE;
}
//======================================================================
// DllCanUnloadNow - Exported function called when DLL can unload
//
STDAPI DllCanUnloadNow () {

    if (g_DllCnt)
        return S_FALSE;
    return S_OK;
}
//======================================================================
// DllRegisterServer - Exported function called to register the server
//
STDAPI DllRegisterServer () {
    TCHAR szName[MAX_PATH+2];
    DWORD dwDisp;
    HKEY hKey, hSubKey;
    INT rc, i;

    GetModuleFileName (hInst, szName, sizeof (szName));
    // Open the key.
    rc = RegCreateKeyEx (HKEY_CLASSES_ROOT, szCLSIDNumPanel, 0,
                         TEXT (""), 0, 0, NULL, &hKey, &dwDisp);
    if (rc != ERROR_SUCCESS)
        return E_FAIL;

    // Set the friendly name of the SIP.
    RegSetValueEx (hKey, TEXT (""), 0, REG_SZ, (PBYTE)szFriendlyName,
                   (lstrlen (szFriendlyName)+1) * sizeof (TCHAR));

    // Create subkeys.
    // Set the module name of the SIP.
    rc = RegCreateKeyEx (hKey, TEXT ("InProcServer32"), 0, TEXT (""),
                         0, 0, NULL, &hSubKey, &dwDisp);
    rc = RegSetValueEx (hSubKey, TEXT (""), 0, REG_SZ, (PBYTE)szName,
                        (lstrlen (szName)+1) * sizeof (TCHAR));
    RegCloseKey (hSubKey);

    // Set the default icon of the server.
    RegCreateKeyEx (hKey, TEXT ("DefaultIcon"), 0, TEXT (""),
                         0, 0, NULL, &hSubKey, &dwDisp);
    lstrcat (szName, TEXT (",0"));
    RegSetValueEx (hSubKey, TEXT (""), 0, REG_SZ, (PBYTE)szName,
                        (lstrlen (szName)+1) * sizeof (TCHAR));
    RegCloseKey (hSubKey);

    // Set the flag indicating this is a SIP.
    RegCreateKeyEx (hKey, TEXT ("IsSIPInputMethd"), 0, TEXT (""), 
                    0, 0, NULL, &hSubKey, &dwDisp);
    i = 1;
    RegSetValueEx (hSubKey, TEXT (""), 0, REG_DWORD, (PBYTE)&i, 4);
    RegCloseKey (hSubKey);

    RegCloseKey (hKey);
    return S_OK;
}
//======================================================================
// DllUnregisterServer - Exported function called to remove the server
// information from the registry
//
STDAPI DllUnregisterServer() {
    INT rc;
    rc = RegDeleteKey (HKEY_CLASSES_ROOT, szCLSIDNumPanel);
    if (rc == ERROR_SUCCESS)
        return S_OK;
    return E_FAIL;
}
//**********************************************************************
// MyClassFactory Object implimentation
//----------------------------------------------------------------------
// Object constructor
MyClassFactory::MyClassFactory () {
    m_lRef = 1;     //Set ref count to 1 on create
    return;
}
//----------------------------------------------------------------------
// Object destructor
MyClassFactory::~MyClassFactory () {
    return;
}
//----------------------------------------------------------------------
// QueryInterface - Called to see what interfaces this object supports
STDMETHODIMP MyClassFactory::QueryInterface (THIS_ REFIID riid, 
                                             LPVOID *ppv) {

    // If caller wants our IUnknown or IClassFactory object, 
    // return a pointer to the object.
    if (IsEqualIID (riid, IID_IUnknown) || 
        IsEqualIID (riid, IID_IClassFactory)) {

        *ppv = (LPVOID)this;     // return pointer to object.
        AddRef();                // Inc ref to prevent delete on return.
        return NOERROR;
    }
    *ppv = NULL;
    return (E_NOINTERFACE);
}
//----------------------------------------------------------------------
// AddRef - Increment object reference count.
STDMETHODIMP_(ULONG) MyClassFactory::AddRef (THIS) {
    ULONG cnt;

    cnt = (ULONG)InterlockedIncrement (&m_lRef);
    return cnt;
}
//----------------------------------------------------------------------
// Release - Decrement object reference count.
STDMETHODIMP_(ULONG) MyClassFactory::Release (THIS) {
    ULONG cnt;

    cnt = (ULONG)InterlockedDecrement (&m_lRef);
    if (cnt == 0)
        delete this;
    return cnt;
}
//----------------------------------------------------------------------
// LockServer - Called to tell the DLL not to unload even if use cnt 0
STDMETHODIMP MyClassFactory::LockServer (BOOL fLock) {
    if (fLock)
        InterlockedIncrement (&g_DllCnt);
    else
        InterlockedDecrement (&g_DllCnt);
    return NOERROR;
}
//----------------------------------------------------------------------
// CreateInstance - Called to have class factory object create other
// objects
STDMETHODIMP MyClassFactory::CreateInstance (LPUNKNOWN pUnkOuter, 
                                             REFIID riid, LPVOID *ppv) {
    MyIInputMethod *pMyIM;
    HRESULT hr;

    if (pUnkOuter)
        return (CLASS_E_NOAGGREGATION);

    if (IsEqualIID (riid, IID_IUnknown) || 
        IsEqualIID (riid, IID_IInputMethod)) {

        // Create file filter object.
        pMyIM = new MyIInputMethod();
        if (!pMyIM)
            return E_OUTOFMEMORY;

        // See if object exports the proper interface.
        hr = pMyIM->QueryInterface (riid, ppv);
        // This will cause an obj delete unless interface found.
        pMyIM->Release ();
        return hr;
    } 
    return E_NOINTERFACE;
}

//**********************************************************************
// MyIInputMethod Object implementation
//----------------------------------------------------------------------
// Object constructor
MyIInputMethod::MyIInputMethod () {

    m_lRef = 1;     //Set reference count to 1 on create.
    g_DllCnt++;
    return;
}
//----------------------------------------------------------------------
// Object destructor
MyIInputMethod::~MyIInputMethod () {
    g_DllCnt--;
    return;
}
//----------------------------------------------------------------------
// QueryInterface - Called to see what interfaces this object supports
STDMETHODIMP MyIInputMethod::QueryInterface (THIS_ REFIID riid, 
                                             LPVOID *ppv) {

    // If caller wants our IUnknown or IID_ICeFileFilter object, 
    // return a pointer to the object.
    if (IsEqualIID (riid, IID_IUnknown) || 
        IsEqualIID (riid, IID_IInputMethod)){

        // Return pointer to object.
        *ppv = (IInputMethod *)this;
        AddRef();                // Inc ref to prevent delete on return.
        return NOERROR;
    }
    *ppv = NULL;
    return (E_NOINTERFACE);
}
//----------------------------------------------------------------------
// AddRef - Increment object reference count.
STDMETHODIMP_(ULONG) MyIInputMethod::AddRef (THIS) {
    ULONG cnt;

    cnt = (ULONG)InterlockedIncrement (&m_lRef);
    return cnt;
}
//----------------------------------------------------------------------
// Release - Decrement object reference count.
STDMETHODIMP_(ULONG) MyIInputMethod::Release (THIS) {
    ULONG cnt;

    cnt = (ULONG)InterlockedDecrement (&m_lRef);
    if (cnt == 0) {
        delete this;
        return 0;
    }
    return cnt;
}
//----------------------------------------------------------------------
// Select - The IM has just been loaded into memory.
//
HRESULT STDMETHODCALLTYPE MyIInputMethod::Select (HWND hwndSip) {
    RECT rect;
    WNDCLASS wc;
    HBITMAP hBmp, hbmpMask;

    m_hwndParent = hwndSip;

    // Create image list for narrow (16x16) image.
    m_himlNarrow = ImageList_Create (16, 16, ILC_COLOR | ILC_MASK, 
                                     1, 0);
    hBmp = LoadBitmap (hInst, TEXT ("NarrowBmp"));
    hbmpMask = LoadBitmap (hInst, TEXT ("NarrowMask"));
    ImageList_Add (m_himlNarrow, hBmp, hbmpMask);
    DeleteObject (hBmp);
    DeleteObject (hbmpMask);

    // Create image list for wide (32x16) image.
    m_himlWide = ImageList_Create (32, 16, ILC_COLOR | ILC_MASK, 1, 0);
    hBmp = LoadBitmap (hInst, TEXT ("WideBmp"));
    hbmpMask = LoadBitmap (hInst, TEXT ("WideMask"));
    ImageList_Add (m_himlWide, hBmp, hbmpMask);
    DeleteObject (hBmp);
    DeleteObject (hbmpMask);

    // Register SIP window class.
    memset (&wc, 0, sizeof (wc));
    wc.style = CS_DBLCLKS;
    wc.lpfnWndProc = NPWndProc;               // Callback function
    wc.hInstance = hInst;                     // Owner handle
    wc.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH);
    wc.lpszClassName = MYSIPCLS;              // Window class name
    if (RegisterClass (&wc) == 0) return E_FAIL;

    // Create SIP window.  
    GetClientRect (hwndSip, &rect);
    m_hwndMyWnd = CreateWindowEx (0, MYSIPCLS, TEXT (""), 
                  WS_VISIBLE | WS_CHILD | WS_BORDER, rect.left, 
                  rect.top, rect.right - rect.left, 
                  rect.bottom - rect.top, hwndSip, (HMENU)IDC_SIP, 
                  hInst, 0);
    if (!IsWindow (m_hwndMyWnd))
        return E_FAIL;

    return S_OK;
}
//----------------------------------------------------------------------
// Deselect - The IM is about to be unloaded.
//
HRESULT STDMETHODCALLTYPE MyIInputMethod::Deselect (void) {

    // Clean up since we're about to be unloaded.
    DestroyWindow (m_hwndMyWnd);
    UnregisterClass (MYSIPCLS, hInst);
    ImageList_Destroy (m_himlNarrow);
    ImageList_Destroy (m_himlWide);
    return S_OK;
}
//----------------------------------------------------------------------
// Showing - The IM is about to be made visible.
//
HRESULT STDMETHODCALLTYPE MyIInputMethod::Showing (void) {
    return S_OK;
}
//----------------------------------------------------------------------
// Hiding - The IM is about to be hidden.
//
HRESULT STDMETHODCALLTYPE MyIInputMethod::Hiding (void) {
    return S_OK;
}
//----------------------------------------------------------------------
// GetInfo - The SIP wants info from the IM.
//
HRESULT STDMETHODCALLTYPE MyIInputMethod::GetInfo (
                                              IMINFO __RPC_FAR *pimi) {
    pimi->cbSize = sizeof (IMINFO);
    pimi->hImageNarrow = m_himlNarrow;
    pimi->hImageWide = m_himlWide;
    pimi->iNarrow = 0;
    pimi->iWide = 0;  
    pimi->fdwFlags = SIPF_DOCKED;

    pimi->rcSipRect.left = 0;
    pimi->rcSipRect.top = 0;
    pimi->rcSipRect.right = FLOATWIDTH;
    pimi->rcSipRect.bottom = FLOATHEIGHT;
    SendMessage (m_hwndMyWnd, MYMSG_METHCALL, 1, (LPARAM) pimi);
    return S_OK;
}
//----------------------------------------------------------------------
// ReceiveSipInfo - The SIP is passing info to the IM.
//
HRESULT STDMETHODCALLTYPE MyIInputMethod::ReceiveSipInfo (
                                               SIPINFO __RPC_FAR *psi) {
    // Pass the SIP info data to the window.
    SendMessage (m_hwndMyWnd, MYMSG_METHCALL, 2, (LPARAM) psi);
    return S_OK;
}
//----------------------------------------------------------------------
// RegisterCallback - The SIP is providing the IM with the pointer to 
// the IIMCallback interface.
//
HRESULT STDMETHODCALLTYPE MyIInputMethod::RegisterCallback (
                                  IIMCallback __RPC_FAR *lpIMCallback) {
    m_pIMCallback = lpIMCallback;
    PostMessage (m_hwndMyWnd, MYMSG_METHCALL, 0, (LPARAM)m_pIMCallback);
    return S_OK;
}
//----------------------------------------------------------------------
// GetImData - An application is passing IM-specfic data to the IM.
// 
HRESULT STDMETHODCALLTYPE MyIInputMethod::GetImData (DWORD dwSize,
                                                     LPVOID pvImData) {
    return E_FAIL;
}
//----------------------------------------------------------------------
// SetImData - An application is querying IM-specfic data from the IM.
//
HRESULT STDMETHODCALLTYPE MyIInputMethod::SetImData (DWORD dwSize, 
                                                     LPVOID pvImData) {
    return S_OK;
}
//----------------------------------------------------------------------
// UserOptionsDlg - The SIP control panel applet is asking for a 
// configuration dialog box to be displayed.
//
HRESULT STDMETHODCALLTYPE MyIInputMethod::UserOptionsDlg (
                                                     HWND hwndParent) {
    MessageBox (hwndParent, TEXT ("UserOptionsDlg called."),
                TEXT ("NumPanel"), MB_OK);
    return S_OK;
}