WebVersion.h
//////////////////
// This class encapsulates over-the-Web version checking. It expects a
// text version file that contains four numbers separated by commas, the
// same format for FILEVERSION and PRODUCTVERSION in VS_VERSION_INFO.
// ReadVersion reads these numbers into dwVersionMS and dwVersionLS.
// Uses HTTP, not FTP, to fetch the file.
//
class CWebVersion {
protected:
   enum { BUFSIZE = 64 };
   char    m_version[BUFSIZ];           // version number as text
   CString m_sServer;                   // server name (www.mysite.com)
   DWORD   m_dwStatus;                  // status code
   CString m_sStatus;                   // status text

public:
   DWORD dwMajorVersion;      // version number: most-sig 32 bits
   DWORD dwMinorVersion;      // version number: least-sig 32 bits

   CWebVersion(LPCTSTR server) : m_sServer(server) { }
   ~CWebVersion() { }

   static BOOL Online();
   BOOL     ReadVersion(LPCTSTR lpFileName);
   LPCSTR   GetVersionText()      { return m_version; }
   DWORD    GetStatus()           { return m_dwStatus; }
   CString  GetStatusText()       { return m_sStatus; }
};

WebVersion.cpp
#include „stdafx.h"
#include „WebVersion.h"

//////////////////
// Check if connected to Internet.
//
BOOL CWebVersion::Online()
{
    DWORD dwState = 0; 
    DWORD dwSize = sizeof(DWORD);
    return InternetQueryOption(NULL,
       INTERNET_OPTION_CONNECTED_STATE, &dwState, &dwSize)
       && (dwState & INTERNET_STATE_CONNECTED);
}
//////////////////
// Read version number as string into buffer. Use MFC CHttpFile.
//
BOOL CWebVersion::ReadVersion(LPCTSTR lpFileName)
{
   ASSERT(lpFileName);
   BOOL bRet = FALSE;                   // assume failure
   m_dwStatus=0;
   m_sStatus.Empty();

   // Read version file using MFC Inet classes.
   INTERNET_PORT nPort = INTERNET_DEFAULT_HTTP_PORT;
   CInternetSession session(_T("MySession"));
   CHttpConnection* pConn = NULL;
   CHttpFile* pFile = NULL;
   try {
      pConn = session.GetHttpConnection(m_sServer, nPort);
      pFile = pConn->OpenRequest(
         CHttpConnection::HTTP_VERB_GET, lpFileName);
      pFile->SendRequest();
      pFile->QueryInfoStatusCode(m_dwStatus);
      if (m_dwStatus==HTTP_STATUS_OK) {
         const UINT BUFSIZE = 128;
         UINT nRead = pFile->Read(m_version, BUFSIZE);
         if (nRead>0) {
            // read version number in the form Mhi,Mlo,mhi,mlo
            m_version[nRead] = 0;
            int Mhi,Mlo,mhi,mlo;
            _stscanf(m_version, (_T(«%x,%x,%x,%x»)), 
               &Mhi, &Mlo, &mhi, &mlo);
            dwMajorVersion = MAKELONG(Mlo,Mhi);
            dwMinorVersion = MAKELONG(mlo,mhi);
            bRet = TRUE;                // success!
         }
      } else {
         pFile->QueryInfo(HTTP_QUERY_STATUS_TEXT, m_sStatus);
      }

   } catch (CInternetException* pEx) { ... }
   session.Close();

   delete pFile;
   delete pConn;

   return bRet;
}

#pragma once

// one of these for each application sound
struct APPSOUND {
   UINT id;                             // ID for programming
   LPCTSTR log_name;                    // logical event name for registry
   LPCTSTR gui_name;                    // user-visible event name
};

//////////////////
// Class to manage app sounds. Use macros to create a static table, then
// construct one of these initialized from the table.
//
class CSoundMgr {
protected:
   APPSOUND* m_soundtab;                // table of APPSOUNDs

   // helper fns
   BOOL GetSoundFileName(LPCTSTR logname, CString& s);
   BOOL GetLogicalName(UINT id, CString& logname);

public:
   BOOL m_bUseResourceSounds;           // look for default sounds in res
                                           file?
   BOOL m_bEnableSounds;                // enable/disable sound

   CSoundMgr(APPSOUND* tab);
   ~CSoundMgr() { }

   CString GetSoundSchemeKey(LPCTSTR logname=NULL);

   BOOL PlaySound(UINT id, DWORD dwAddFlags=0);
   BOOL PlaySound(LPCTSTR logname, DWORD dwAddFlags=0);

   BOOL IsRegistered();                 // are sounds registered?
   BOOL Register();                     // register sounds
};

//////////////////
// Macros to build sounds table.
//
#define BEGIN_SOUND_MAP(name) APPSOUND name[] = {
#define DEFINE_SOUND(id, regname, guiname) { id, regname, guiname },
#define END_SOUND_MAP() { 0, NULL, NULL } }; 

#include "stdafx.h"
#include "SoundMgr.h"

//////////////////
// Construct sound manager from table.
//
CSoundMgr::CSoundMgr(APPSOUND* tab) : m_soundtab(tab)
{
   m_bUseResourceSounds = TRUE;   // default: use default resource sounds
   m_bEnableSounds = TRUE;        // default: sounds enabled
}

//////////////////
// Get name of registry key for sound events:
// HKCU\AppEvents\Schemes\Apps\logname, where logname is optional.
//
CString CSoundMgr::GetSoundSchemeKey(LPCTSTR logname)
{
   CString key;
   key.Format(_T("AppEvents\\Schemes\\Apps\\%s"), AfxGetAppName());
   if (logname) {
      key += _T("\\");
      key += logname;
   }
   return key;
}

SoundMgr.h 
#pragma once

// one of these for each application sound
struct APPSOUND {
   UINT id;                             // ID for programming
   LPCTSTR log_name;                    // logical event name for registry
   LPCTSTR gui_name;                    // user-visible event name
};

//////////////////
// Class to manage app sounds. Use macros to create a static table, then
// construct one of these initialized from the table.
//
class CSoundMgr {
protected:
   APPSOUND* m_soundtab;                // table of APPSOUNDs

   // helper fns
   BOOL GetSoundFileName(LPCTSTR logname, CString& s);
   BOOL GetLogicalName(UINT id, CString& logname);

public:
   BOOL m_bUseResourceSounds;           // look for default sounds in res
                                           file?
   BOOL m_bEnableSounds;                // enable/disable sound

   CSoundMgr(APPSOUND* tab);
   ~CSoundMgr() { }

   CString GetSoundSchemeKey(LPCTSTR logname=NULL);

   BOOL PlaySound(UINT id, DWORD dwAddFlags=0);
   BOOL PlaySound(LPCTSTR logname, DWORD dwAddFlags=0);

   BOOL IsRegistered();                 // are sounds registered?
   BOOL Register();                     // register sounds
};

//////////////////
// Macros to build sounds table.
//
#define BEGIN_SOUND_MAP(name) APPSOUND name[] = {
#define DEFINE_SOUND(id, regname, guiname) { id, regname, guiname },
#define END_SOUND_MAP() { 0, NULL, NULL } }; 

SoundMgr.cpp
#include "stdafx.h"
#include "SoundMgr.h"

//////////////////
// Construct sound manager from table.
//
CSoundMgr::CSoundMgr(APPSOUND* tab) : m_soundtab(tab)
{
   m_bUseResourceSounds = TRUE;   // default: use default resource sounds
   m_bEnableSounds = TRUE;        // default: sounds enabled
}

//////////////////
// Get name of registry key for sound events:
// HKCU\AppEvents\Schemes\Apps\logname, where logname is optional.
//
CString CSoundMgr::GetSoundSchemeKey(LPCTSTR logname)
{
   CString key;
   key.Format(_T("AppEvents\\Schemes\\Apps\\%s"), AfxGetAppName());
   if (logname) {
      key += _T("\\");
      key += logname;
   }
   return key;
}
//////////////////
// Play logical sound from ID.
//
BOOL CSoundMgr::PlaySound(UINT id, DWORD dwAddFlags)
{
   if (id==0) {
      ::PlaySound(NULL,NULL,0); // ID 0 = stop playing async sound
      return TRUE;
   }
   CString logname;
   return GetLogicalName(id, logname) ?
      PlaySound(logname, dwAddFlags) : FALSE;
}

//////////////////
// Play logical sound using logical name.
//
BOOL CSoundMgr::PlaySound(LPCTSTR logname, DWORD dwAddFlags)
{
   if (m_bEnableSounds) {
      CString soundname;
      if (GetSoundFileName(logname, soundname)  && !soundname.IsEmpty()) {
         return ::PlaySound(soundname, NULL,
            dwAddFlags|SND_APPLICATION|SND_NODEFAULT);
      } else if (m_bUseResourceSounds) {
         // play sound resource w/same logical name
         return ::PlaySound(logname, AfxGetResourceHandle(),
            dwAddFlags|SND_RESOURCE|SND_NODEFAULT);
      }
   }
   return FALSE;
}

//////////////////
// Get logical sound name from ID. Search table for sound that matches.
//
BOOL CSoundMgr::GetLogicalName(UINT id, CString& logname)
{
   if (m_soundtab) {
      for (int i=0; m_soundtab[i].id; i++) {
         if (m_soundtab[i].id==id) {
            logname = m_soundtab[i].log_name;
            return TRUE;
         }
      }
   }
   return FALSE;
}

//////////////////
// Read current sound file name from registry.
//
BOOL CSoundMgr::GetSoundFileName(LPCTSTR logname, CString& s)
{
   CString key = GetSoundSchemeKey(logname); // get registry key

   // open key and read the ".current" value.
   BOOL bRet = FALSE;
   HKEY hkey;
   if (RegOpenKey(HKEY_CURRENT_USER, key, &hkey)==ERROR_SUCCESS) {
      TCHAR val[255]={0};
      LONG  vlen=sizeof(val)/sizeof(TCHAR);
      if (RegQueryValue(hkey, _T(".current"), val, &vlen)==ERROR_SUCCESS)       
      {
         s = val;                       // return in caller’s string
         bRet = TRUE;                   // success
      }
      RegCloseKey(hkey);
   }
   return bRet; // failed :(
}
//////////////////
// Test if sounds are registered. Algorithm: see if first logical sound is
// registered. Note this is not foolproof if someone deletes other keys.
//
BOOL CSoundMgr::IsRegistered()
{
   ASSERT(m_soundtab);
   CString key = GetSoundSchemeKey(m_soundtab[1].log_name);
   HKEY hkey;
   if (RegOpenKey(HKEY_CURRENT_USER, key, &hkey)==ERROR_SUCCESS)
      return TRUE;
   RegCloseKey(hkey);
   return FALSE;
}

// Helper function to open a registry key, creating if necessary
static LONG RegCreateOpenKey(HKEY hkey, LPCTSTR lpSubKey, PHKEY phkRes)
{
   return RegOpenKey(hkey, lpSubKey, phkRes)==ERROR_SUCCESS ?
      ERROR_SUCCESS : RegCreateKey(hkey, lpSubKey, phkRes);
}

//////////////////
// Register app-defined sounds. Note this only creates all the keys, 
// it does NOT set the values (file names) since the app will play default 
// sounds from the resource file. Creating the keys is all that’s required 
// to let users change the sounds.
//
BOOL CSoundMgr::Register()
{
   ASSERT(m_soundtab);
   BOOL bRet = FALSE;

   static LPCTSTR APPS = _T("AppEvents\\Schemes\\Apps");
   static LPCTSTR LABELS = _T("AppEvents\\EventLabels");
   HKEY hkApps,hkLabels;

   if (RegOpenKey(HKEY_CURRENT_USER, APPS, &hkApps)==ERROR_SUCCESS) {
      if (RegOpenKey(HKEY_CURRENT_USER, LABELS, &hkLabels)==ERROR_SUCCESS) 
   {
         HKEY hkApp;
         if (RegCreateOpenKey(hkApps, AfxGetAppName(), 
               &hkApp)==ERROR_SUCCESS) {
            // opened event key, now add all the sounds
            for (int i=0; m_soundtab[i].id; i++) {
               HKEY hk;
               LPCTSTR lpName = m_soundtab[i].gui_name;
               DWORD dwLen = (DWORD)_tcslen(m_soundtab[i].gui_name);

               // add app event
               RegCreateKey(hkApp, m_soundtab[i].log_name, &hk);
               RegSetValue(hk, NULL, REG_SZ, lpName, dwLen);
               RegCloseKey(hk);

               // add event name
               RegCreateKey(hkLabels, m_soundtab[i].log_name, &hk);
               RegSetValue(hk,NULL,REG_SZ, lpName, dwLen);
               RegCloseKey(hk);
            }
            RegCloseKey(hkApp);
            bRet = TRUE; // success! (maybe)
         }
         RegCloseKey(hkLabels);
      }
      RegCloseKey(hkApps);
   }
   return bRet;
}