776 lines
22 KiB
C++
776 lines
22 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1997.
|
|
//
|
|
// File: N O T I F Y . C P P
|
|
//
|
|
// Contents: Implementation of INetConnectionNotifySink
|
|
//
|
|
// Notes:
|
|
//
|
|
// Author: shaunco 21 Aug 1998
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "pch.h"
|
|
#pragma hdrstop
|
|
#include "foldinc.h"
|
|
#include "nccom.h"
|
|
#include "notify.h"
|
|
#include "shutil.h"
|
|
#include "smcent.h"
|
|
#include "ctrayui.h"
|
|
#include "traymsgs.h"
|
|
#include "wzcdlg.h"
|
|
|
|
extern HWND g_hwndTray;
|
|
|
|
enum EVENT_LEVELS
|
|
{
|
|
EVT_LVL_DISABLE_ALL = 0,
|
|
EVT_LVL_ENABLE_PRIVATE = 1,
|
|
EVT_LVL_ENABLE_ALL = 2
|
|
};
|
|
|
|
DWORD g_dwCurrentEventLevel = EVT_LVL_ENABLE_ALL;
|
|
|
|
//static
|
|
HRESULT
|
|
CConnectionNotifySink::CreateInstance (
|
|
REFIID riid,
|
|
VOID** ppv)
|
|
{
|
|
TraceFileFunc(ttidNotifySink);
|
|
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
|
|
// Initialize the output parameter.
|
|
//
|
|
*ppv = NULL;
|
|
|
|
CConnectionNotifySink* pObj;
|
|
pObj = new CComObject <CConnectionNotifySink>;
|
|
if (pObj)
|
|
{
|
|
// Do the standard CComCreator::CreateInstance stuff.
|
|
//
|
|
pObj->SetVoid (NULL);
|
|
pObj->InternalFinalConstructAddRef ();
|
|
hr = pObj->FinalConstruct ();
|
|
pObj->InternalFinalConstructRelease ();
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Call the PidlInitialize function to allow the enumeration
|
|
// object to copy the list.
|
|
//
|
|
hr = HrGetConnectionsFolderPidl(pObj->m_pidlFolder);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pObj->QueryInterface (riid, ppv);
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
delete pObj;
|
|
}
|
|
}
|
|
|
|
TraceHr(ttidError, FAL, hr, (S_FALSE == hr), "CConnectionNotifySink::CreateInstance");
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CConnectionNotifySink::~CConnectionNotifySink
|
|
//
|
|
// Purpose: Clean up the sink object, deleting the folder pidl and any
|
|
// alloc'd junk we might add in the future.
|
|
//
|
|
// Arguments:
|
|
// (none)
|
|
//
|
|
// Returns:
|
|
//
|
|
// Author: jeffspr 26 Aug 1998
|
|
//
|
|
// Notes:
|
|
//
|
|
CConnectionNotifySink::~CConnectionNotifySink()
|
|
{
|
|
TraceFileFunc(ttidNotifySink);
|
|
|
|
if (FIsDebugFlagSet (dfidBreakOnNotifySinkRelease))
|
|
{
|
|
AssertSz(FALSE, "THIS IS NOT A BUG! The debug flag "
|
|
"\"BreakOnNotifySinkRelease\" has been set. Set your breakpoints now.");
|
|
}
|
|
|
|
TraceTag(ttidNotifySink, "Connection notify sink destroyed");
|
|
}
|
|
|
|
HRESULT CConnectionNotifySink::HrUpdateIncomingConnection()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
ConnListEntry cle;
|
|
hr = g_ccl.HrFindRasServerConnection(cle);
|
|
if (S_OK == hr)
|
|
{
|
|
hr = HrOnNotifyUpdateConnection(
|
|
m_pidlFolder,
|
|
&(cle.ccfe.GetGuidID()),
|
|
cle.ccfe.GetNetConMediaType(),
|
|
cle.ccfe.GetNetConSubMediaType(),
|
|
cle.ccfe.GetNetConStatus(),
|
|
cle.ccfe.GetCharacteristics(),
|
|
cle.ccfe.GetName(),
|
|
cle.ccfe.GetDeviceName(),
|
|
cle.ccfe.GetPhoneOrHostAddress()
|
|
);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
CConnectionNotifySink::ConnectionAdded (
|
|
const NETCON_PROPERTIES_EX* pPropsEx)
|
|
{
|
|
TraceFileFunc(ttidNotifySink);
|
|
|
|
#ifdef DBG
|
|
OLECHAR szGuidString[MAX_GUID_STRING_LEN];
|
|
StringFromGUID2(pPropsEx->guidId, szGuidString, MAX_GUID_STRING_LEN);
|
|
TraceTag(ttidNotifySink, "INetConnectionNotifySink::ConnectionAdded - %S %S [%s:%s:%s:%s]",
|
|
szGuidString, pPropsEx->bstrName, DbgNcm(pPropsEx->ncMediaType), DbgNcsm(pPropsEx->ncSubMediaType), DbgNcs(pPropsEx->ncStatus), DbgNccf(pPropsEx->dwCharacter) );
|
|
#endif
|
|
if (g_dwCurrentEventLevel <= EVT_LVL_DISABLE_ALL)
|
|
{
|
|
TraceTag(ttidNotifySink, "Last event ignored due to g_dwCurrentEventLevel == %d", g_dwCurrentEventLevel);
|
|
return S_FALSE;
|
|
}
|
|
|
|
HRESULT hr = S_OK; // Only used for code paths. We don't return this.
|
|
HRESULT hrFind = S_OK; // Only for finding the connection.
|
|
PCONFOLDPIDL pidlNew;
|
|
|
|
ConnListEntry cleDontCare;
|
|
hrFind = g_ccl.HrFindConnectionByGuid(&(pPropsEx->guidId), cleDontCare);
|
|
if (S_OK == hrFind)
|
|
{
|
|
// We already know about this connection. Don't bother added it.
|
|
TraceTag(ttidShellFolder, "Ignoring known connection on ConnectionAdded notify");
|
|
}
|
|
else
|
|
{
|
|
// Create the entry in the connection list and get the returned pidl
|
|
//
|
|
hr = HrCreateConFoldPidl(
|
|
*pPropsEx,
|
|
pidlNew);
|
|
if (SUCCEEDED(hr) && (!pidlNew.empty()))
|
|
{
|
|
CONFOLDENTRY cfe;
|
|
|
|
Assert(!m_pidlFolder.empty());
|
|
|
|
// Convert to the confoldentry
|
|
//
|
|
hr = pidlNew.ConvertToConFoldEntry(cfe);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Insert the connection in the connection list
|
|
//
|
|
hr = g_ccl.HrInsert(cfe);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Notify the shell that we have a new object
|
|
//
|
|
PCONFOLDPIDL pidlShellNotify;
|
|
hr = cfe.ConvertToPidl(pidlShellNotify);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
GenerateEvent(SHCNE_CREATE, m_pidlFolder, pidlShellNotify, NULL);
|
|
}
|
|
}
|
|
|
|
// Don't delete the cfe here because the connection list now owns it.
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr) &&
|
|
(NCM_NONE != pPropsEx->ncMediaType) &&
|
|
(pPropsEx->dwCharacter & NCCF_INCOMING_ONLY) )
|
|
{
|
|
hr = HrUpdateIncomingConnection();
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
CConnectionNotifySink::ConnectionBandWidthChange (
|
|
const GUID* pguidId)
|
|
{
|
|
TraceFileFunc(ttidNotifySink);
|
|
#ifdef DBG
|
|
OLECHAR szGuidString[MAX_GUID_STRING_LEN];
|
|
StringFromGUID2(*pguidId, szGuidString, MAX_GUID_STRING_LEN);
|
|
TraceTag(ttidNotifySink, "INetConnectionNotifySink::ConnectionBandWidthChange - %S", szGuidString);
|
|
#endif
|
|
if (g_dwCurrentEventLevel <= EVT_LVL_DISABLE_ALL)
|
|
{
|
|
TraceTag(ttidNotifySink, "Last event ignored due to g_dwCurrentEventLevel == %d", g_dwCurrentEventLevel);
|
|
return S_FALSE;
|
|
}
|
|
|
|
HRESULT hr = S_OK;
|
|
CNetStatisticsCentral * pnsc = NULL;
|
|
|
|
hr = CNetStatisticsCentral::HrGetNetStatisticsCentral(&pnsc, FALSE);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pnsc->UpdateRasLinkList(pguidId);
|
|
ReleaseObj(pnsc);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CConnectionNotifySink::ConnectionDeleted (
|
|
const GUID* pguidId)
|
|
{
|
|
TraceFileFunc(ttidNotifySink);
|
|
|
|
HRESULT hr = S_OK;
|
|
HRESULT hrFind = S_OK;
|
|
ConnListEntry cle;
|
|
PCONFOLDPIDL pidlFind;
|
|
BOOL fFlushPosts = FALSE;
|
|
|
|
Assert(pguidId);
|
|
Assert(!m_pidlFolder.empty());
|
|
|
|
if (g_dwCurrentEventLevel <= EVT_LVL_DISABLE_ALL)
|
|
{
|
|
TraceTag(ttidNotifySink, "CConnectionNotifySink::ConnectionDeleted event ignored due to g_dwCurrentEventLevel == %d", g_dwCurrentEventLevel);
|
|
return S_FALSE;
|
|
}
|
|
|
|
// Find the connection using the GUID.
|
|
//
|
|
hrFind = g_ccl.HrFindConnectionByGuid(pguidId, cle);
|
|
if (S_OK == hrFind)
|
|
{
|
|
#ifdef DBG
|
|
OLECHAR szGuidString[MAX_GUID_STRING_LEN];
|
|
StringFromGUID2(cle.ccfe.GetGuidID(), szGuidString, MAX_GUID_STRING_LEN);
|
|
TraceTag(ttidNotifySink, "INetConnectionNotifySink::ConnectionDeleted - %S %S [%s:%s:%s:%s]", szGuidString, cle.ccfe.GetName(),
|
|
DbgNcm(cle.ccfe.GetNetConMediaType()), DbgNcsm(cle.ccfe.GetNetConSubMediaType()), DbgNcs(cle.ccfe.GetNetConStatus()), DbgNccf(cle.ccfe.GetCharacteristics()));
|
|
#endif
|
|
// Very important to release the lock before doing any thing which
|
|
// calls back into the shell. (e.g. GenerateEvent)
|
|
|
|
const CONFOLDENTRY &ccfe = cle.ccfe;
|
|
|
|
// Get the pidl for the connection so we can use it to notify
|
|
// the shell further below.
|
|
//
|
|
ccfe.ConvertToPidl(pidlFind);
|
|
|
|
// Remove this connection from the global list while we
|
|
// have the lock held.
|
|
//
|
|
hr = g_ccl.HrRemove(cle.ccfe, &fFlushPosts);
|
|
}
|
|
else
|
|
{
|
|
TraceTag(ttidShellFolder, "Notify: Delete <item not found in cache>. hr = 0x%08x", hr);
|
|
}
|
|
|
|
|
|
// If we need to flush the posts after making tray icon changes, do so
|
|
//
|
|
if (g_hwndTray && fFlushPosts)
|
|
{
|
|
FlushTrayPosts(g_hwndTray);
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && (!pidlFind.empty()))
|
|
{
|
|
GenerateEvent(SHCNE_DELETE, m_pidlFolder, pidlFind, NULL);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = HrUpdateIncomingConnection();
|
|
}
|
|
|
|
// Only return S_OK from here.
|
|
//
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
CConnectionNotifySink::ConnectionModified (
|
|
const NETCON_PROPERTIES_EX* pPropsEx)
|
|
{
|
|
TraceFileFunc(ttidNotifySink);
|
|
|
|
Assert(pPropsEx);
|
|
Assert(!m_pidlFolder.empty());
|
|
|
|
#ifdef DBG
|
|
OLECHAR szGuidString[MAX_GUID_STRING_LEN];
|
|
StringFromGUID2(pPropsEx->guidId, szGuidString, MAX_GUID_STRING_LEN);
|
|
TraceTag(ttidNotifySink, "INetConnectionNotifySink::ConnectionModified - %S %S [%s:%s:%s:%s]", szGuidString, pPropsEx->bstrName,
|
|
DbgNcm(pPropsEx->ncMediaType), DbgNcsm(pPropsEx->ncSubMediaType), DbgNcs(pPropsEx->ncStatus), DbgNccf(pPropsEx->dwCharacter));
|
|
#endif
|
|
|
|
if (g_dwCurrentEventLevel <= EVT_LVL_ENABLE_PRIVATE)
|
|
{
|
|
TraceTag(ttidNotifySink, "Last event ignored due to g_dwCurrentEventLevel == %d", g_dwCurrentEventLevel);
|
|
return S_FALSE;
|
|
}
|
|
|
|
// Get the result for debugging only. We never want to fail this function
|
|
//
|
|
HRESULT hrTmp = HrOnNotifyUpdateConnection(
|
|
m_pidlFolder,
|
|
(GUID *)&(pPropsEx->guidId),
|
|
pPropsEx->ncMediaType,
|
|
pPropsEx->ncSubMediaType,
|
|
pPropsEx->ncStatus,
|
|
pPropsEx->dwCharacter,
|
|
pPropsEx->bstrName,
|
|
pPropsEx->bstrDeviceName,
|
|
pPropsEx->bstrPhoneOrHostAddress);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CConnectionNotifySink::ConnectionRenamed (
|
|
const GUID* pguidId,
|
|
PCWSTR pszwNewName)
|
|
{
|
|
TraceFileFunc(ttidNotifySink);
|
|
|
|
HRESULT hr = S_OK;
|
|
PCONFOLDPIDL pidlNew;
|
|
|
|
Assert(pguidId);
|
|
Assert(pszwNewName);
|
|
|
|
if (g_dwCurrentEventLevel <= EVT_LVL_DISABLE_ALL)
|
|
{
|
|
TraceTag(ttidNotifySink, "CConnectionNotifySink::ConnectionRenamed event ignored due to g_dwCurrentEventLevel == %d", g_dwCurrentEventLevel);
|
|
return S_FALSE;
|
|
}
|
|
|
|
// Update the name in the cache
|
|
//
|
|
|
|
// Note: There exists a race condition with shutil.cpp:
|
|
// HrRenameConnectionInternal\HrUpdateNameByGuid can also update the cache.
|
|
ConnListEntry cle;
|
|
hr = g_ccl.HrFindConnectionByGuid(pguidId, cle);
|
|
if (FAILED(hr))
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
#ifdef DBG
|
|
OLECHAR szGuidString[MAX_GUID_STRING_LEN];
|
|
StringFromGUID2(cle.ccfe.GetGuidID(), szGuidString, MAX_GUID_STRING_LEN);
|
|
TraceTag(ttidNotifySink, "INetConnectionNotifySink::ConnectionRenamed - %S %S (to %S) [%s:%s:%s:%s]", szGuidString, cle.ccfe.GetName(), pszwNewName,
|
|
DbgNcm(cle.ccfe.GetNetConMediaType()), DbgNcsm(cle.ccfe.GetNetConSubMediaType()), DbgNcs(cle.ccfe.GetNetConStatus()), DbgNccf(cle.ccfe.GetCharacteristics()));
|
|
#endif
|
|
|
|
hr = g_ccl.HrUpdateNameByGuid(
|
|
(GUID *) pguidId,
|
|
(PWSTR) pszwNewName,
|
|
pidlNew,
|
|
TRUE); // Force the update -- this is a notification, not a request
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
PCONFOLDPIDL pidl;
|
|
cle.ccfe.ConvertToPidl(pidl);
|
|
|
|
GenerateEvent(
|
|
SHCNE_RENAMEITEM,
|
|
m_pidlFolder,
|
|
pidl,
|
|
pidlNew.GetItemIdList());
|
|
|
|
// Update status monitor title (RAS case)
|
|
CNetStatisticsCentral * pnsc = NULL;
|
|
|
|
hr = CNetStatisticsCentral::HrGetNetStatisticsCentral(&pnsc, FALSE);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pnsc->UpdateTitle(pguidId, pszwNewName);
|
|
ReleaseObj(pnsc);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If the connection wasn't found in the cache, then it's likely that
|
|
// the notification engine is giving us a notification for a connection
|
|
// that hasn't yet been given to us.
|
|
//
|
|
if (S_FALSE == hr)
|
|
{
|
|
TraceHr(ttidShellFolder, FAL, hr, FALSE, "Rename notification received on a connection we don't know about");
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
CConnectionNotifySink::ConnectionStatusChange (
|
|
const GUID* pguidId,
|
|
NETCON_STATUS Status)
|
|
{
|
|
TraceFileFunc(ttidNotifySink);
|
|
|
|
HRESULT hr = S_OK;
|
|
HRESULT hrFind = S_OK;
|
|
PCONFOLDPIDL pidlFind;
|
|
|
|
if (g_dwCurrentEventLevel <= EVT_LVL_ENABLE_PRIVATE)
|
|
{
|
|
TraceTag(ttidNotifySink, "CConnectionNotifySink::ConnectionStatusChange event ignored due to g_dwCurrentEventLevel == %d", g_dwCurrentEventLevel);
|
|
return S_FALSE;
|
|
}
|
|
|
|
// Find the connection using the GUID. Cast the const away from the GUID
|
|
//
|
|
hrFind = g_ccl.HrFindPidlByGuid((GUID *) pguidId, pidlFind);
|
|
|
|
if( S_OK != hrFind )
|
|
{
|
|
GUID guidOwner;
|
|
|
|
// We did not find the guid in connection folder. Try finding the connection in the
|
|
// hidden connectiod list on netmans side.
|
|
//
|
|
hr = g_ccl.HrMapCMHiddenConnectionToOwner(*pguidId, &guidOwner);
|
|
if (S_OK == hr)
|
|
{
|
|
// The conection has a parent!!!! Use the childs status instead of the parents status.
|
|
//
|
|
if (Status == NCS_CONNECTED)
|
|
{
|
|
// This means that the child has connected and the parent still has to connect
|
|
// the overall status should stay as connected. This was done to overrule the Multi-link
|
|
// hack in HrOnNotifyUpdateStatus. If we did not do this it would say :
|
|
// Child( Connecting, Connected) and then Parent(Connecting, Connected)
|
|
//
|
|
Status = NCS_CONNECTING;
|
|
}
|
|
|
|
// Get the pidl of the parent.
|
|
//
|
|
hrFind = g_ccl.HrFindPidlByGuid(&guidOwner, pidlFind);
|
|
}
|
|
}
|
|
|
|
if (S_OK == hrFind)
|
|
{
|
|
#ifdef DBG
|
|
OLECHAR szGuidString[MAX_GUID_STRING_LEN];
|
|
StringFromGUID2(pidlFind->guidId, szGuidString, MAX_GUID_STRING_LEN);
|
|
TraceTag(ttidNotifySink, "INetConnectionNotifySink::ConnectionStatusChange - %S %S [%s:%s:%s:%s]", szGuidString, pidlFind->PszGetNamePointer(),
|
|
DbgNcm(pidlFind->ncm), DbgNcsm(pidlFind->ncsm), DbgNcs(Status), DbgNccf(pidlFind->dwCharacteristics));
|
|
#endif
|
|
hr = HrOnNotifyUpdateStatus(m_pidlFolder, pidlFind, Status);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
CConnectionNotifySink::RefreshAll ()
|
|
{
|
|
TraceFileFunc(ttidNotifySink);
|
|
|
|
#ifdef DBG
|
|
TraceTag(ttidNotifySink, "INetConnectionNotifySink::RefreshAll");
|
|
#endif
|
|
|
|
if (g_dwCurrentEventLevel <= EVT_LVL_DISABLE_ALL)
|
|
{
|
|
TraceTag(ttidNotifySink, "Last event ignored due to g_dwCurrentEventLevel == %d", g_dwCurrentEventLevel);
|
|
return S_FALSE;
|
|
}
|
|
|
|
// Refresh the connections folder, without having to hook the shell view.
|
|
// In this case, we do a non-flush refresh where we compare the new set
|
|
// of items to the cached set and do the merge (with the correct set
|
|
// of individual notifications).
|
|
//
|
|
(VOID) HrForceRefreshNoFlush(m_pidlFolder);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CConnectionNotifySink::ConnectionAddressChange (
|
|
const GUID* pguidId )
|
|
{
|
|
// Find the connection using the GUID.
|
|
//
|
|
PCONFOLDPIDL pidlFind;
|
|
HRESULT hr = g_ccl.HrFindPidlByGuid(pguidId, pidlFind);
|
|
if (S_OK != hr)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
#ifdef DBG
|
|
OLECHAR szGuidString[MAX_GUID_STRING_LEN];
|
|
StringFromGUID2(pidlFind->guidId, szGuidString, MAX_GUID_STRING_LEN);
|
|
TraceTag(ttidNotifySink, "INetConnectionNotifySink::ConnectionAddressChange - %S %S [%s:%s:%s:%s]", szGuidString, pidlFind->PszGetNamePointer(),
|
|
DbgNcm(pidlFind->ncm), DbgNcsm(pidlFind->ncsm), DbgNcs(pidlFind->ncs), DbgNccf(pidlFind->dwCharacteristics));
|
|
|
|
#endif
|
|
if (g_dwCurrentEventLevel <= EVT_LVL_DISABLE_ALL)
|
|
{
|
|
TraceTag(ttidNotifySink, "Last event ignored due to g_dwCurrentEventLevel == %d", g_dwCurrentEventLevel);
|
|
return S_FALSE;
|
|
}
|
|
|
|
PCONFOLDPIDLFOLDER pidlFolder;
|
|
hr = HrGetConnectionsFolderPidl(pidlFolder);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
GenerateEvent(SHCNE_UPDATEITEM, pidlFolder, pidlFind, NULL);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
DWORD WINAPI OnTaskBarIconBalloonClickThread(LPVOID lpParam);
|
|
|
|
STDMETHODIMP CConnectionNotifySink::ShowBalloon(
|
|
IN const GUID* pguidId,
|
|
IN const BSTR szCookie,
|
|
IN const BSTR szBalloonText)
|
|
{
|
|
HRESULT hr;
|
|
|
|
#ifdef DBG
|
|
OLECHAR szGuidString[MAX_GUID_STRING_LEN];
|
|
StringFromGUID2(*pguidId, szGuidString, MAX_GUID_STRING_LEN);
|
|
TraceTag(ttidNotifySink, "INetConnectionNotifySink::ShowBalloon - %S (%S)", szGuidString, szBalloonText);
|
|
#endif
|
|
|
|
if (g_dwCurrentEventLevel <= EVT_LVL_DISABLE_ALL)
|
|
{
|
|
TraceTag(ttidNotifySink, "Last event ignored due to g_dwCurrentEventLevel == %d", g_dwCurrentEventLevel);
|
|
return S_FALSE;
|
|
}
|
|
|
|
CComBSTR szBalloonTextTmp = szBalloonText;
|
|
BSTR szCookieTmp = NULL;
|
|
|
|
if (szCookie)
|
|
{
|
|
szCookieTmp = SysAllocStringByteLen(reinterpret_cast<LPCSTR>(szCookie), SysStringByteLen(szCookie));
|
|
}
|
|
|
|
ConnListEntry cleFind;
|
|
hr = g_ccl.HrFindConnectionByGuid(pguidId, cleFind);
|
|
if (S_OK == hr)
|
|
{
|
|
hr = WZCCanShowBalloon(pguidId, cleFind.ccfe.GetName(), &szBalloonTextTmp, &szCookieTmp);
|
|
if ( (S_OK == hr) || (S_OBJECT_NO_LONGER_VALID == hr) )
|
|
{
|
|
CTrayBalloon *pTrayBalloon = new CTrayBalloon();
|
|
if (!pTrayBalloon)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
pTrayBalloon->m_gdGuid = *pguidId;
|
|
pTrayBalloon->m_dwTimeOut = 30 * 1000;
|
|
pTrayBalloon->m_szMessage = szBalloonTextTmp;
|
|
pTrayBalloon->m_pfnFuncCallback = WZCOnBalloonClick;
|
|
pTrayBalloon->m_szCookie = szCookieTmp;
|
|
pTrayBalloon->m_szAdapterName = cleFind.ccfe.GetName();
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
PostMessage(g_hwndTray, MYWM_SHOWBALLOON,
|
|
NULL,
|
|
(LPARAM) pTrayBalloon);
|
|
}
|
|
else // S_OBJECT_NO_LONGER_VALID == hr
|
|
{
|
|
CreateThread(NULL, STACK_SIZE_SMALL, OnTaskBarIconBalloonClickThread, pTrayBalloon, 0, NULL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (S_OK != hr)
|
|
{
|
|
SysFreeString(szCookieTmp);
|
|
}
|
|
|
|
TraceHr(ttidError, FAL, hr, FALSE,
|
|
"CConnectionNotifySink::ShowBalloon");
|
|
|
|
return hr;
|
|
}
|
|
|
|
UINT_PTR uipTimer = NULL;
|
|
|
|
VOID CALLBACK EventTimerProc(
|
|
HWND hwnd, // handle to window
|
|
UINT uMsg, // WM_TIMER message
|
|
UINT_PTR idEvent, // timer identifier
|
|
DWORD dwTime // current system time
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
TraceTag(ttidNotifySink, "Refreshing the folder due to DisableEvents timeout reached");
|
|
|
|
g_dwCurrentEventLevel = EVT_LVL_ENABLE_ALL;
|
|
if (uipTimer)
|
|
{
|
|
KillTimer(NULL, uipTimer);
|
|
uipTimer = NULL;
|
|
}
|
|
|
|
PCONFOLDPIDLFOLDER pcfpFolder;
|
|
hr = HrGetConnectionsFolderPidl(pcfpFolder);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
HrForceRefreshNoFlush(pcfpFolder);
|
|
}
|
|
}
|
|
|
|
STDMETHODIMP CConnectionNotifySink::DisableEvents (
|
|
IN const BOOL fDisable,
|
|
IN const ULONG ulDisableTimeout)
|
|
{
|
|
#ifdef DBG
|
|
TraceTag(ttidNotifySink, "INetConnectionNotifySink::DisableEvents - %s 0x%08x", fDisable ? "DISABLE" : "ENABLE", ulDisableTimeout);
|
|
#endif
|
|
HRESULT hr = S_OK;
|
|
|
|
if (fDisable)
|
|
{
|
|
if (HIWORD(ulDisableTimeout) & 0x8000)
|
|
{
|
|
// Called from private interface - disable all the events
|
|
g_dwCurrentEventLevel = EVT_LVL_DISABLE_ALL;
|
|
}
|
|
else
|
|
{
|
|
// Called from public interface - only disable connection modified & status change events
|
|
g_dwCurrentEventLevel = EVT_LVL_ENABLE_PRIVATE;
|
|
}
|
|
|
|
UINT uiEventTimeOut = LOWORD(ulDisableTimeout);
|
|
if (uipTimer)
|
|
{
|
|
KillTimer(NULL, uipTimer);
|
|
uipTimer = NULL;
|
|
}
|
|
|
|
uipTimer = SetTimer(NULL, NULL, uiEventTimeOut, EventTimerProc);
|
|
}
|
|
else
|
|
{
|
|
g_dwCurrentEventLevel = EVT_LVL_ENABLE_ALL;
|
|
|
|
if (uipTimer)
|
|
{
|
|
KillTimer(NULL, uipTimer);
|
|
uipTimer = NULL;
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE; // Timer no more.
|
|
}
|
|
|
|
HrForceRefreshNoFlush(m_pidlFolder);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrGetNotifyConPoint
|
|
//
|
|
// Purpose: Common code for getting the connection point for use in
|
|
// NotifyAdd and NotifyRemove
|
|
//
|
|
// Arguments:
|
|
// ppConPoint [out] Return ptr for IConnectionPoint
|
|
//
|
|
// Returns:
|
|
//
|
|
// Author: jeffspr 24 Aug 1998
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT HrGetNotifyConPoint(
|
|
IConnectionPoint ** ppConPoint)
|
|
{
|
|
TraceFileFunc(ttidNotifySink);
|
|
|
|
HRESULT hr = S_OK;
|
|
IConnectionPointContainer * pContainer = NULL;
|
|
|
|
Assert(ppConPoint);
|
|
|
|
// Get the debug interface from the connection manager
|
|
//
|
|
hr = HrCreateInstance(
|
|
CLSID_ConnectionManager,
|
|
CLSCTX_LOCAL_SERVER | CLSCTX_NO_CODE_DOWNLOAD,
|
|
&pContainer);
|
|
|
|
TraceHr(ttidError, FAL, hr, FALSE,
|
|
"HrCreateInstance(CLSID_ConnectionManager) for IConnectionPointContainer");
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IConnectionPoint * pConPoint = NULL;
|
|
|
|
// Get the connection point itself and fill in the return param
|
|
// on success
|
|
//
|
|
hr = pContainer->FindConnectionPoint(
|
|
IID_INetConnectionNotifySink,
|
|
&pConPoint);
|
|
|
|
TraceHr(ttidError, FAL, hr, FALSE, "pContainer->FindConnectionPoint");
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
NcSetProxyBlanket (pConPoint);
|
|
*ppConPoint = pConPoint;
|
|
}
|
|
|
|
ReleaseObj(pContainer);
|
|
}
|
|
|
|
TraceHr(ttidError, FAL, hr, FALSE, "HrGetNotifyConPoint");
|
|
return hr;
|
|
}
|