able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/enduser/netmeeting/ui/msconf/clcnflnk.cpp

1020 lines
21 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
// File: conflnk.cpp
#include "precomp.h"
#include <shellapi.h>
#include <shlstock.h>
#include <ConfDir.h>
#include <ConfCli.h>
#include "clCnfLnk.hpp"
#include "resource.h"
#include "atlbase.h"
#include "confevt.h"
#include "sdkInternal.h"
#include "nameres.h"
/////////////////////////////////////////////////////////////////////
// Initialize GUIDs
//
#pragma data_seg(".text")
#define INITGUID
#include <initguid.h>
#include "CLinkId.h"
// from shlguid.h - must keep in sync
DEFINE_SHLGUID(CLSID_ShellLink, 0x00021401L, 0, 0);
#ifndef _UNICODE
DEFINE_SHLGUID(IID_IShellLink, 0x000214EEL, 0, 0);
DEFINE_SHLGUID(IID_IShellExtInit, 0x000214E8L, 0, 0);
DEFINE_SHLGUID(IID_IShellPropSheetExt, 0x000214E9L, 0, 0);
#endif // _UNICODE
#undef INITGUID
#pragma data_seg()
/////////////////////////////////////////////////////////////////////
#ifdef DEBUG
BOOL IsValidPCConfLink(PCCConfLink pcConfLink)
{
return(
IS_VALID_READ_PTR(pcConfLink, CConfLink) &&
FLAGS_ARE_VALID(pcConfLink->m_dwFlags, ALL_CONFLNK_FLAGS) &&
(! pcConfLink->m_pszFile ||
IS_VALID_STRING_PTR(pcConfLink->m_pszFile, STR)) &&
(! pcConfLink->m_pszName ||
IS_VALID_STRING_PTR(pcConfLink->m_pszName, STR)) &&
IS_VALID_STRUCT_PTR((PCRefCount)pcConfLink, CRefCount) &&
IS_VALID_INTERFACE_PTR((PCIDataObject)pcConfLink, IDataObject) &&
IS_VALID_INTERFACE_PTR((PCIPersistFile)pcConfLink, IPersistFile) &&
IS_VALID_INTERFACE_PTR((PCIPersistStream)pcConfLink, IPersistStream) &&
IS_VALID_INTERFACE_PTR((PCIShellExtInit)pcConfLink, IShellExtInit) &&
IS_VALID_INTERFACE_PTR((PCIShellPropSheetExt)pcConfLink, IShellPropSheetExt) &&
IS_VALID_INTERFACE_PTR((PCIConferenceLink)pcConfLink, IConferenceLink));
}
#endif /* DEBUG */
CConfLink::CConfLink(OBJECTDESTROYEDPROC ObjectDestroyed) :
RefCount (ObjectDestroyed),
m_dwFlags (0),
m_dwCallFlags (0),
m_dwTransport (0),
m_pszFile (NULL),
m_pszName (NULL),
m_pszRemoteConfName (NULL),
m_pszAddress (NULL)
{
DebugEntry(CConfLink::CConfLink);
// Don't validate this until after construction.
ASSERT( !ObjectDestroyed ||
IS_VALID_CODE_PTR(ObjectDestroyed, OBJECTDESTROYEDPROC));
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
DebugExitVOID(CConfLink::CConfLink);
return;
}
CConfLink::~CConfLink(void)
{
DebugEntry(CConfLink::~CConfLink);
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
delete m_pszFile;
m_pszFile = NULL;
delete m_pszName;
m_pszName = NULL;
delete m_pszAddress;
m_pszAddress = NULL;
delete m_pszRemoteConfName;
m_pszRemoteConfName = NULL;
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
DebugExitVOID(CConfLink::~CConfLink);
return;
}
HRESULT STDMETHODCALLTYPE CConfLink::SetAddress(PCSTR pcszAddress)
{
HRESULT hr;
PSTR pszNewAddress = NULL;
DebugEntry(CConfLink::SetAddress);
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ASSERT( !pcszAddress ||
IS_VALID_STRING_PTR(pcszAddress, CSTR));
pszNewAddress = new char[lstrlen(pcszAddress) + 1];
if (NULL != pszNewAddress)
{
lstrcpy(pszNewAddress, pcszAddress);
hr = S_OK;
}
else
{
hr = E_OUTOFMEMORY;
}
if (S_OK == hr)
{
if (NULL != m_pszAddress)
{
delete m_pszAddress;
}
m_pszAddress = pszNewAddress;
Dirty(TRUE);
TRACE_OUT(("CConfLink::SetAddress(): Set Address to %s.",
CHECK_STRING(m_pszAddress)));
}
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ASSERT( hr == S_OK ||
hr == E_OUTOFMEMORY);
DebugExitHRESULT(CConfLink::SetAddress, hr);
return(hr);
}
HRESULT STDMETHODCALLTYPE CConfLink::GetAddress(PSTR *ppszAddress)
{
HRESULT hr;
DebugEntry(CConfLink::GetAddress);
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ASSERT(IS_VALID_WRITE_PTR(ppszAddress, PSTR));
*ppszAddress = NULL;
if (NULL != m_pszAddress)
{
*ppszAddress = NULL;
LPMALLOC pMalloc;
if (SUCCEEDED(SHGetMalloc(&pMalloc)))
{
// (+ 1) for null terminator.
*ppszAddress = (PSTR) pMalloc->Alloc(lstrlen(m_pszAddress) + 1);
pMalloc->Release();
pMalloc = NULL;
}
if (NULL != *ppszAddress)
{
lstrcpy(*ppszAddress, m_pszAddress);
hr = S_OK;
TRACE_OUT(("CConfLink::GetAddress(): Got Address %s.", *ppszAddress));
}
else
{
hr = E_OUTOFMEMORY;
}
}
else
{
// No Name.
hr = S_FALSE;
}
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ASSERT( (hr == S_OK &&
IS_VALID_STRING_PTR(*ppszAddress, STR)) ||
(( hr == S_FALSE ||
hr == E_OUTOFMEMORY) &&
! *ppszAddress));
DebugExitHRESULT(CConfLink::GetAddress, hr);
return(hr);
}
HRESULT STDMETHODCALLTYPE CConfLink::SetRemoteConfName(PCSTR pcszRemoteConfName)
{
HRESULT hr;
DebugEntry(CConfLink::SetRemoteConfName);
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ASSERT( !pcszRemoteConfName ||
IS_VALID_STRING_PTR(pcszRemoteConfName, CSTR));
PSTR pszNewRemoteConfName = new char[lstrlen(pcszRemoteConfName) + 1];
if (NULL != pszNewRemoteConfName)
{
lstrcpy(pszNewRemoteConfName, pcszRemoteConfName);
hr = S_OK;
}
else
{
hr = E_OUTOFMEMORY;
}
if (S_OK == hr)
{
if (NULL != m_pszRemoteConfName)
{
delete m_pszRemoteConfName;
}
m_pszRemoteConfName = pszNewRemoteConfName;
Dirty(TRUE);
TRACE_OUT(("CConfLink::SetRemoteConfName(): Set RemoteConfName to %s.",
CHECK_STRING(m_pszRemoteConfName)));
}
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ASSERT( hr == S_OK ||
hr == E_OUTOFMEMORY);
DebugExitHRESULT(CConfLink::SetRemoteConfName, hr);
return(hr);
}
HRESULT STDMETHODCALLTYPE CConfLink::GetRemoteConfName(PSTR *ppszRemoteConfName)
{
HRESULT hr;
DebugEntry(CConfLink::GetRemoteConfName);
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ASSERT(IS_VALID_WRITE_PTR(ppszRemoteConfName, PSTR));
*ppszRemoteConfName = NULL;
if (NULL != m_pszRemoteConfName)
{
*ppszRemoteConfName = NULL;
LPMALLOC pMalloc;
if (SUCCEEDED(SHGetMalloc(&pMalloc)))
{
// (+ 1) for null terminator.
*ppszRemoteConfName = (PSTR) pMalloc->Alloc(lstrlen(m_pszRemoteConfName) + 1);
pMalloc->Release();
pMalloc = NULL;
}
if (NULL != *ppszRemoteConfName)
{
lstrcpy(*ppszRemoteConfName, m_pszRemoteConfName);
hr = S_OK;
TRACE_OUT(("CConfLink::GetRemoteConfName(): Got RemoteConfName %s.",
*ppszRemoteConfName));
}
else
{
hr = E_OUTOFMEMORY;
}
}
else
{
// No Name.
hr = S_FALSE;
}
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ASSERT( (hr == S_OK &&
IS_VALID_STRING_PTR(*ppszRemoteConfName, STR)) ||
(( hr == S_FALSE ||
hr == E_OUTOFMEMORY) &&
! *ppszRemoteConfName));
DebugExitHRESULT(CConfLink::GetRemoteConfName, hr);
return(hr);
}
HRESULT STDMETHODCALLTYPE CConfLink::SetName(PCSTR pcszName)
{
HRESULT hr;
BOOL bChanged;
PSTR pszNewName = NULL;
DebugEntry(CConfLink::SetName);
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ASSERT( !pcszName ||
IS_VALID_STRING_PTR(pcszName, CSTR));
bChanged = ! ((! pcszName && ! m_pszName) ||
(pcszName && m_pszName &&
! lstrcmp(pcszName, m_pszName)));
if (bChanged && pcszName)
{
pszNewName = new(char[lstrlen(pcszName) + 1]);
if (pszNewName)
{
lstrcpy(pszNewName, pcszName);
hr = S_OK;
}
else
{
hr = E_OUTOFMEMORY;
}
}
else
{
hr = S_OK;
}
if (hr == S_OK)
{
if (bChanged)
{
if (m_pszName)
{
delete m_pszName;
}
m_pszName = pszNewName;
Dirty(TRUE);
TRACE_OUT(("CConfLink::SetName(): Set Name to %s.",
CHECK_STRING(m_pszName)));
}
else
{
TRACE_OUT(("CConfLink::SetName(): Name already %s.",
CHECK_STRING(m_pszName)));
}
}
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ASSERT( hr == S_OK ||
hr == E_OUTOFMEMORY);
DebugExitHRESULT(CConfLink::SetName, hr);
return(hr);
}
HRESULT STDMETHODCALLTYPE CConfLink::GetName(PSTR *ppszName)
{
HRESULT hr;
DebugEntry(CConfLink::GetName);
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ASSERT(IS_VALID_WRITE_PTR(ppszName, PSTR));
*ppszName = NULL;
if (m_pszName)
{
*ppszName = NULL;
LPMALLOC pMalloc;
if (SUCCEEDED(SHGetMalloc(&pMalloc)))
{
// (+ 1) for null terminator.
*ppszName = (PSTR) pMalloc->Alloc(lstrlen(m_pszName) + 1);
pMalloc->Release();
pMalloc = NULL;
}
// ChrisPi: I changed this to use the above implementation because
// SHAlloc is not available in the sdk shell32.lib
// *ppszName = (PSTR)SHAlloc(lstrlen(m_pszURL) + 1);
if (*ppszName)
{
lstrcpy(*ppszName, m_pszName);
hr = S_OK;
TRACE_OUT(("CConfLink::GetName(): Got Name %s.", *ppszName));
}
else
{
hr = E_OUTOFMEMORY;
}
}
else
{
// No Name.
hr = S_FALSE;
}
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ASSERT( (hr == S_OK &&
IS_VALID_STRING_PTR(*ppszName, STR)) ||
(( hr == S_FALSE ||
hr == E_OUTOFMEMORY) &&
! *ppszName));
DebugExitHRESULT(CConfLink::GetName, hr);
return(hr);
}
HRESULT STDMETHODCALLTYPE CConfLink::SetTransport(DWORD dwTransport)
{
HRESULT hr;
DebugEntry(CConfLink::SetTransport);
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
m_dwTransport = dwTransport;
Dirty(TRUE);
TRACE_OUT(("CConfLink::SetTransport(): Set Transport to %#8x.",
m_dwTransport));
hr = S_OK;
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
DebugExitHRESULT(CConfLink::SetTransport, hr);
return(hr);
}
HRESULT STDMETHODCALLTYPE CConfLink::GetTransport(DWORD *pdwTransport)
{
HRESULT hr;
DebugEntry(CConfLink::GetTransport);
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ASSERT(IS_VALID_WRITE_PTR(pdwTransport, PDWORD));
*pdwTransport = m_dwTransport;
hr = S_OK;
TRACE_OUT(("CConfLink::GetTransport(): Got Transport %#8x.",
*pdwTransport));
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
DebugExitHRESULT(CConfLink::GetTransport, hr);
return(hr);
}
HRESULT STDMETHODCALLTYPE CConfLink::SetCallFlags(DWORD dwCallFlags)
{
HRESULT hr;
DebugEntry(CConfLink::SetCallFlags);
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
m_dwCallFlags = dwCallFlags;
Dirty(TRUE);
TRACE_OUT(("CConfLink::SetCallFlags(): Set CallFlags to %#8x.",
m_dwCallFlags));
hr = S_OK;
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
DebugExitHRESULT(CConfLink::SetCallFlags, hr);
return(hr);
}
HRESULT STDMETHODCALLTYPE CConfLink::GetCallFlags(DWORD *pdwCallFlags)
{
HRESULT hr;
DebugEntry(CConfLink::GetCallFlags);
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ASSERT(IS_VALID_WRITE_PTR(pdwCallFlags, PDWORD));
*pdwCallFlags = m_dwCallFlags;
hr = S_OK;
TRACE_OUT(("CConfLink::GetCallFlags(): Got CallFlags %#8x.",
*pdwCallFlags));
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
DebugExitHRESULT(CConfLink::GetCallFlags, hr);
return(hr);
}
#define STR_CALLTO _T("callto:")
#define STR_CONFERENCE _T("+conference=")
#define STR_GATEWAY _T("+gateway=")
#define STR_SECURE _T("+secure=true")
#define STR_PHONE _T("+type=phone")
#define STR_NO_AV _T("+av=false")
#define STR_NO_DATA _T("+data=false")
//--------------------------------------------------------------------------//
// CConfLink::InvokeCommand. //
//--------------------------------------------------------------------------//
HRESULT
STDMETHODCALLTYPE
CConfLink::InvokeCommand
(
PCLINVOKECOMMANDINFO pclici
){
DebugEntry( CConfLink::InvokeCommand );
ASSERT( IS_VALID_STRUCT_PTR( this, CConfLink ) );
ASSERT( IS_VALID_STRUCT_PTR( pclici, CCLINVOKECOMMANDINFO ) );
HRESULT result = E_INVALIDARG;
if(m_pszAddress)
{
if( m_dwTransport == NAMETYPE_CALLTO )
{
result = shellCallto( m_pszAddress, IS_FLAG_SET( pclici->dwFlags, ICL_INVOKECOMMAND_FL_ALLOW_UI ) );
}
else
{
long lMax = lstrlen(STR_CALLTO) +
lstrlen(STR_CONFERENCE) +
lstrlen(STR_GATEWAY) +
lstrlen(STR_PHONE) +
lstrlen(STR_SECURE) +
lstrlen(STR_NO_AV) +
lstrlen(STR_NO_DATA) +
lstrlen(m_pszAddress) +
(m_pszRemoteConfName ? lstrlen(m_pszRemoteConfName) : 0) +
1;
LPTSTR url = (TCHAR*) _alloca(lMax);
lstrcpy( url, STR_CALLTO );
if( m_dwTransport != NAMETYPE_H323GTWY )
{
lstrcat( url, m_pszAddress );
}
else
{
TCHAR * const pSlash = (TCHAR * const) _StrChr( m_pszAddress, '/' );
if( pSlash != NULL )
{
*pSlash = '\0';
lstrcat( url, pSlash + 1 );
lstrcat( url, STR_GATEWAY );
}
lstrcat( url, m_pszAddress );
lstrcat( url, STR_PHONE );
}
if( m_pszRemoteConfName != NULL )
{
lstrcat( url, STR_CONFERENCE );
lstrcat( url, m_pszRemoteConfName );
}
if( IS_FLAG_SET( m_dwCallFlags, CRPCF_SECURE ) )
{
lstrcat( url, STR_SECURE );
}
if( IS_FLAG_CLEAR( m_dwCallFlags, (CRPCF_AUDIO | CRPCF_VIDEO) ) )
{
lstrcat( url, STR_NO_AV );
}
if( IS_FLAG_CLEAR( m_dwCallFlags, CRPCF_DATA) )
{
lstrcat( url, STR_NO_DATA );
}
result = shellCallto( url, IS_FLAG_SET( pclici->dwFlags, ICL_INVOKECOMMAND_FL_ALLOW_UI ) );
}
ASSERT( IS_VALID_STRUCT_PTR( this, CConfLink ) );
DebugExitHRESULT( CConfLink::InvokeCommand, result );
}
return( result );
} // End of CConfLink::InvokeCommand.
//--------------------------------------------------------------------------//
// shellCallto. //
//--------------------------------------------------------------------------//
HRESULT
shellCallto
(
const TCHAR * const url,
const bool notifyOnError
){
ASSERT( url != NULL );
ASSERT( url[ 0 ] != '\0' );
TRACE_OUT( ("shellCallto: url:\"%s\"", url) );
HRESULT result;
if( url == NULL )
{
result = E_POINTER;
}
else if( url[ 0 ] == '\0' )
{
result = E_INVALIDARG;
}
else
{
result = ::CoInitializeEx( NULL, COINIT_APARTMENTTHREADED );
if( SUCCEEDED( result ) )
{
IInternalConfExe * internalConf;
HRESULT result;
result = CoCreateInstance( CLSID_NmManager, NULL, CLSCTX_ALL, IID_IInternalConfExe, (LPVOID *) &internalConf );
if( SUCCEEDED( result ) && (internalConf != NULL) )
{
result = internalConf->ShellCalltoProtocolHandler( CComBSTR( url ), FALSE );
internalConf->Release();
}
::CoUninitialize();
}
if( FAILED( result ) && notifyOnError )
{
TCHAR message[ MAX_PATH ];
TCHAR title[ MAX_PATH ];
::LoadString( g_hInst, // handle to module containing string resource
IDS_COULD_NOT_CALL, // resource identifier
message, // pointer to buffer for resource
ARRAY_ELEMENTS( message ) ); // size of buffer
::LoadString( g_hInst, // handle to module containing string resource
IDS_LAUNCH_ERROR, // resource identifier
title, // pointer to buffer for resource
ARRAY_ELEMENTS( title ) ); // size of buffer
::MessageBox( NULL, message, title, MB_ICONERROR | MB_OK );
}
}
return( result );
} // End of shellCallto.
ULONG STDMETHODCALLTYPE CConfLink::AddRef(void)
{
ULONG ulcRef;
DebugEntry(CConfLink::AddRef);
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ulcRef = RefCount::AddRef();
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
DebugExitULONG(CConfLink::AddRef, ulcRef);
return(ulcRef);
}
ULONG STDMETHODCALLTYPE CConfLink::Release(void)
{
ULONG ulcRef;
DebugEntry(CConfLink::Release);
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ulcRef = RefCount::Release();
DebugExitULONG(CConfLink::Release, ulcRef);
return(ulcRef);
}
HRESULT STDMETHODCALLTYPE CConfLink::QueryInterface(REFIID riid,
PVOID *ppvObject)
{
HRESULT hr = S_OK;
DebugEntry(CConfLink::QueryInterface);
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
ASSERT(IsValidREFIID(riid));
ASSERT(IS_VALID_WRITE_PTR(ppvObject, PVOID));
if (riid == IID_IDataObject)
{
*ppvObject = (PIDataObject)this;
TRACE_OUT(("CConfLink::QueryInterface(): Returning IDataObject."));
}
#if 0 // These are currently unsupported interfaces:
else if (riid == IID_IExtractIcon)
{
*ppvObject = NULL;
hr = E_NOINTERFACE;
// *ppvObject = (PIExtractIcon)this;
TRACE_OUT(("CConfLink::QueryInterface(): NOT Returning IExtractIcon!"));
}
else if (riid == IID_INewShortcutHook)
{
*ppvObject = NULL;
hr = E_NOINTERFACE;
// *ppvObject = (PINewShortcutHook)this;
TRACE_OUT(("CConfLink::QueryInterface(): NOT Returning INewShortcutHook!"));
}
else if (riid == IID_IShellExecuteHook)
{
*ppvObject = NULL;
hr = E_NOINTERFACE;
// *ppvObject = (PIShellExecuteHook)this;
TRACE_OUT(("CConfLink::QueryInterface(): NOT Returning IShellExecuteHook!"));
}
else if (riid == IID_IShellLink)
{
*ppvObject = NULL;
hr = E_NOINTERFACE;
// *ppvObject = (PIShellLink)this;
TRACE_OUT(("CConfLink::QueryInterface(): NOT Returning IShellLink!"));
}
#endif /* DEBUG */
// Supported interfaces:
else if (riid == IID_IShellExtInit)
{
*ppvObject = (PIShellExtInit)this;
TRACE_OUT(("CConfLink::QueryInterface(): Returning IShellExtInit."));
}
else if (riid == IID_IShellPropSheetExt)
{
*ppvObject = (PIShellPropSheetExt)this;
TRACE_OUT(("CConfLink::QueryInterface(): Returning IShellPropSheetExt."));
}
else if (riid == IID_IPersist)
{
*ppvObject = (PIPersist)(PIPersistStream)this;
TRACE_OUT(("CConfLink::QueryInterface(): Returning IPersist."));
}
else if (riid == IID_IPersistFile)
{
*ppvObject = (PIPersistFile)this;
TRACE_OUT(("CConfLink::QueryInterface(): Returning IPersistFile."));
}
else if (riid == IID_IPersistStream)
{
*ppvObject = (PIPersistStream)this;
TRACE_OUT(("CConfLink::QueryInterface(): Returning IPersistStream."));
}
else if (riid == IID_IConferenceLink)
{
*ppvObject = (PIConferenceLink)this;
TRACE_OUT(("CConfLink::QueryInterface(): Returning IConferenceLink."));
}
else if (riid == IID_IUnknown)
{
*ppvObject = (PIUnknown) (PIConferenceLink) this;
TRACE_OUT(("CConfLink::QueryInterface(): Returning IUnknown."));
}
else
{
TRACE_OUT(("CConfLink::QueryInterface(): Called on unknown interface."));
*ppvObject = NULL;
hr = E_NOINTERFACE;
}
if (hr == S_OK)
{
AddRef();
}
ASSERT(IS_VALID_STRUCT_PTR(this, CConfLink));
DebugExitHRESULT(CConfLink::QueryInterface, hr);
return(hr);
}
/* O P E N C O N F L I N K */
/*-------------------------------------------------------------------------
%%Function: OpenConfLink
-------------------------------------------------------------------------*/
void WINAPI OpenConfLink(HWND hwndParent, HINSTANCE hinst,
PSTR pszCmdLine, int nShowCmd)
{
HRESULT hr;
CConfLink conflink(NULL);
// int nResult;
DebugEntry(OpenConfLink);
ASSERT(IS_VALID_HANDLE(hwndParent, WND));
ASSERT(IS_VALID_HANDLE(hinst, INSTANCE));
ASSERT(IS_VALID_STRING_PTR(pszCmdLine, STR));
ASSERT(IsValidShowCmd(nShowCmd));
// Assume the entire command line is a Conference Link file path.
// TrimWhiteSpace(pszCmdLine);
TRACE_OUT(("OpenConfLink(): Trying to open Conference Link %s.",
pszCmdLine));
#if 0
TCHAR szBuf[256];
wsprintf(szBuf, "Launching conference link %s", pszCmdLine);
::MessageBox( NULL,
szBuf,
"Conference Link Extension",
MB_ICONINFORMATION);
#endif
hr = conflink.LoadFromFile(pszCmdLine, TRUE);
if (hr == S_OK)
{
CLINVOKECOMMANDINFO clici;
clici.dwcbSize = sizeof(clici);
clici.hwndParent = hwndParent;
clici.pcszVerb = NULL;
clici.dwFlags = ( ICL_INVOKECOMMAND_FL_ALLOW_UI |
ICL_INVOKECOMMAND_FL_USE_DEFAULT_VERB);
hr = conflink.InvokeCommand(&clici);
}
else
{
// BUGBUG: need resource here INTL
::MessageBox( hwndParent,
_TEXT("There was an error while identifying the conference"),
_TEXT("Conference Shortcut Error"),
MB_ICONINFORMATION);
// if (MyMsgBox(hwndParent, MAKEINTRESOURCE(IDS_SHORTCUT_ERROR_TITLE),
// MAKEINTRESOURCE(IDS_LOADFROMFILE_FAILED),
// (MB_OK | MB_ICONEXCLAMATION), &nResult, pszCmdLine))
//
// ASSERT(nResult == IDOK);
}
DebugExitVOID(OpenConfLink);
return;
}
/* A N Y M E A T */
/*-------------------------------------------------------------------------
%%Function: AnyMeat
Return TRUE if the string has any non-whitespace characters
-------------------------------------------------------------------------*/
BOOL AnyMeat(PCSTR pcsz)
{
TCHAR ch;
ASSERT((!pcsz) || IS_VALID_STRING_PTR(pcsz, CSTR));
if (NULL == pcsz)
return FALSE;
while (0 != (ch = *pcsz++))
{
switch (ch)
{
case _T(' '): // Space
case _T('\t'): // Tab
case 0x00A0: // Non-breaking space
break;
default:
return TRUE; // found a non-whitespace character
}
}
return FALSE;
}
HRESULT MyReleaseStgMedium(PSTGMEDIUM pstgmed)
{
HRESULT hr;
ASSERT(IS_VALID_STRUCT_PTR(pstgmed, CSTGMEDIUM));
if (pstgmed->pUnkForRelease)
hr = pstgmed->pUnkForRelease->Release();
else
{
switch(pstgmed->tymed)
{
case TYMED_HGLOBAL:
hr = (! GlobalFree(pstgmed->hGlobal)) ? S_OK : E_HANDLE;
break;
#if 0 /* Only TYMED_HGLOBAL is ever used */
case TYMED_ISTREAM:
hr = pstgmed->pstm->Release();
break;
case TYMED_ISTORAGE:
hr = pstgmed->pstm->Release();
break;
case TYMED_FILE:
{
PIMalloc pMalloc = NULL;
if (SUCCEEDED(SHGetMalloc(&pMalloc)))
{
pMalloc->Free(pstgmed->lpszFileName);
pMalloc->Release();
pMalloc = NULL;
pstgmed->lpszFileName = NULL;
}
hr = S_OK;
break;
}
case TYMED_GDI:
hr = (DeleteObject(pstgmed->hBitmap)) ? S_OK : E_HANDLE;
break;
case TYMED_MFPICT:
hr = (DeleteMetaFile((HMETAFILE)(pstgmed->hMetaFilePict)) &&
! GlobalFree(pstgmed->hMetaFilePict)) ? S_OK : E_HANDLE;
break;
case TYMED_ENHMF:
hr = (DeleteEnhMetaFile(pstgmed->hEnhMetaFile)) ? S_OK : E_HANDLE;
break;
#endif // 0
default:
ASSERT(pstgmed->tymed == TYMED_NULL);
hr = S_OK;
break;
}
}
return(hr);
}
Reference in a new issue Copy permalink