Windows/Windows-classic-samples
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Windows-classic-samples/Samples/Win7Samples/tabletpc/multireco/cpp/MultiReco.cpp
Raten 12d6772ad2 new
2025-11-28 00:35:46 +09:00

1579 lines
51 KiB
C++
Raw Permalink Blame History

// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// Module:
// MultiReco.cpp
//
// Description:
// This sample demonstrates such advanced features of the
// Microsoft Tablet PC Automation API used for handwriting
// recognition, as
// - serializing recognition results with a stroke collection
// - organizing stroke collections into a custom collection
// within the ink object
// - serializing ink object into/from an ISF file
// - enumerating the installed recognizers
// - creating a recognition context with a specific language
// recognizer
// - setting recognizer input guides
// - synchronous and asynchronous recognition
//
// This application is discussed in the Getting Started guide.
//
// (NOTE: For code simplicity, returned HRESULT is not checked
// for failure in the places where failures are not critical
// for the application)
//
// The interfaces used are:
// IInkRecognizers, IInkRecognizer, IInkRecognizerContext,
// IInkRecognitionResult, IInkRecognizerGuide,
// IInkCollector, IInkDisp, IInkRenderer, IInkDrawingAttributes,
// IInkCustomStrokes, IInkStrokes, IInkStroke
//
// Requirements:
// One or more handwriting recognizer must be installed on the system.
// Also, appropriate Asian fonts need to be installed to output the
// results of the Asian recognizers.
//
//--------------------------------------------------------------------------
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0500
#endif
// Windows header files
#include <windows.h>
#include <commctrl.h> // need it to call CreateStatusWindow
#include <commdlg.h>
// A useful macro to determine the number of elements in the array
#define countof(array) (sizeof(array)/sizeof(array[0]))
// ATL header files
#include <atlbase.h> // defines CComModule, CComPtr, CComVariant
CComModule _Module;
#include <atlwin.h> // defines CWindowImpl
#include <atlcom.h> // defines IDispEventSimpleImpl
// Header for the safe string manipulation
#include <strsafe.h>
// Headers for Tablet PC Automation interfaces
#include <msinkaut.h>
#include <msinkaut_i.c>
// The application header files
#include "resource.h" // main symbols, including command ID's
#include "EventSinks.h" // defines the IInkEventsImpl and IInkRecognitionEventsImpl
#include "ChildWnds.h" // definitions of the CInkInputWnd and CRecoOutputWnd
#include "MultiReco.h" // contains the definition of CAddRecoApp
// The static members of the event sink templates are initialized here
// (defined in EventSinks.h). These _ATL_FUNC_INFO structures contain type information
// used to describe a method or property on a dispinterface.
// Type information of the Recognition event of IInkRecognitionEvents
const _ATL_FUNC_INFO IInkRecognitionEventsImpl<CMultiRecoApp>::mc_AtlFuncInfo =
{CC_STDCALL, VT_EMPTY, 3, {VT_BSTR, VT_VARIANT, VT_I4}};
// Type information of the Stroke event of IInkCollectorEvents
const _ATL_FUNC_INFO IInkCollectorEventsImpl<CMultiRecoApp>::mc_AtlFuncInfo =
{CC_STDCALL, VT_EMPTY, 3, {VT_UNKNOWN, VT_UNKNOWN, VT_BOOL|VT_BYREF}};
// The sample uses different colors for different collections of strokes. Below is the palette.
const COLORREF CMultiRecoApp::mc_crColors[] = {
RGB( 0, 0, 0)/*black*/, RGB(0xA0,0,0)/*red*/, RGB(0,0xA0,0)/*green*/, RGB(0,0,0xA0)/*blue*/,
RGB(0xA0,0xA0,0)/**/, RGB(0xA0,0,0xA0)/**/, RGB(0,0xA0,0xA0)/**/, RGB(0xA0,0xA0,0xA0)/*gray*/
};
const WCHAR gc_szAppName[] = L"Multiple Language Recognition with Serialization";
/////////////////////////////////////////////////////////
//
// WinMain
//
// The WinMain function is called by the system as the
// initial entry point for a Win32-based application.
//
// Parameters:
// HINSTANCE hInstance, : [in] handle to current instance
// HINSTANCE hPrevInstance, : [in] handle to previous instance
// LPSTR lpCmdLine, : [in] command line
// int nCmdShow : [in] show state
//
// Return Values (int):
// 0 : The function terminated before entering the message loop.
// non zero: Value of the wParam when receiving the WM_QUIT message
//
/////////////////////////////////////////////////////////
int APIENTRY WinMain(
HINSTANCE hInstance,
HINSTANCE /*hPrevInstance*/, // not used here
LPSTR /*lpCmdLine*/, // not used here
int nCmdShow
)
{
int iRet = 0;
// Initialize the COM library and the application module
if (S_OK == ::CoInitializeEx(NULL, COINIT_APARTMENTTHREADED))
{
_Module.Init(NULL, hInstance);
// Register the common control classes used by the application
INITCOMMONCONTROLSEX icc;
icc.dwSize = sizeof(icc);
icc.dwICC = ICC_BAR_CLASSES;
if (TRUE == ::InitCommonControlsEx(&icc))
{
// Call the boilerplate function of the application
iRet = CMultiRecoApp::Run(nCmdShow);
}
else
{
::MessageBoxW(NULL, L"Error initializing the common controls.",
gc_szAppName, MB_ICONERROR | MB_OK);
}
// Release the module and the COM library
_Module.Term();
::CoUninitialize();
}
return iRet;
}
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::Run
//
// The static CMultiRecoApp::Run is the boilerplate of the application.
// It instantiates and initializes an CMultiRecoApp object and runs the
// application's message loop.
//
// Parameters:
// int nCmdShow : [in] show state
//
// Return Values (int):
// 0 : The function terminated before entering the message loop.
// non zero: Value of the wParam when receiving the WM_QUIT message
//
/////////////////////////////////////////////////////////
int CMultiRecoApp::Run(
int nCmdShow
)
{
CMultiRecoApp theApp;
// Load and update the menu before creating the main window.
// Create menu items for the installed recognizers and for the
// supported factoids.
HMENU hMenu = theApp.LoadMenu();
if (NULL == hMenu)
return 0;
int iRet;
// Load the icon from the resource and associate it with the window class
WNDCLASSEX& wc = CMultiRecoApp::GetWndClassInfo().m_wc;
wc.hIcon = wc.hIconSm = ::LoadIcon(_Module.GetResourceInstance(),
MAKEINTRESOURCE(IDR_APPICON));
// Create the application's main window
if (theApp.Create(NULL, CWindow::rcDefault, gc_szAppName,
WS_OVERLAPPEDWINDOW, 0, (UINT)hMenu) != NULL)
{
// Initialize the application object:
// Create an ink object
theApp.SendMessage(WM_COMMAND, ID_FILE_NEW);
// Create a recognition context using the first recognizer in the list
// and start new stroke collection
theApp.SendMessage(WM_COMMAND, ID_RECOGNIZER_FIRST);
// Show and update the main window
theApp.ShowWindow(nCmdShow);
theApp.UpdateWindow();
// Run the boilerplate message loop
MSG msg;
while (::GetMessage(&msg, NULL, 0, 0) > 0)
{
::TranslateMessage(&msg);
::DispatchMessage(&msg);
}
iRet = msg.wParam;
}
else
{
::MessageBoxW(NULL, L"Error creating the window",
gc_szAppName, MB_ICONERROR | MB_OK);
::DestroyMenu(hMenu);
iRet = 0;
}
return iRet;
}
// Window message handlers //////////////////////////////
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::OnCreate
//
// This WM_CREATE message handler creates the child windows,
// creates the required objects, sets their attributes,
// and enables pen input.
//
// Parameters:
// defined in the ATL's macro MESSAGE_HANDLER,
// none of them is used here
//
// Return Values (LRESULT):
// 0 if succeeded, or -1 otherwise
//
/////////////////////////////////////////////////////////
LRESULT CMultiRecoApp::OnCreate(
UINT /*uMsg*/,
WPARAM /*wParam*/,
LPARAM /*lParam*/,
BOOL& /*bHandled*/
)
{
// Create child windows for ink input and recognition output,
// listview controls for the lists of gestures, and a status bar
if (false == CreateChildWindows())
return -1;
HRESULT hr;
// Create an ink collector object.
hr = m_spIInkCollector.CoCreateInstance(CLSID_InkCollector);
if (FAILED(hr))
return -1;
// Establish a connection to the collector's event source.
hr = IInkCollectorEventsImpl<CMultiRecoApp>::DispEventAdvise(m_spIInkCollector);
// There is nothing interesting the application can do without events
// from the ink collector
if (FAILED(hr))
return -1;
// Enable ink input in the m_wndInput window
hr = m_spIInkCollector->put_hWnd((long)m_wndInput.m_hWnd);
if (FAILED(hr))
return -1;
hr = m_spIInkCollector->put_Enabled(VARIANT_TRUE);
if (FAILED(hr))
return -1;
// Create recognition guide objects
CreateRecoGuides();
return 0;
}
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::OnDestroy
//
// The WM_DESTROY message handler.
// Used for clean up and also to post a quit message to
// the application itself.
//
// Parameters:
// defined in the ATL's macro MESSAGE_HANDLER,
// none is used here
//
// Return Values (LRESULT):
// always 0
//
/////////////////////////////////////////////////////////
LRESULT CMultiRecoApp::OnDestroy(
UINT /*uMsg*/,
WPARAM /*wParam*/,
LPARAM /*lParam*/,
BOOL& /*bHandled*/
)
{
// Disable ink input and release the InkCollector object
if (m_spIInkCollector != NULL)
{
IInkCollectorEventsImpl<CMultiRecoApp>::DispEventUnadvise(m_spIInkCollector);
m_spIInkCollector->put_Enabled(VARIANT_FALSE);
m_spIInkCollector.Release();
}
// Detach the strokes collection from the recognition context
// and stop listening to the recognition events
if (m_spIInkRecoContext != NULL)
{
m_spIInkRecoContext->EndInkInput();
IInkRecognitionEventsImpl<CMultiRecoApp>::DispEventUnadvise(m_spIInkRecoContext);
m_spIInkRecoContext.Release();
}
// Release the other objects and collections
m_spIInkRecoGuideLined.Release();
m_spIInkRecoGuideBoxed.Release();
m_spIInkStrokes.Release();
m_spIInkRecognizers.Release();
// Post a WM_QUIT message to the application's message queue
::PostQuitMessage(0);
return 0;
}
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::OnSize
//
// The WM_SIZE message handler is needed to update
// the layout of the child windows
//
// Parameters:
// defined in the ATL's macro MESSAGE_HANDLER,
// wParam of the WN_SIZE message is the only used here.
//
// Return Values (LRESULT):
// always 0
//
/////////////////////////////////////////////////////////
LRESULT CMultiRecoApp::OnSize(
UINT /*uMsg*/,
WPARAM wParam,
LPARAM /*lParam*/,
BOOL& /*bHandled*/
)
{
if (wParam != SIZE_MINIMIZED)
{
UpdateLayout();
}
return 0;
}
// InkCollector event handlers ///////////////////////////
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::OnStroke
//
// The _IInkCollectorEvents's Stroke event handler.
// See the Tablet PC Automation API Reference for the
// detailed description of the event and its parameters.
//
// Parameters:
// IInkCursor* pIInkCursor : [in] not used here
// IInkStrokeDisp* pInkStroke : [in] the new stroke's interface pointer
// VARIANT_BOOL* pbCancel : [in,out] option to cancel the gesture,
// default value is FALSE, not modified here
//
// Return Values (HRESULT):
// S_OK if succeeded, E_FAIL or E_INVALIDARG otherwise
//
/////////////////////////////////////////////////////////
HRESULT CMultiRecoApp::OnStroke(
IInkCursor* /*pIInkCursor*/,
IInkStrokeDisp* pIInkStroke,
VARIANT_BOOL* pbCancel
)
{
if (m_spIInkStrokes == NULL) // shouldn't happen
return E_FAIL;
if (NULL == pIInkStroke)
return E_INVALIDARG;
HRESULT hr;
// Add the new stroke to the current collection
hr = m_spIInkStrokes->Add(pIInkStroke);
if (SUCCEEDED(hr))
{
// Cancel the previous background recognition requests
// which have not been processed yet
m_spIInkRecoContext->StopBackgroundRecognition();
// Ask the context to update the recognition results with newly added strokes
// When the results are ready, the recognition context will return them
// via the corresponding event RecognitionWithAlternates
CComVariant vCustomData;
m_spIInkRecoContext->BackgroundRecognize(vCustomData);
}
return hr;
}
// Recognition event handler ////////////////////////////
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::OnRecognition
//
// The _IInkRecognitionEvents's Recognition event handler
//
// Parameters:
// BSTR bstrRecognizedString : the top result of the recognition
// VARIANT vCustomParam : not used here
// InkRecognitionStatus RecognitionStatus : not used here
//
// Return Values (HRESULT):
// always S_OK
//
/////////////////////////////////////////////////////////
HRESULT CMultiRecoApp::OnRecognition(
BSTR bstrRecognizedString,
VARIANT /*vCustomParam*/,
InkRecognitionStatus /*RecognitionStatus*/
)
{
if (m_wndResults.IsWindow())
{
// Update the output window with the new results
m_wndResults.UpdateString(bstrRecognizedString);
}
if (NULL != bstrRecognizedString)
::SysFreeString(bstrRecognizedString);
return S_OK;
}
// Command handlers /////////////////////////////////////
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::OnClear
//
// Deletes all strokes and recognition results from the
// ink object and clears the windows.
//
// Parameters:
// defined in the ATL's macro COMMAND_RANGE_HANDLER
// Here only wID - the id of the command associated
// with the recognizer menu item - is used.
//
// Return Values (LRESULT):
// always 0
//
/////////////////////////////////////////////////////////
LRESULT CMultiRecoApp::OnClear(
WORD /*wNotifyCode*/,
WORD /*wID*/,
HWND /*hWndCtl*/,
BOOL& /*bHandled*/
)
{
if (m_spIInkDisp == NULL) // there is nothing to clear
return 0;
// Detach the current stroke collection from the recognition context and release it
if (m_spIInkRecoContext != NULL)
m_spIInkRecoContext->putref_Strokes(NULL);
m_spIInkStrokes.Release();
// Clear the custom strokes collection
if (m_spIInkCustomStrokes != NULL)
m_spIInkCustomStrokes->Clear();
// Delete all strokes from the Ink object
m_spIInkDisp->DeleteStrokes(NULL); // Passing NULL as a stroke collection pointer
// means asking to delete all strokes
// Get a new stroke collection from the ink object
CComVariant v; // This varaint is used to pass an array of ID's of the strokes
// which to be included into the new collection.
// Ask for an empty collection by passing an empty variant
if (SUCCEEDED(m_spIInkDisp->CreateStrokes(v, &m_spIInkStrokes)))
{
// Attach it to the recognition context
if (FAILED(m_spIInkRecoContext->putref_Strokes(m_spIInkStrokes)))
{
MessageBoxW(L"Unable to attach the stroke collection to "
L"the recognition context",
gc_szAppName, MB_ICONERROR | MB_OK);
}
}
else
{
MessageBoxW(L"Error creating new stroke collection.",
gc_szAppName, MB_ICONERROR | MB_OK);
}
// Update the child windows
m_wndInput.Invalidate();
m_wndResults.ResetResults(); // resets the text and updates the window
// Tell the results window that a new stroke collection
// is started, and set the color for it.
m_wndResults.AddString(
mc_crColors[m_iColor], // new current color
NULL // recognition result string, none yet
);
return 0;
}
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::OnNewStrokes
//
// This command handler is called when user selects a recognizer
// in the "New Strokes" submenu. It saves the current stroke collection,
// creates a new recognition context if user selected a different language
// recognizer, and then starts a new collection of strokes attached to
// the new recognition context.
//
// Parameters:
// defined in the ATL's macro COMMAND_RANGE_HANDLER
// Here only wID - the id of the command associated
// with the recognizer menu item - is used.
//
// Return Values (LRESULT):
// always 0
//
/////////////////////////////////////////////////////////
LRESULT CMultiRecoApp::OnNewStrokes(
WORD /*wNotifyCode*/,
WORD wID,
HWND /*hWndCtl*/,
BOOL& /*bHandled*/
)
{
// Change cursor to the system's Hourglass
HCURSOR hCursor = ::SetCursor(::LoadCursor(NULL, IDC_WAIT));
// Save the current stroke collection if there is any
if (m_spIInkRecoContext != NULL)
{
// Cancel the previous background recognition requests
// which have not been processed yet
m_spIInkRecoContext->StopBackgroundRecognition();
// Let the context know that there'll be no more input
// for the attached stroke collection
m_spIInkRecoContext->EndInkInput();
// Add the stroke collection to the Ink object's CustomStrokes collection
SaveStrokeCollection();
}
// If a different recognizer was selected, create a new recognition context
// Else, reuse the same recognition context
if (wID != m_nCmdRecognizer)
{
// Get a pointer to the recognizer object from the recognizer collection
CComPtr<IInkRecognizer> spIInkRecognizer;
if ((m_spIInkRecognizers == NULL)
|| FAILED(m_spIInkRecognizers->Item(wID - ID_RECOGNIZER_FIRST,
&spIInkRecognizer))
|| (false == CreateRecoContext(spIInkRecognizer)))
{
// restore the cursor
::SetCursor(hCursor);
return 0;
}
// Update the status bar
m_bstrCurRecoName.Empty();
spIInkRecognizer->get_Name(&m_bstrCurRecoName);
UpdateStatusBar();
// Store the selected recognizer's command id
m_nCmdRecognizer = wID;
}
// Create a new stroke collection
StartNewStrokeCollection();
// restore the cursor
::SetCursor(hCursor);
return 0;
}
// Helper methods //////////////////////////////
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::StartNewStrokeCollection
//
// Creates an empty stroke collection and attaches it
// to the recognition context.
//
// Parameters: none
//
// Return Values (void):
// ignore failures
//
/////////////////////////////////////////////////////////
void CMultiRecoApp::StartNewStrokeCollection()
{
if ((m_spIInkDisp == NULL) || (m_spIInkRecoContext == NULL))
return;
// Create a new empty stroke collection and attach it to the recognition context
CComVariant vt(0);
if (SUCCEEDED(m_spIInkDisp->CreateStrokes(vt, &m_spIInkStrokes)))
{
if (FAILED(m_spIInkRecoContext->putref_Strokes(m_spIInkStrokes)))
{
MessageBoxW(L"Failed to attach the stroke collection to "
L"the recognition context",
gc_szAppName, MB_ICONERROR | MB_OK);
}
// Change the color of the pen and text output
CComPtr<IInkDrawingAttributes> spIInkDrawAttrs;
if (SUCCEEDED(m_spIInkCollector->get_DefaultDrawingAttributes(&spIInkDrawAttrs)))
{
spIInkDrawAttrs->put_Color(mc_crColors[m_iColor]);
}
// Tell the output window that the new stroke collection is current now and
// it's future recognition results should be shown in the RichEdit control
// with a different color
m_wndResults.AddString(
mc_crColors[m_iColor], // new current color
NULL // recognition result string, none yet
);
}
else
{
MessageBoxW(L"Error creating new stroke collection.",
gc_szAppName, MB_ICONERROR | MB_OK);
}
}
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::LoadMenu
//
// This method instantiates an enumerator object for the installed
// recognizers, loads the main menu resource and creates a menu item
// for the recognizers from the collection.
//
// Parameters:
// none
//
// Return Values (HMENU):
// The return value is a handle of the menu
// that'll be used for the main window
//
/////////////////////////////////////////////////////////
HMENU CMultiRecoApp::LoadMenu()
{
HRESULT hr = S_OK;
// Create the enumerator for the installed recognizers
hr = m_spIInkRecognizers.CoCreateInstance(CLSID_InkRecognizers);
if (FAILED(hr))
return NULL;
// Get the number of the recognizers known to the system
LONG lCount = 0;
hr = m_spIInkRecognizers->get_Count(&lCount);
if (0 == lCount)
{
::MessageBoxW(NULL, L"There are no handwriting recognizers installed.\n"
L"You need to have at least one in order to run this sample.\nExiting.",
gc_szAppName, MB_ICONERROR | MB_OK);
return NULL;
}
// Load the menu of the main window
HMENU hMenu = ::LoadMenu(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDR_MENU));
if (NULL == hMenu)
return NULL; // Not normal
MENUITEMINFOW miinfo;
miinfo.cbSize = sizeof(miinfo);
miinfo.fMask = MIIM_ID | MIIM_STATE | MIIM_TYPE;
miinfo.fType = MFT_STRING;
// Get the submenu id for the recognizers menu.
// This submenu will contain the list of installed recognizers
HMENU hSubMenu = ::GetSubMenu(hMenu, mc_iSubmenuRecognizers);
if (NULL == hSubMenu)
{
::DestroyMenu(hMenu);
return NULL; // Not normal
}
// Remove the placeholding separator
::DeleteMenu(hSubMenu, 0, MF_BYPOSITION);
CComPtr<IInkRecognizer> spIInkRecognizer;
// Make sure that the number of menu items won't exceed
// the predefined range of the corresponding command ID's
if (lCount > (ID_RECOGNIZER_LAST - ID_RECOGNIZER_FIRST + 1))
lCount = ID_RECOGNIZER_LAST - ID_RECOGNIZER_FIRST + 1;
miinfo.fState = 0;
bool bAllFailed = true;
for (LONG i = 0; i < lCount; i++)
{
if (FAILED(m_spIInkRecognizers->Item(i, &spIInkRecognizer)))
continue;
// Filter out non-language recognizers by checking for
// the languages supported by the recognizer - there'll be
// none if it's a gesture or object recognizer.
CComVariant vLanguages;
if (SUCCEEDED(spIInkRecognizer->get_Languages(&vLanguages)))
{
if ((VT_ARRAY == (VT_ARRAY & vLanguages.vt)) // it should be an array
&& (NULL != vLanguages.parray)
&& (0 < vLanguages.parray->rgsabound[0].cElements)) // with at least one element
{
// This is a language recognizer. Add its name to the menu.
CComBSTR bstrName;
if (SUCCEEDED(spIInkRecognizer->get_Name(&bstrName)))
{
// The ID_RECOGNIZER_FIRST is defined in the resource.h file.
// It's the base id for the commands that fill this submenu
miinfo.wID = ID_RECOGNIZER_FIRST + i;
miinfo.dwTypeData = bstrName;
if ((::InsertMenuItemW(hSubMenu, (UINT)-1, TRUE, &miinfo) != 0)
&& (true == bAllFailed))
{
bAllFailed = false;
}
}
}
}
spIInkRecognizer.Release();
}
if (bAllFailed)
{
::MessageBoxW(
NULL,
L"Unable to find or load handwriting text recognizers.\n"
L"You need to have at least one in order to run this sample.\nExiting.",
gc_szAppName,
MB_ICONERROR | MB_OK);
::DestroyMenu(hMenu);
return NULL;
}
return hMenu;
}
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::DoOpen
//
// This helper function creates new ink object or takes
// one loaded from a file and attaches it to the ink collector,
// obtains a pointer to the custom strokes of the ink
// and populates the stored recognition results from the stroke
// collections.
//
// Parameters:
// bool bNew : true - create new ink object
// false - let the user pick an .isf file
// and load ink object from it.
//
// Return Values (bool):
// true - new ink object created or loaded from a file
// false - if failed to create ink object, or the user
// canceled the "Open" dialog box
//
/////////////////////////////////////////////////////////
bool CMultiRecoApp::DoOpen(
bool bNew
)
{
// Disable inking
m_spIInkCollector->put_Enabled(VARIANT_FALSE);
// Create a new ink object
CComPtr<IInkDisp> spIInkDisp;
if (FAILED(spIInkDisp.CoCreateInstance(CLSID_InkDisp)))
{
MessageBoxW(L"Unable to create an ink object.",
gc_szAppName, MB_ICONERROR | MB_OK);
// Enable inking
m_spIInkCollector->put_Enabled(VARIANT_TRUE);
return false;
}
// Let user select an .isf file to open
if (false == bNew)
{
if (false == LoadFile(spIInkDisp))
{
// Don't proceed if opening a file or reading from it failed
// or if the user canceled the operation
// Enable inking
m_spIInkCollector->put_Enabled(VARIANT_TRUE);
return false;
}
}
else
{
// Reset the file name and update the window's title
UpdateFilename();
}
// Replace the old Ink object with the new one
m_spIInkDisp.Attach(spIInkDisp.Detach()); // Attach/Detach don't call AddRef/Release
m_spIInkCollector->putref_Ink(m_spIInkDisp);
// Release the current stroke collections
m_spIInkStrokes.Release();
m_spIInkCustomStrokes.Release();
m_wndResults.ResetResults();
// Obtain a pointer to the custom strokes collection of the new ink object
long lCount = 0;
if (SUCCEEDED(m_spIInkDisp->get_CustomStrokes(&m_spIInkCustomStrokes)))
{
m_spIInkCustomStrokes->get_Count(&lCount);
for (CComVariant vItem(0); vItem.lVal < lCount; vItem.lVal++)
{
IInkStrokes* pIInkStrokes;
if (SUCCEEDED(m_spIInkCustomStrokes->Item(vItem, &pIInkStrokes)))
{
// Get the color of the strokes or use GRAY if fail
COLORREF clr = RGB(0x80,0x80,0x80);
CComPtr<IInkStrokeDisp> spIInkStroke;
CComPtr<IInkDrawingAttributes> spIDrawAttrs;
if (SUCCEEDED(pIInkStrokes->Item(0, &spIInkStroke))
&& SUCCEEDED(spIInkStroke->get_DrawingAttributes(&spIDrawAttrs)))
{
spIDrawAttrs->get_Color((long*)&clr);
}
// Get the best result string
CComBSTR bstrToString;
if (SUCCEEDED(pIInkStrokes->ToString(&bstrToString)))
{
// Add the string to the RichEdit control
m_wndResults.AddString(
clr, // the strokes color
bstrToString // the recognition result string
);
}
pIInkStrokes->Release();
}
}
}
// Create an empty new stroke collection and attach it to the recognition context
m_iColor = WORD(lCount) % countof(mc_crColors); // next color to use
StartNewStrokeCollection();
// Reset the Dirty flag
m_spIInkDisp->put_Dirty(VARIANT_FALSE);
// Update the input window
m_wndInput.Invalidate();
// Enable inking
m_spIInkCollector->put_Enabled(VARIANT_TRUE);
return true;
}
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::DoSave
//
// This function saves the current ink object into file.
//
//
// Parameters:
// bool bSaveAs: true - open "Save As..." common dialog box
// for the user to specify the filename
// false - save changes into the current file
// bool bAskUser: true - ask user whether she'd like to save
// the changes; it's used when DoSave
// is called from ID_FILE_NEW or ID_FILE_OPEN
// command handlers
// false - don't ask, just save
//
// Return Values (bool):
// true - succeeded or there's nothing to save or the user was
// was asked and said "No" to saving
// false - failed to save or canceled by the user
//
/////////////////////////////////////////////////////////
bool CMultiRecoApp::DoSave(
bool bSaveAs,
bool bAskUser
)
{
if (m_spIInkDisp == NULL)
return true;
// If there's been no changes since the last save,
// and it's not a SaveAs command, do nothing and return true
VARIANT_BOOL bDirty = VARIANT_TRUE;
if ((false == bSaveAs)
&& SUCCEEDED(m_spIInkDisp->get_Dirty(&bDirty))
&& VARIANT_FALSE == bDirty)
{
return true;
}
if (true == bAskUser)
{
int iRet = MessageBoxW(L"The ink object has been changed.\n"
L"Do you want to save the changes?",
gc_szAppName, MB_ICONQUESTION | MB_YESNOCANCEL);
if (IDCANCEL == iRet)
return false;
if (IDNO == iRet)
return true;
}
WCHAR wchFile[MAX_PATH];
WCHAR wchFileTitle[MAX_PATH];
wchFile[0] = wchFileTitle[0] = 0;
if (false == bSaveAs && 0 == m_wchFile[0])
bSaveAs = true;
// If the function is called from the ID_FILE_SAVEAS command handler,
// or the file is new, display the "SaveAs" common dialog box
// for the user to specify the file name
if (true == bSaveAs)
{
// Initialize the OPENFILENAME members.
OPENFILENAMEW ofn;
memset(&ofn, 0, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = m_hWnd;
ofn.lpstrDefExt = L"isf";
ofn.lpstrFilter = L"*.isf\0";
ofn.lpstrFileTitle= wchFileTitle;
ofn.nMaxFileTitle = countof(wchFileTitle);
ofn.lpstrFile= wchFile;
ofn.nMaxFile = countof(wchFile);
ofn.Flags = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY;
// Display the dialog box
if (::GetSaveFileNameW(&ofn) == 0)
return false; // canceled by the user
}
// Add the current stroke collection to the Ink's CustomStrokes and release it
SaveStrokeCollection();
// Save the ink object into a variant using the ISF format
bool bOk = false;
CComVariant vData;
if (SUCCEEDED(m_spIInkDisp->Save(
IPF_InkSerializedFormat, // save as ISF
IPCM_Default, // use default compression
&vData) // the output
))
{
BYTE* pbData;
if (SUCCEEDED(::SafeArrayAccessData(vData.parray, (void**)&pbData)))
{
// Create new or overwrite the existing file
HANDLE hFile = ::CreateFileW(
bSaveAs ? wchFile : m_wchFile,
GENERIC_WRITE,
0,
NULL,
CREATE_ALWAYS,
0,
NULL);
if (INVALID_HANDLE_VALUE != hFile)
{
// Write the data into the file
ULONG ulWritten, ulSize = vData.parray->rgsabound[0].cElements;
if (TRUE == ::WriteFile(hFile, pbData, ulSize, &ulWritten, NULL))
{
bOk = true;
m_spIInkDisp->put_Dirty(VARIANT_FALSE);
}
else
{
MessageBoxW(L"Error writing file!",
gc_szAppName, MB_ICONERROR | MB_OK);
}
::CloseHandle(hFile);
// Update the filename string
if (true == bSaveAs)
{
UpdateFilename(wchFile, wchFileTitle);
}
}
else
{
MessageBoxW(L"Unable to create the file.",
gc_szAppName, MB_ICONERROR | MB_OK);
}
::SafeArrayUnaccessData(vData.parray);
}
}
return bOk;
}
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::LoadFile
//
// Loads the ink object from the specified file.
//
// Parameters:
// IInkDisp* pIInkDisp : pointer to the ink object
//
// Return Values (bool):
// true - succeeded
// false - failed
//
/////////////////////////////////////////////////////////
bool CMultiRecoApp::LoadFile(
IInkDisp* pIInkDisp
)
{
WCHAR wchFile[MAX_PATH];
WCHAR wchFileTitle[MAX_PATH];
wchFile[0] = wchFileTitle[0] = 0;
// Initialize the OPENFILENAME members.
OPENFILENAMEW ofn;
memset(&ofn, 0, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = m_hWnd;
ofn.lpstrFilter = L"*.isf\0";
ofn.lpstrFileTitle= wchFileTitle;
ofn.nMaxFileTitle = countof(wchFileTitle);
ofn.lpstrFile= wchFile;
ofn.nMaxFile = countof(wchFile);
ofn.Flags = OFN_OVERWRITEPROMPT | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
// Display the "Open File..." common dialog box
if (::GetOpenFileNameW(&ofn) == 0)
{
return false;
}
// Open the file and populate the Ink object from it
HANDLE hFile = ::CreateFileW(wchFile, GENERIC_READ, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (INVALID_HANDLE_VALUE == hFile)
{
MessageBoxW(L"Error opening the file!", gc_szAppName, MB_ICONERROR | MB_OK);
return false;
}
// Load the file into a safearrray of bytes, then load the ink object from the array
bool bOk = false;
DWORD dwRead, dwSize;
dwSize = ::GetFileSize(hFile, NULL);
if (dwSize != DWORD(-1))
{
VARIANT vtData;
VariantInit(&vtData);
vtData.vt = VT_ARRAY | VT_UI1;
vtData.parray = ::SafeArrayCreateVector(VT_UI1, 0, dwSize);
if (vtData.parray)
{
BYTE *pbData;
if (SUCCEEDED(::SafeArrayAccessData(vtData.parray, (void**)&pbData)))
{
if (TRUE == ::ReadFile(hFile, pbData, dwSize, &dwRead, NULL)
&& SUCCEEDED(pIInkDisp->Load(vtData)))
{
bOk = true;
}
::SafeArrayUnaccessData(vtData.parray);
}
::SafeArrayDestroy(vtData.parray);
}
if (false == bOk)
{
MessageBoxW(L"Error loading ink object from the file.",
gc_szAppName, MB_ICONERROR | MB_OK);
}
}
else
{
MessageBoxW(L"Error reading data from the file.\nUnknown file format.",
gc_szAppName, MB_ICONERROR | MB_OK);
}
// Close the file
::CloseHandle(hFile);
// Store the filenames and update the title
if (true == bOk)
{
UpdateFilename(wchFile, wchFileTitle);
}
return bOk;
}
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::CreateRecoGuides
//
// Create recognizer guides for boxed and lined input.
// They are not required but recommended for getting
// better recognition results.
//
// Parameters: none
//
// Return Values (void):
// the result is not important - the application just
// won't use the guides if failed to create or initialize them
//
/////////////////////////////////////////////////////////
void CMultiRecoApp::CreateRecoGuides()
{
CComPtr<IInkRenderer> spIInkRenderer;
if ((m_spIInkCollector == NULL)
|| FAILED(m_spIInkCollector->get_Renderer(&spIInkRenderer)))
return;
HDC hdc = m_wndInput.GetDC();
if (NULL == hdc)
return;
// Initialize the recognizer guide data structure
_InkRecoGuide irg;
irg.midline = -1; // not use midline
irg.cRows = mc_iNumRowsCols;
irg.cColumns = mc_iNumRowsCols;
::SetRect(&irg.rectWritingBox, 0, 0, mc_iGuideColWidth, mc_iGuideRowHeight);
// Make the guide's DrawnBox a little smaller than the the actual area
// in which a user is expected to draw the ink (WritingBox)
irg.rectDrawnBox = irg.rectWritingBox;
::InflateRect(&irg.rectDrawnBox, -mc_cxBoxMargin, -mc_cyBoxMargin);
// Set the m_wndInput's guide data with screen coordinates
m_wndInput.SetGuide(irg);
// Use IInkRenderer to transform the guide boxes
// rectangles into ink space coordinates
// - the guide's writing box
if ( SUCCEEDED(spIInkRenderer->PixelToInkSpace((long)hdc,
&irg.rectWritingBox.left,
&irg.rectWritingBox.top))
&& SUCCEEDED(spIInkRenderer->PixelToInkSpace((long)hdc,
&irg.rectWritingBox.right,
&irg.rectWritingBox.bottom))
// and the drawn box
&& SUCCEEDED(spIInkRenderer->PixelToInkSpace((long)hdc,
&irg.rectDrawnBox.left,
&irg.rectDrawnBox.top))
&& SUCCEEDED(spIInkRenderer->PixelToInkSpace((long)hdc,
&irg.rectDrawnBox.right,
&irg.rectDrawnBox.bottom))
)
{
// Create the boxed guide
if (SUCCEEDED(m_spIInkRecoGuideBoxed.CoCreateInstance(CLSID_InkRecognizerGuide)))
{
// Initialize it
if (FAILED(m_spIInkRecoGuideBoxed->put_GuideData(irg)))
{
m_spIInkRecoGuideBoxed.Release();
}
}
// Create the lined guide
if (SUCCEEDED(m_spIInkRecoGuideLined.CoCreateInstance(CLSID_InkRecognizerGuide)))
{
// Initialize it
irg.cColumns = 0; // no columns, just rows
if (FAILED(m_spIInkRecoGuideLined->put_GuideData(irg)))
{
m_spIInkRecoGuideLined.Release();
}
}
}
// Clean up
ReleaseDC(hdc);
}
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::SaveStrokeCollection
//
// The method finalize the recognition of the current
// stroke collection and saves the best result with it.
// Then this stroke collection is added to the custom strokes
// collection of the ink object.
//
// Parameters:
// none
//
// Return Values (void):
// none - ignore any failures
//
/////////////////////////////////////////////////////////
void CMultiRecoApp::SaveStrokeCollection()
{
if (m_spIInkStrokes == NULL)
return;
long lCount = 0;
if (m_spIInkRecoContext != NULL)
{
if (SUCCEEDED(m_spIInkStrokes->get_Count(&lCount)) && 0 != lCount)
{
CComPtr<IInkRecognitionResult> spIInkRecoResult;
InkRecognitionStatus RecognitionStatus;
if (SUCCEEDED(m_spIInkRecoContext->Recognize(&RecognitionStatus, &spIInkRecoResult)) && (spIInkRecoResult != NULL))
{
if (SUCCEEDED(spIInkRecoResult->SetResultOnStrokes()))
{
CComBSTR bstr;
spIInkRecoResult->get_TopString(&bstr);
m_wndResults.UpdateString(bstr);
}
else
{
MessageBoxW(L"Unable to save recognition result "
L"in the stroke collection.",
gc_szAppName, MB_ICONERROR | MB_OK);
}
}
else
{
MessageBoxW(L"Recognition has failed. No results will be "
L"stored in the stroke collection.",
gc_szAppName, MB_ICONERROR | MB_OK);
}
}
// Detach the stroke collection from the old recognition context
m_spIInkRecoContext->putref_Strokes(NULL);
}
// Now add it to the ink's custom strokes collection
// Each item (stroke collection) of the custom strokes must be identified
// by a unique string. Here we generate a GUID for this.
if ((0 != lCount) && (m_spIInkCustomStrokes != NULL))
{
GUID guid;
WCHAR szGuid[40]; // format: "{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}"
if (SUCCEEDED(::CoCreateGuid(&guid))
&& (::StringFromGUID2(guid, szGuid, countof(szGuid)) != 0))
{
CComBSTR bstrGuid(szGuid);
if (FAILED(m_spIInkCustomStrokes->Add(bstrGuid, m_spIInkStrokes)))
{
MessageBoxW(L"Failed to add the strokes to the Ink object's "
L"custom stroke collection",
gc_szAppName, MB_ICONERROR | MB_OK);
}
}
else
{
MessageBoxW(L"Failed to create a unique string id for the stroke collection",
gc_szAppName, MB_ICONERROR | MB_OK);
}
// Use another color for the next collection
m_iColor++;
if (m_iColor >= countof(mc_crColors))
{
m_iColor= 0;
}
}
m_spIInkStrokes.Release();
}
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::CreateRecoContext
//
// As it follows from the name, this helper method, given
// a pointer to the recognizer, creates and initializes
// new recognition context.
//
// Parameters:
// IInkRecognizer* pIInkRecognizer
// : [in] the recognizer to create a context with
//
// Return Values (bool):
// true if succeeded creating new recognition context, false otherwise
//
/////////////////////////////////////////////////////////
bool CMultiRecoApp::CreateRecoContext(
IInkRecognizer* pIInkRecognizer
)
{
// Create a new recognition context
CComPtr<IInkRecognizerContext> spNewContext;
if (FAILED(pIInkRecognizer->CreateRecognizerContext(&spNewContext)))
return false;
// Replace the current context with the new one
if (m_spIInkRecoContext != NULL)
{
// Close the connection to the recognition events source
IInkRecognitionEventsImpl<CMultiRecoApp>::DispEventUnadvise(m_spIInkRecoContext);
}
m_spIInkRecoContext.Attach(spNewContext.Detach());
// Establish a connection with the recognition context's event source
if (FAILED(IInkRecognitionEventsImpl<CMultiRecoApp>::DispEventAdvise(m_spIInkRecoContext)))
{
MessageBoxW(L"Failed connect to the recognition context's event source.\n"
L"The input won't be recognized dynamically.",
gc_szAppName, MB_ICONERROR | MB_OK);
}
// Set the guide if it's supported by the recognizer and has been created
int cRows = 0, cColumns = 0;
bool fRequiresBoxGuide = false;
InkRecognizerCapabilities dwCapabilities = IRC_DontCare;
if (SUCCEEDED(pIInkRecognizer->get_Capabilities(&dwCapabilities)))
{
// Find out the language chosen. In the case of Japanese, Chinese and Korean we will
// create a box guide.
CComVariant vLanguages;
if (SUCCEEDED(pIInkRecognizer->get_Languages(&vLanguages)))
{
if ((VT_ARRAY == (VT_ARRAY & vLanguages.vt)) // it should be an array
&& (NULL != vLanguages.parray)
&& (0 < vLanguages.parray->rgsabound[0].cElements)) // with at least one element
{
ULONG ulSize = vLanguages.parray->rgsabound[0].cElements;
short *pbData;
if (SUCCEEDED(::SafeArrayAccessData(vLanguages.parray, (void**)&pbData)))
{
for(ULONG i = 0; i < ulSize; i++)
{
if ( 0x411 == pbData[i] || // Japanese
0x404 == pbData[i] || // Chinese
0x804 == pbData[i] || // Chinese
0x412 == pbData[i]) // Korean
{
fRequiresBoxGuide = true;
break;
}
}
::SafeArrayUnaccessData(vLanguages.parray);
}
}
}
// Try the boxed guide in case it is required
if (((IRC_BoxedInput & dwCapabilities) == IRC_BoxedInput)
&& (m_spIInkRecoGuideBoxed != NULL) && fRequiresBoxGuide)
{
HRESULT hr = m_spIInkRecoContext->putref_Guide(m_spIInkRecoGuideBoxed);
if (SUCCEEDED(hr))
{
cRows = cColumns = mc_iNumRowsCols;
}
}
// or the lined one
else if (((IRC_LinedInput & dwCapabilities) == IRC_LinedInput)
&& (m_spIInkRecoGuideLined != NULL))
{
if (SUCCEEDED(m_spIInkRecoContext->putref_Guide(m_spIInkRecoGuideLined)))
{
cRows = mc_iNumRowsCols;
}
}
}
// Update the input window
m_wndInput.SetRowsCols(cRows, cColumns);
return true;
}
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::CreateChildWindows
//
// This helper method is called from WM_CREATE message handler.
// The child windows and controls are created and initialized here.
//
// Parameters:
// none
//
// Return Values (bool):
// true if the windows have been created successfully,
// false otherwise
//
/////////////////////////////////////////////////////////
bool CMultiRecoApp::CreateChildWindows()
{
// Create windows for input and output
if ((m_wndResults.Create(m_hWnd, mc_iOutputWndId) == NULL)
|| (m_wndInput.Create(m_hWnd, CWindow::rcDefault, NULL,
WS_CHILD, WS_EX_CLIENTEDGE, (UINT)mc_iInputWndId) == NULL))
{
return false;
}
// Create a status bar (Ignore if it fails, the application can live without it).
m_hwndStatusBar = ::CreateStatusWindow(
WS_CHILD|WS_VISIBLE|WS_CLIPCHILDREN|WS_CLIPSIBLINGS|SBARS_SIZEGRIP,
NULL, m_hWnd, (UINT)mc_iStatusWndId);
if (NULL != m_hwndStatusBar)
{
// Set the status bar font
::SendMessage(m_hwndStatusBar,
WM_SETFONT,
(LPARAM)::GetStockObject(DEFAULT_GUI_FONT),
FALSE);
}
// Update the child windows' positions and sizes so that they cover
// entire client area of the main window.
UpdateLayout();
return true;
}
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::UpdateLayout
//
// This helper method is called when the size of the main
// window has been changed and the child windows' positions
// need to be updated so that they cover entire client area
// of the main window.
//
// Parameters:
// none
//
// Return Values (void):
// none
//
/////////////////////////////////////////////////////////
void CMultiRecoApp::UpdateLayout()
{
RECT rect;
GetClientRect(&rect);
// update the size and position of the status bar
if (::IsWindow(m_hwndStatusBar)
&& ((DWORD)::GetWindowLong(m_hwndStatusBar, GWL_STYLE) & WS_VISIBLE))
{
::SendMessage(m_hwndStatusBar, WM_SIZE, 0, 0);
RECT rectStatusBar;
::GetWindowRect(m_hwndStatusBar, &rectStatusBar);
if (rect.bottom > rectStatusBar.bottom - rectStatusBar.top)
{
rect.bottom -= rectStatusBar.bottom - rectStatusBar.top;
}
else
{
rect.bottom = 0;
}
}
// update the size and position of the output window
if (m_wndResults.IsWindow())
{
int cyResultsWnd = 100;
if (cyResultsWnd > rect.bottom)
{
cyResultsWnd = rect.bottom;
}
::SetWindowPos(m_wndResults.m_hWnd, NULL,
rect.left, rect.bottom - cyResultsWnd,
rect.right - rect.left, cyResultsWnd - rect.top,
SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
rect.bottom -= cyResultsWnd;
}
// update the size and position of the ink input window
if (::IsWindow(m_wndInput.m_hWnd))
{
::SetWindowPos(m_wndInput.m_hWnd, NULL,
rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top,
SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
}
}
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::UpdateStatusBar
//
// This helper function sets the name of the currently selected
// recognizer to appear on the application's status bar.
//
// Parameters:
// none
//
// Return Values (void):
// none
//
/////////////////////////////////////////////////////////
void CMultiRecoApp::UpdateStatusBar()
{
if (::IsWindow(m_hwndStatusBar))
{
::SendMessage(m_hwndStatusBar, SB_SETTEXTW, NULL, (LPARAM)m_bstrCurRecoName.m_str);
}
}
/////////////////////////////////////////////////////////
//
// CMultiRecoApp::UpdateFilename
//
// This helper function stores the new file name
// and update the window's caption
//
// Parameters:
// WCHAR pwsFile : the fule name of the opened file
// WCHAR pwsFileTitle : the name and extension of the file, without path
//
// Return Values (void):
// none
//
/////////////////////////////////////////////////////////
void CMultiRecoApp::UpdateFilename(
WCHAR* pwsFile,
WCHAR* pwsFileTitle
)
{
// The title that appears in the window's caption bar
CComBSTR bstrTitle;
if ((NULL != pwsFile) && (NULL != pwsFileTitle))
{
// Copy the strings
StringCchCopyNExW(m_wchFile, MAX_PATH, pwsFile, MAX_PATH, NULL, NULL, STRSAFE_NULL_ON_FAILURE);
StringCchCopyNExW(m_wchFileTitle, MAX_PATH, pwsFileTitle, MAX_PATH, NULL, NULL, STRSAFE_NULL_ON_FAILURE);
bstrTitle = m_wchFileTitle;
}
else
{
m_wchFile[0] = m_wchFileTitle[0] = 0;
bstrTitle = L"New File";
}
// The application's title is combined from the application name and
// the name of the currently open file
bstrTitle += L" - ";
bstrTitle += gc_szAppName;
// Update the window's caption
::SetWindowTextW(m_hWnd, bstrTitle);
}
Reference in New Issue View Git Blame Copy Permalink