//-----------------------------------------------------------------------------
// IEEnumChildProc()
//-----------------------------------------------------------------------------
// Enumération des fils de la fenêtre navigateur à la recherche
// de la barre d'adresse pour vérifier l'URL -> changé en 0.83, voir dans swSSOWeb.cpp
//-----------------------------------------------------------------------------
// [in] lp = &psz
//-----------------------------------------------------------------------------
static int CALLBACK IEEnumChildProc(HWND w, LPARAM lp)
{
UNREFERENCED_PARAMETER(lp);
int rc=true; // true=continuer l'énumération
char szClassName[128+1];
DWORD dw;
HRESULT hr;
IHTMLDocument2 *pHTMLDocument2=NULL;
BSTR bstrURL=NULL;
BSTR bstrState=NULL;
T_GETURL *ptGetURL=(T_GETURL *)lp;
// 0.85B6 : je supprime la comparaison du titre car ne fonctionne pas quand le titre est trop long !
// (exemple copaindavant -> titre fenêtre windows tronqué vs titre html entier, incomparable donc)
GetClassName(w,szClassName,sizeof(szClassName));
TRACE((TRACE_DEBUG,_F_,"w=0x%08lx class=%s",w,szClassName));
if (strcmp(szClassName,"Internet Explorer_Server")!=0) goto end;
// récupération pointeur sur le document HTML (interface IHTMLDocument2)
SendMessageTimeout(w,guiHTMLGetObjectMsg,0L,0L,SMTO_ABORTIFHUNG,1000,&dw);
hr=(*gpfObjectFromLresult)(dw,IID_IHTMLDocument2,0,(void**)&pHTMLDocument2);
if (FAILED(hr))
{
TRACE((TRACE_ERROR,_F_,"gpfObjectFromLresult(%d,IID_IHTMLDocument2)=0x%08lx",dw,hr));
goto end;
}
TRACE((TRACE_DEBUG,_F_,"gpfObjectFromLresult(IID_IHTMLDocument2)=%08lx pHTMLDocument2=%08lx",hr,pHTMLDocument2));
// 0.90 : ne commence pas tant que le document n'est pas chargé
// (uniquement dans le cas d'une simulation de frappe clavier ?)
// 0.97 : on ne le fait que si bWaitReady (et notamment on ne le fait pas dans le cas des popups cf. ISSUE#87)
if (ptGetURL->bWaitReady)
{
hr=pHTMLDocument2->get_readyState(&bstrState);
if (FAILED(hr))
{
TRACE((TRACE_ERROR,_F_,"get_readyState=0x%08lx",hr));
// ca n'a pas marché, pas grave, on continue quand même
}
else
{
TRACE((TRACE_INFO,_F_,"readyState=%S",bstrState));
if (!CompareBSTRtoSZ(bstrState,"complete")) { rc=false; goto end; } // pas fini de charger, on arrête
}
}
hr=pHTMLDocument2->get_URL(&bstrURL);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_URL()=0x%08lx",hr)); goto end; }
TRACE((TRACE_DEBUG,_F_,"get_URL()=%S",bstrURL));
ptGetURL->pszURL=(char*)malloc(SysStringLen(bstrURL)+1);
if (ptGetURL->pszURL==NULL) { TRACE((TRACE_ERROR,_F_,"malloc(%d)=NULL",SysStringLen(bstrURL)+1)); goto end; }
wsprintf(ptGetURL->pszURL,"%S",bstrURL);
rc=false; // trouvé l'URL, on arrete l'enum
end:
if (bstrState!=NULL) SysFreeString(bstrState);
if (pHTMLDocument2!=NULL) pHTMLDocument2->Release();
if (bstrURL!=NULL) SysFreeString(bstrURL);
return rc;
}
static HRESULT WINAPI MkProtocol_StartEx(IInternetProtocolEx *iface, IUri *pUri,
IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
DWORD grfPI, HANDLE *dwReserved)
{
MkProtocol *This = impl_from_IInternetProtocolEx(iface);
LPWSTR mime, progid, display_name, colon_ptr;
DWORD bindf=0, eaten=0, scheme=0, len;
BSTR url, path = NULL;
IParseDisplayName *pdn;
BINDINFO bindinfo;
STATSTG statstg;
IMoniker *mon;
HRESULT hres;
CLSID clsid;
TRACE("(%p)->(%p %p %p %08x %p)\n", This, pUri, pOIProtSink,
pOIBindInfo, grfPI, dwReserved);
hres = IUri_GetScheme(pUri, &scheme);
if(FAILED(hres))
return hres;
if(scheme != URL_SCHEME_MK)
return INET_E_INVALID_URL;
memset(&bindinfo, 0, sizeof(bindinfo));
bindinfo.cbSize = sizeof(BINDINFO);
hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &bindf, &bindinfo);
if(FAILED(hres)) {
WARN("GetBindInfo failed: %08x\n", hres);
return hres;
}
ReleaseBindInfo(&bindinfo);
IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_SENDINGREQUEST, NULL);
hres = IUri_GetDisplayUri(pUri, &url);
if(FAILED(hres))
return hres;
hres = FindMimeFromData(NULL, url, NULL, 0, NULL, 0, &mime, 0);
SysFreeString(url);
if(SUCCEEDED(hres)) {
IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, mime);
CoTaskMemFree(mime);
}
hres = IUri_GetPath(pUri, &path);
if(FAILED(hres))
return hres;
len = SysStringLen(path)+1;
hres = UrlUnescapeW(path, NULL, &len, URL_UNESCAPE_INPLACE);
if (FAILED(hres)) {
SysFreeString(path);
return report_result(pOIProtSink, INET_E_RESOURCE_NOT_FOUND, ERROR_INVALID_PARAMETER);
}
progid = path+1; /* skip '@' symbol */
colon_ptr = strchrW(path, ':');
if(!colon_ptr) {
SysFreeString(path);
return report_result(pOIProtSink, INET_E_RESOURCE_NOT_FOUND, ERROR_INVALID_PARAMETER);
}
len = strlenW(path);
display_name = heap_alloc((len+1)*sizeof(WCHAR));
memcpy(display_name, path, (len+1)*sizeof(WCHAR));
progid[colon_ptr-progid] = 0; /* overwrite ':' with NULL terminator */
hres = CLSIDFromProgID(progid, &clsid);
SysFreeString(path);
if(FAILED(hres))
{
heap_free(display_name);
return report_result(pOIProtSink, INET_E_RESOURCE_NOT_FOUND, ERROR_INVALID_PARAMETER);
}
hres = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
&IID_IParseDisplayName, (void**)&pdn);
if(FAILED(hres)) {
WARN("Could not create object %s\n", debugstr_guid(&clsid));
heap_free(display_name);
return report_result(pOIProtSink, hres, ERROR_INVALID_PARAMETER);
}
hres = IParseDisplayName_ParseDisplayName(pdn, NULL /* FIXME */, display_name, &eaten, &mon);
heap_free(display_name);
IParseDisplayName_Release(pdn);
if(FAILED(hres)) {
WARN("ParseDisplayName failed: %08x\n", hres);
return report_result(pOIProtSink, hres, ERROR_INVALID_PARAMETER);
}
if(This->stream) {
IStream_Release(This->stream);
This->stream = NULL;
}
hres = IMoniker_BindToStorage(mon, NULL /* FIXME */, NULL, &IID_IStream, (void**)&This->stream);
IMoniker_Release(mon);
if(FAILED(hres)) {
WARN("BindToStorage failed: %08x\n", hres);
return report_result(pOIProtSink, hres, ERROR_INVALID_PARAMETER);
}
hres = IStream_Stat(This->stream, &statstg, STATFLAG_NONAME);
if(FAILED(hres)) {
WARN("Stat failed: %08x\n", hres);
return report_result(pOIProtSink, hres, ERROR_INVALID_PARAMETER);
}
IInternetProtocolSink_ReportData(pOIProtSink,
BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION,
statstg.cbSize.u.LowPart, statstg.cbSize.u.LowPart);
return report_result(pOIProtSink, S_OK, ERROR_SUCCESS);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d X T R N I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method ReadXTRNImage reads a XTRN image file and returns it. It
% allocates the memory necessary for the new Image structure and returns a
% pointer to the new image.
%
% The format of the ReadXTRNImage method is:
%
% Image *ReadXTRNImage(const ImageInfo *image_info,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: Method ReadXTRNImage returns a pointer to the image after
% reading. A null image is returned if there is a memory shortage or
% if the image cannot be read.
%
% o image_info: Specifies a pointer to an ImageInfo structure.
%
% o exception: return any errors or warnings in this structure.
%
%
*/
static Image *ReadXTRNImage(const ImageInfo *image_info, ExceptionInfo *exception)
{
Image
*image;
ImageInfo
*clone_info;
void
*param1,
*param2,
*param3;
param1 = param2 = param3 = (void *) NULL;
image = (Image *) NULL;
clone_info=CloneImageInfo(image_info);
if (clone_info->filename == NULL)
{
DestroyImageInfo(clone_info);
ThrowReaderException(OptionError,MissingAnImageFilename,image);
}
/* DebugString("ReadXTRN CODER: %s\n",clone_info->filename); */
if (LocaleCompare(image_info->magick,"XTRNFILE") == 0)
{
image=ReadImage(clone_info,exception);
/* this should not be needed since the upstream code should catch any
excetpions thrown by ReadImage
*/
if (exception->severity != UndefinedException)
MagickWarning2(exception->severity,exception->reason,exception->description);
}
else if (LocaleCompare(image_info->magick,"XTRNIMAGE") == 0)
{
Image
**image_ptr;
#ifdef ALL_IMAGEINFO
ImageInfo
**image_info_ptr;
#endif
(void) sscanf(clone_info->filename,"%lx,%lx",¶m1,¶m2);
image_ptr=(Image **) param2;
if (*image_ptr != (Image *)NULL)
image=CloneImage(*image_ptr,0,0,False,&(*image_ptr)->exception);
#ifdef ALL_IMAGEINFO
image_info_ptr=(ImageInfo **) param1;
if (*image_info_ptr != (ImageInfo *)NULL)
image_info=*image_info_ptr;
#endif
}
else if (LocaleCompare(image_info->magick,"XTRNBLOB") == 0)
{
char
**blob_data;
size_t
*blob_length;
char
filename[MaxTextExtent];
(void) sscanf(clone_info->filename,"%lx,%lx,%s",¶m1,¶m2,&filename);
blob_data=(char **) param1;
blob_length=(size_t *) param2;
image=BlobToImage(clone_info,*blob_data,*blob_length,exception);
if (exception->severity != UndefinedException)
MagickWarning2(exception->severity,exception->reason,exception->description);
}
else if (LocaleCompare(image_info->magick,"XTRNARRAY") == 0)
{
SAFEARRAY
*pSafeArray;
char
*blob_data;
size_t
blob_length;
long
lBoundl,
lBoundu;
HRESULT
hr;
char
filename[MaxTextExtent];
filename[0] = '\0';
(void) sscanf(clone_info->filename,"%lx,%s",¶m1,&filename);
hr = S_OK;
pSafeArray = (SAFEARRAY *) param1;
if (pSafeArray)
{
hr = SafeArrayGetLBound(pSafeArray, 1, &lBoundl);
if (SUCCEEDED(hr))
hr = SafeArrayGetUBound(pSafeArray, 1, &lBoundu);
if (SUCCEEDED(hr))
{
blob_length = lBoundu - lBoundl + 1;
hr = SafeArrayAccessData(pSafeArray, (void**)&blob_data);
if(SUCCEEDED(hr))
{
if (filename[0] != '\0')
{
(void) strcpy(clone_info->filename, filename);
(void) strcpy(clone_info->magick, filename);
}
else
{
*clone_info->magick = '\0';
clone_info->filename[0] = '\0';
}
image=BlobToImage(clone_info,blob_data,blob_length,exception);
hr = SafeArrayUnaccessData(pSafeArray);
if (exception->severity != UndefinedException)
MagickWarning2(exception->severity,exception->reason,
exception->description);
}
}
}
}
else if (LocaleCompare(image_info->magick,"XTRNBSTR") == 0)
{
BSTR
bstr;
char
*blob_data;
size_t
blob_length;
HRESULT
hr;
char
filename[MaxTextExtent];
filename[0] = '\0';
(void) sscanf(clone_info->filename,"%lx,%s",¶m1,&filename);
hr = S_OK;
bstr = (BSTR) param1;
blob_length = SysStringLen(bstr) * 2;
blob_data = (char *)bstr;
/* DebugString("XTRN CODER: 0x%04lx (%ld)\n",(unsigned long)blob_data,blob_length); */
if ((blob_data != (char *)NULL) && (blob_length>0))
{
if (filename[0] != '\0')
{
(void) strcpy(clone_info->filename, filename);
(void) strcpy(clone_info->magick, filename);
}
else
{
*clone_info->magick = '\0';
clone_info->filename[0] = '\0';
}
image=BlobToImage(clone_info,blob_data,blob_length,exception);
if (exception->severity != UndefinedException)
MagickWarning2(exception->severity,exception->reason,
exception->description);
}
}
DestroyImageInfo(clone_info);
return(image);
}
static HRESULT BindStatusCallback_create(httprequest* This, BindStatusCallback **obj, const VARIANT *body)
{
BindStatusCallback *bsc;
IBindCtx *pbc;
HRESULT hr;
hr = CreateBindCtx(0, &pbc);
if (hr != S_OK) return hr;
bsc = heap_alloc(sizeof(*bsc));
if (!bsc)
{
IBindCtx_Release(pbc);
return E_OUTOFMEMORY;
}
bsc->lpBindStatusCallbackVtbl = &BindStatusCallbackVtbl;
bsc->lpHttpNegotiateVtbl = &BSCHttpNegotiateVtbl;
bsc->ref = 1;
bsc->request = This;
bsc->binding = NULL;
bsc->stream = NULL;
bsc->body = NULL;
TRACE("created callback %p\n", bsc);
if (This->verb != BINDVERB_GET)
{
if (V_VT(body) == VT_BSTR)
{
LONG size = SysStringLen(V_BSTR(body)) * sizeof(WCHAR);
void *ptr;
bsc->body = GlobalAlloc(GMEM_FIXED, size);
if (!bsc->body)
{
heap_free(bsc);
return E_OUTOFMEMORY;
}
ptr = GlobalLock(bsc->body);
memcpy(ptr, V_BSTR(body), size);
GlobalUnlock(bsc->body);
}
else
FIXME("unsupported body data type %d\n", V_VT(body));
}
hr = RegisterBindStatusCallback(pbc, (IBindStatusCallback*)bsc, NULL, 0);
if (hr == S_OK)
{
IMoniker *moniker;
hr = CreateURLMoniker(NULL, This->url, &moniker);
if (hr == S_OK)
{
IStream *stream;
hr = IMoniker_BindToStorage(moniker, pbc, NULL, &IID_IStream, (void**)&stream);
IMoniker_Release(moniker);
if (stream) IStream_Release(stream);
}
IBindCtx_Release(pbc);
}
if (FAILED(hr))
{
IBindStatusCallback_Release((IBindStatusCallback*)bsc);
bsc = NULL;
}
*obj = bsc;
return hr;
}
/**
* Gets the switch port info from WMI (switch port friendly name, ifSpeed)
* and merges into the list of existing ports.
*/
void readWMISwitchPorts(HSP *sp)
{
myLog(LOG_INFO, "entering readWMISwitchPorts");
BSTR path = SysAllocString(WMI_VIRTUALIZATION_NS_V2);
HRESULT hr = S_FALSE;
IWbemServices *pNamespace = NULL;
hr = connectToWMI(path, &pNamespace);
if (FAILED(hr)) {
//only try the v2 namespace since this will only be present
//with the extensible switch that supports sampling.
//don't try to get counters if there is no sampling.
SysFreeString(path);
myLog(LOG_INFO, "readWMISwitchPorts: virtualization namespace v2 not found");
return;
} else {
SysFreeString(path);
}
BSTR queryLang = SysAllocString(L"WQL");
BSTR query = SysAllocString(L"SELECT * FROM Msvm_EthernetSwitchPort");
IEnumWbemClassObject *switchPortEnum = NULL;
hr = pNamespace->ExecQuery(queryLang, query, WBEM_FLAG_FORWARD_ONLY, NULL, &switchPortEnum);
SysFreeString(queryLang);
SysFreeString(query);
if (FAILED(hr)) {
myLog(LOG_ERR,"readWMISwitchPorts: ExecQuery() failed for query %S error=0x%x", query, hr);
CoUninitialize();
return;
}
if (sp->vAdaptorList == NULL) {
sp->vAdaptorList = adaptorListNew();
}
IWbemClassObject *switchPortObj = NULL;
BSTR propElementName = SysAllocString(L"ElementName");
BSTR propSystemName = SysAllocString(L"SystemName");
BSTR propName = SysAllocString(L"Name");
BSTR propSpeed = SysAllocString(L"Speed");
//could also get ifDirection but FullDuplex=True always
VARIANT systemVal;
VARIANT elementVal;
VARIANT nameVal;
VARIANT speedVal;
hr = WBEM_S_NO_ERROR;
while (WBEM_S_NO_ERROR == hr) {
SFLAdaptor *vAdaptor = NULL;
ULONG uReturned = 1;
hr = switchPortEnum->Next(WBEM_INFINITE, 1, &switchPortObj, &uReturned);
if (0 == uReturned) {
break;
}
HRESULT portHr;
portHr = switchPortObj->Get(propName, 0, &nameVal, 0, 0);
char portGuid[FORMATTED_GUID_LEN+1];
guidToString(nameVal.bstrVal, (UCHAR *)portGuid, FORMATTED_GUID_LEN);
myLog(LOG_INFO, "readWMISwitchPorts: portGuid=%s", portGuid);
VariantClear(&nameVal);
vAdaptor = adaptorListGet(sp->vAdaptorList, portGuid);
if (vAdaptor != NULL) {
portHr = switchPortObj->Get(propSystemName, 0, &systemVal, 0, 0);
portHr = switchPortObj->Get(propElementName, 0, &elementVal, 0, 0);
portHr = switchPortObj->Get(propSpeed, 0, &speedVal, 0, 0);
int length = SysStringLen(systemVal.bstrVal)+1; //include room for terminating null
wchar_t *switchName = (wchar_t *)my_calloc(length*sizeof(wchar_t));
wcscpy_s(switchName, length, systemVal.bstrVal);
length = SysStringLen(elementVal.bstrVal)+1;
wchar_t *friendlyName = (wchar_t *)my_calloc(length*sizeof(wchar_t));
wcscpy_s(friendlyName, length, elementVal.bstrVal);
ULONGLONG ifSpeed = _wcstoui64(speedVal.bstrVal, NULL, 10);
VariantClear(&systemVal);
VariantClear(&elementVal);
VariantClear(&speedVal);
HVSVPortInfo *portInfo = (HVSVPortInfo *)vAdaptor->userData;
if (portInfo->switchName != NULL) {
my_free(portInfo->switchName);
}
portInfo->switchName = switchName;
if (portInfo->portFriendlyName != NULL) {
my_free(portInfo->portFriendlyName);
}
portInfo->portFriendlyName = friendlyName;
setPortCountersInstance(vAdaptor);
vAdaptor->ifSpeed = ifSpeed;
//Get the MACs and VM system name when we enumerate the vms.
myLog(LOG_INFO,
"readWMISwitchPorts: updated switch port %s %S portId=%u ifIndex=%u ifSpeed=%llu counterName=%S",
vAdaptor->deviceName, portInfo->portFriendlyName, portInfo->portId, vAdaptor->ifIndex,
vAdaptor->ifSpeed, portInfo->portCountersInstance);
} else {
myLog(LOG_INFO, "readWMISwitchPorts: vAdapter not found");
}
switchPortObj->Release();
}
switchPortEnum->Release();
pNamespace->Release();
CoUninitialize();
SysFreeString(propElementName);
SysFreeString(propSystemName);
SysFreeString(propName);
SysFreeString(propSpeed);
return;
}
static HRESULT WINAPI RegExp2_Execute(IRegExp2 *iface,
BSTR sourceString, IDispatch **ppMatches)
{
RegExp2 *This = impl_from_IRegExp2(iface);
match_state_t *result;
const WCHAR *pos;
IMatchCollection2 *match_collection;
IMatch2 *add = NULL;
HRESULT hres;
TRACE("(%p)->(%s %p)\n", This, debugstr_w(sourceString), ppMatches);
if(!This->pattern) {
DWORD i, len = SysStringLen(sourceString);
hres = create_match_collection2(&match_collection);
if(FAILED(hres))
return hres;
for(i=0; i<=len; i++) {
hres = create_match2(i, NULL, &add);
if(FAILED(hres))
break;
hres = add_match(match_collection, add);
if(FAILED(hres))
break;
IMatch2_Release(add);
if(!(This->flags & REG_GLOB))
break;
}
if(FAILED(hres)) {
IMatchCollection2_Release(match_collection);
return hres;
}
*ppMatches = (IDispatch*)match_collection;
return S_OK;
}
if(!This->regexp) {
This->regexp = regexp_new(NULL, &This->pool, This->pattern,
strlenW(This->pattern), This->flags, FALSE);
if(!This->regexp)
return E_FAIL;
} else {
hres = regexp_set_flags(&This->regexp, NULL, &This->pool, This->flags);
if(FAILED(hres))
return hres;
}
hres = create_match_collection2(&match_collection);
if(FAILED(hres))
return hres;
pos = sourceString;
while(1) {
result = alloc_match_state(This->regexp, NULL, pos);
if(!result) {
hres = E_OUTOFMEMORY;
break;
}
hres = regexp_execute(This->regexp, NULL, &This->pool,
sourceString, SysStringLen(sourceString), result);
if(hres != S_OK) {
heap_free(result);
break;
}
pos = result->cp;
hres = create_match2(result->cp-result->match_len-sourceString, &result, &add);
heap_free(result);
if(FAILED(hres))
break;
hres = add_match(match_collection, add);
IMatch2_Release(add);
if(FAILED(hres))
break;
if(!(This->flags & REG_GLOB))
break;
}
if(FAILED(hres)) {
IMatchCollection2_Release(match_collection);
return hres;
}
*ppMatches = (IDispatch*)match_collection;
return S_OK;
}
BOOL getWordByAccEx( POINT pt )
{
HRESULT hr;
IAccessible *pAcc, *pAccParent;
ITextProvider *pText;
ITextRangeProvider *pTextRange;
VARIANT var;
long idChild;
BSTR bstr = NULL;
int n;
UiaPoint upt;
POINT ppt = { 0, 0 };
if( getPhysicalCursorPosFunc != NULL ) {
getPhysicalCursorPosFunc( &ppt );
} else {
ppt = pt;
}
upt.x = ppt.x;
upt.y = ppt.y;
pAcc = NULL;
hr = AccessibleObjectFromPoint( ppt, &pAcc, &var );
idChild = var.lVal;
if( hr != S_OK || pAcc == NULL) {
VariantClear( &var );
return FALSE;
}
pText = NULL;
while( pAcc != NULL) {
hr = GetPatternFromIAccessible( pAcc, 0, UIA_TextPatternId, &IID_ITextProvider, (void **)&pText );
if( hr == S_OK && pText != NULL )
break;
pAccParent = NULL;
hr = GetParentAccessibleObject( pAcc, &pAccParent );
pAcc->lpVtbl->Release( pAcc );
pAcc = pAccParent;
}
if( pAcc == NULL )
return FALSE;
pAcc->lpVtbl->Release( pAcc );
pTextRange = NULL;
hr = pText->lpVtbl->RangeFromPoint( pText, upt, &pTextRange );
if( hr != S_OK || pTextRange == NULL ) {
pText->lpVtbl->Release( pText );
return FALSE;
}
hr = pTextRange->lpVtbl->ExpandToEnclosingUnit( pTextRange, TextUnit_Word );
if( hr == S_OK) {
bstr = NULL;
hr = pTextRange->lpVtbl->GetText( pTextRange, 255, &bstr );
if (hr == S_OK) {
n = SysStringLen( bstr );
if( n != 0 ) {
n = WideCharToMultiByte( CP_UTF8, 0, (LPCWSTR)bstr, n, GlobalData->CurMod.MatchedWord, sizeof( GlobalData->CurMod.MatchedWord ) - 1, NULL, NULL );
GlobalData->CurMod.WordLen = n;
GlobalData->CurMod.MatchedWord[n] = 0;
}
SysFreeString( bstr );
}
}
pTextRange->lpVtbl->Release( pTextRange );
pText->lpVtbl->Release( pText );
return TRUE;
}
// Private Functions
string Audio::ConvertBSTRToMBS(BSTR bstr)
{
int wslen = SysStringLen(bstr);
return ConvertWCSToMBS((wchar_t*)bstr, wslen);
}
HRESULT CFormattedTextDraw::get_RTFText(BSTR *pVal)
{
*pVal = SysAllocStringLen(m_RTFText, SysStringLen(m_RTFText));
return S_OK;
}
