1685 lines
39 KiB
C++
1685 lines
39 KiB
C++
|
|
//+=======================================================================
|
|
//
|
|
// File: CMoniker.cxx
|
|
//
|
|
// Purpose: Define the CMoniker class.
|
|
//
|
|
// This class provides for all handling of monikers in
|
|
// the CreateFileMonikerEx DRT. Not only does it maintain
|
|
// a file moniker, it also maintains the represented link
|
|
// source file, and a bind context.
|
|
//
|
|
//+=======================================================================
|
|
|
|
// --------
|
|
// Includes
|
|
// --------
|
|
|
|
#define _DCOM_ // Allow DCOM extensions (e.g., CoInitializeEx).
|
|
|
|
#include <windows.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <wchar.h>
|
|
#include <wtypes.h>
|
|
#include <oaidl.h>
|
|
#include <dsys.h>
|
|
#include <olecairo.h>
|
|
#include "CFMEx.hxx"
|
|
#include "CMoniker.hxx"
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::CMoniker
|
|
//
|
|
// Synopsis: Simply initialize all member variables.
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Outputs: N/A
|
|
//
|
|
// Effects: Members are defaulted/initialized.
|
|
//
|
|
//+-------------------------------------------------------------------------
|
|
|
|
|
|
CMoniker::CMoniker()
|
|
{
|
|
*m_wszSystemTempPath = L'\0';
|
|
*m_wszTemporaryStorage = L'\0';
|
|
m_pIMoniker = NULL;
|
|
m_pIBindCtx = NULL;
|
|
m_pIStorage = NULL;
|
|
*m_wszErrorMessage = L'\0';
|
|
m_dwTrackFlags = 0L;
|
|
m_hkeyLinkTracking = NULL;
|
|
m_hr = 0L;
|
|
m_bSuppressErrorMessages = FALSE;
|
|
m_pcDirectoryOriginal = NULL;
|
|
m_pcDirectoryFinal = NULL;
|
|
|
|
return;
|
|
|
|
} // CMoniker::CMoniker()
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::~CMoniker
|
|
//
|
|
// Synopsis: Release any COM objects.
|
|
//
|
|
// Inputs: N/A
|
|
//
|
|
// Outputs: N/A
|
|
//
|
|
// Effects: All COM objects are released.
|
|
//
|
|
//+--------------------------------------------------------------------------
|
|
|
|
|
|
CMoniker::~CMoniker()
|
|
{
|
|
if( m_pIMoniker )
|
|
{
|
|
m_pIMoniker->Release();
|
|
m_pIMoniker = NULL;
|
|
}
|
|
|
|
if( m_pIBindCtx )
|
|
{
|
|
m_pIBindCtx->Release();
|
|
m_pIBindCtx = NULL;
|
|
}
|
|
|
|
if( m_pIStorage )
|
|
{
|
|
m_pIStorage->Release();
|
|
m_pIStorage = NULL;
|
|
}
|
|
|
|
return;
|
|
|
|
} // CMoniker::~CMoniker()
|
|
|
|
|
|
//+-----------------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::Initialize
|
|
//
|
|
// Synopsis: Keep pointers to the CDirectory objects passed in.
|
|
//
|
|
// Inputs: A CDirectory object for the original link source file location
|
|
// A CDirectory object for the final location
|
|
//
|
|
// Outputs: TRUE if successful, FALSE otherwise.
|
|
//
|
|
// Effects: The member CDirectory objects are set.
|
|
//
|
|
//+-----------------------------------------------------------------------
|
|
|
|
|
|
BOOL CMoniker::Initialize( const CDirectory& cDirectoryOriginal,
|
|
const CDirectory& cDirectoryFinal )
|
|
{
|
|
m_hr = S_OK;
|
|
|
|
m_pcDirectoryOriginal = &cDirectoryOriginal;
|
|
m_pcDirectoryFinal = &cDirectoryFinal;
|
|
|
|
return( TRUE ); // Success
|
|
|
|
} // CMoniker::Initialize()
|
|
|
|
|
|
//+-----------------------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::CreateFileMonikerEx
|
|
//
|
|
// Synopsis: Create a tracking file moniker. But before doing so, initialize
|
|
// the Bind Context, and create a link source file.
|
|
//
|
|
// Inputs: Track Flags (from the TRACK_FLAGS defines)
|
|
//
|
|
// Outputs: TRUE if successful, FALSE otherwise.
|
|
//
|
|
// Effects: The member bind context is initialized, and a link
|
|
// source file is created.
|
|
//
|
|
//+-----------------------------------------------------------------------------
|
|
|
|
|
|
BOOL CMoniker::CreateFileMonikerEx( DWORD dwTrackFlags )
|
|
{
|
|
|
|
// ---------------
|
|
// Local Variables
|
|
// ---------------
|
|
|
|
// Assume failure
|
|
BOOL bSuccess = FALSE;
|
|
|
|
// -----
|
|
// Begin
|
|
// -----
|
|
|
|
// Initialize the error code.
|
|
|
|
m_hr = S_OK;
|
|
|
|
// Free any existing IMoniker.
|
|
|
|
if( m_pIMoniker )
|
|
{
|
|
m_pIMoniker->Release();
|
|
m_pIMoniker = NULL;
|
|
}
|
|
|
|
// Initialize the bind context.
|
|
|
|
if( !InitializeBindContext() )
|
|
EXIT( L"Could not initialize the bind context" );
|
|
|
|
// Create a root storage for use as a link source.
|
|
|
|
if( !CreateTemporaryStorage() )
|
|
EXIT( L"Could not create temporary Storage" );
|
|
|
|
// Create a tracking File Moniker on that root storage.
|
|
|
|
m_hr = ::CreateFileMonikerEx( dwTrackFlags, m_wszTemporaryStorage, &m_pIMoniker );
|
|
EXIT_ON_FAILED( L"Failed CreateFileMonikerEx" );
|
|
|
|
|
|
bSuccess = TRUE;
|
|
|
|
// ----
|
|
// Exit
|
|
// ----
|
|
|
|
Exit:
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::CreateFileMonikerEx" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::CreateFileMonikerEx()
|
|
|
|
|
|
//+---------------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::SaveDeleteLoad
|
|
//
|
|
// Synopsis: This function exercises a moniker's IPersistStream interface.
|
|
// It creates saves the member moniker's persistent state to
|
|
// a stream, deletes the moniker, and then re-creates it
|
|
// using CreateFileMoniker (no Ex, so it's not a tracking
|
|
// file moniker). It then re-loads the original moniker's
|
|
// persistent state.
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Outputs: TRUE if successful, FALSE otherwise.
|
|
//
|
|
// Effects: The member moniker is deleted, re-created, and re-loaded.
|
|
//
|
|
//+---------------------------------------------------------------------
|
|
|
|
|
|
BOOL CMoniker::SaveDeleteLoad()
|
|
{
|
|
// ---------------
|
|
// Local Variables
|
|
// ---------------
|
|
|
|
// Assume failure
|
|
BOOL bSuccess = FALSE;
|
|
HRESULT hr = E_FAIL;
|
|
|
|
IStream* pStream = NULL;
|
|
IPersistStream* pIPersistStream = NULL;
|
|
LARGE_INTEGER li;
|
|
ULARGE_INTEGER uli;
|
|
|
|
// -----
|
|
// Begin
|
|
// -----
|
|
|
|
// Initialize the error code.
|
|
|
|
m_hr = S_OK;
|
|
|
|
// Verify that we have a member moniker.
|
|
|
|
if( !m_pIMoniker )
|
|
EXIT( L"Attempt to run SaveDeleteLoad test without an existing file moniker" );
|
|
|
|
|
|
// ------------------------
|
|
// Save the moniker's state
|
|
// ------------------------
|
|
|
|
// Get the moniker's IPersistStream interface
|
|
|
|
m_hr = m_pIMoniker->QueryInterface( IID_IPersistStream, (void **) &pIPersistStream );
|
|
EXIT_ON_FAILED( L"Failed 1st IMoniker::QueryInterface(IPersistStream)" );
|
|
|
|
// Create a stream
|
|
|
|
hr = CreateStreamOnHGlobal( NULL, // Auto alloc
|
|
TRUE, // Delete on release
|
|
&pStream );
|
|
EXIT_ON_FAILED( L"Failed CreateStreamOnHGlobal()" );
|
|
|
|
// Save the moniker's state to this stream.
|
|
|
|
hr = pIPersistStream->Save( pStream, TRUE /* Clear dirty*/ );
|
|
EXIT_ON_FAILED( L"Failed IPersistStream::Save()" );
|
|
|
|
// ------------------
|
|
// Delete the moniker
|
|
// ------------------
|
|
|
|
// Release all interfaces for the moniker.
|
|
|
|
m_pIMoniker->Release();
|
|
pIPersistStream->Release();
|
|
|
|
m_pIMoniker = NULL;
|
|
pIPersistStream = NULL;
|
|
|
|
// --------------------
|
|
// Create a new moniker
|
|
// --------------------
|
|
|
|
// Create a new moniker, using the non-Ex version of the function.
|
|
|
|
m_hr = ::CreateFileMoniker( m_wszTemporaryStorage, &m_pIMoniker );
|
|
EXIT_ON_FAILED( L"Failed CreateFileMoniker()" );
|
|
|
|
// --------------------
|
|
// Load the new moniker
|
|
// --------------------
|
|
|
|
// Get the IPersisStream interface
|
|
|
|
m_hr = m_pIMoniker->QueryInterface( IID_IPersistStream, (void **) &pIPersistStream );
|
|
EXIT_ON_FAILED( L"Failed 2nd IMoniker::QueryInterface(IPersistStream)" );
|
|
|
|
// Re-seek the stream to the beginning.
|
|
|
|
li.LowPart = li.HighPart = 0L;
|
|
hr = pStream->Seek( li, STREAM_SEEK_SET, &uli );
|
|
EXIT_ON_FAILED( L"Failed IStream::Seek()" );
|
|
if( uli.LowPart || uli.HighPart ) EXIT( L"Incorrect IStream::Seek()" );
|
|
|
|
// Re-load the moniker from the stream.
|
|
|
|
m_hr = pIPersistStream->Load( pStream );
|
|
EXIT_ON_FAILED( L"Failed IPersistStream::Load()" );
|
|
|
|
|
|
bSuccess = TRUE;
|
|
|
|
// ----
|
|
// Exit
|
|
// ----
|
|
|
|
Exit:
|
|
|
|
// Clean up the stream and the IPersistStream interface.
|
|
|
|
if( pStream )
|
|
pStream->Release;
|
|
|
|
if( pIPersistStream )
|
|
pIPersistStream->Release();
|
|
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::SaveDeleteLoad()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::SaveDeleteLoad()
|
|
|
|
|
|
//+------------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::ComposeWith
|
|
//
|
|
// Synopsis: Compose a tracking moniker with a non-tracking moniker
|
|
// on the right. (The resulting moniker should be tracking,
|
|
// but this is not relevant to this function; that is, whether
|
|
// or not the composed moniker is tracking, this function will
|
|
// succeed.)
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Output: TRUE if successful, FALSE otherwise.
|
|
//
|
|
// Effects: The member moniker is deleted, then recreated.
|
|
//
|
|
//+------------------------------------------------------------------
|
|
|
|
BOOL CMoniker::ComposeWith()
|
|
{
|
|
|
|
// ---------------
|
|
// Local Variables
|
|
// ---------------
|
|
|
|
BOOL bSuccess = FALSE;
|
|
|
|
IMoniker* pmkrFirst = NULL;
|
|
IMoniker* pmkrSecond = NULL;
|
|
HRESULT hr = E_FAIL;
|
|
|
|
WCHAR wszDirectoryName[ MAX_PATH + sizeof( L'\0' ) ];
|
|
WCHAR* wszFileName = NULL;
|
|
|
|
// -----
|
|
// Begin
|
|
// -----
|
|
|
|
// Initiailize the error code.
|
|
|
|
m_hr = S_OK;
|
|
|
|
// If we have a moniker already, delete it.
|
|
|
|
if( m_pIMoniker )
|
|
{
|
|
m_pIMoniker->Release();
|
|
m_pIMoniker = NULL;
|
|
}
|
|
|
|
// Verify we already have a link source file created.
|
|
|
|
if( !wcslen( m_wszTemporaryStorage ) )
|
|
EXIT( L"Attempt to use ComposeWith without first creating a link source.\n" );
|
|
|
|
// -----------------------------------------------
|
|
// Create a tracking and non-tracking file moniker
|
|
// -----------------------------------------------
|
|
|
|
// Parse the storage's filename into a path and a file ...
|
|
// for example, "C:\Temp\file.tmp" would become
|
|
// "C:\Temp" and "file.tmp".
|
|
//
|
|
// First, make a copy of the storage's complete path name,
|
|
// then replace the last '\\' with a '\0', thus creating two
|
|
// strings.
|
|
|
|
wcscpy( wszDirectoryName, m_wszTemporaryStorage );
|
|
wszFileName = wcsrchr( wszDirectoryName, L'\\' );
|
|
*wszFileName = L'\0';
|
|
wszFileName++;
|
|
|
|
// Create a tracking file moniker using the directory name.
|
|
|
|
m_hr = ::CreateFileMonikerEx( 0L, wszDirectoryName, &pmkrFirst );
|
|
EXIT_ON_FAILED( L"Failed 1st CreateFileMoniker()" );
|
|
|
|
// Create a non-tracking file moniker using the file name.
|
|
|
|
m_hr = ::CreateFileMoniker( wszFileName, &pmkrSecond );
|
|
EXIT_ON_FAILED( L"Failed 2nd CreateFileMoniker()" );
|
|
|
|
// -------
|
|
// Compose
|
|
// -------
|
|
|
|
// Compose the directory name moniker (on the left) with the file name moniker
|
|
// (on the right). Put the result in the member moniker.
|
|
|
|
m_hr = pmkrFirst->ComposeWith( pmkrSecond, TRUE, &m_pIMoniker );
|
|
EXIT_ON_FAILED( L"Failed IMoniker::ComposeWith" );
|
|
|
|
|
|
bSuccess = TRUE;
|
|
|
|
// ----
|
|
// Exit
|
|
// ----
|
|
|
|
Exit:
|
|
|
|
// Clean up the intermediary monikers.
|
|
|
|
if( pmkrFirst )
|
|
pmkrFirst->Release();
|
|
|
|
if( pmkrSecond )
|
|
pmkrSecond->Release();
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::ComposeWith()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::ComposeWith()
|
|
|
|
|
|
//+--------------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::CreateTemporaryStorage
|
|
//
|
|
// Synopsis: This function creates a Structured Storage
|
|
// in the directory identified by m_cDirectoryOriginal.
|
|
// The name of the file is randomly generated by the system,
|
|
// but begins with "MKR" and has the extension ".tmp".
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Output: TRUE if successful, FALSE otherwise.
|
|
//
|
|
// Effects: Stores the Structure Storage's name in
|
|
// m_wszTemporaryStorageName, and releases m_pIStorage if
|
|
// it is currently set.
|
|
//
|
|
//+--------------------------------------------------------------------
|
|
|
|
|
|
BOOL CMoniker::CreateTemporaryStorage()
|
|
{
|
|
// ---------------
|
|
// Local Variables
|
|
// ---------------
|
|
|
|
BOOL bSuccess = FALSE;
|
|
|
|
DWORD dwError = 0L;
|
|
UINT nError = 0;
|
|
|
|
|
|
// -----
|
|
// Begin
|
|
// -----
|
|
|
|
m_hr = S_OK;
|
|
|
|
// Delete any existing storage.
|
|
|
|
if( wcslen( m_wszTemporaryStorage ))
|
|
{
|
|
if( !DeleteTemporaryStorage() )
|
|
EXIT( L"Could not delete the existing temporary storage" );
|
|
}
|
|
|
|
// Generate a temporary filename.
|
|
|
|
nError = GetTempFileName( m_pcDirectoryOriginal->GetDirectoryName(),
|
|
L"MKR", // Prefix string.
|
|
0, // Generate random number,
|
|
m_wszTemporaryStorage );
|
|
if( nError == 0 )
|
|
{
|
|
m_hr = (HRESULT) GetLastError();
|
|
EXIT( L"Failed GetTempFileName()" );
|
|
}
|
|
|
|
// Create a root Storage.
|
|
|
|
m_hr = StgCreateDocfile( m_wszTemporaryStorage,
|
|
STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT,
|
|
0L, // Reserved
|
|
&m_pIStorage );
|
|
EXIT_ON_FAILED( L"Failed StgCreateDocfile()" );
|
|
|
|
|
|
// Release the storage.
|
|
|
|
m_pIStorage->Release();
|
|
m_pIStorage = NULL;
|
|
|
|
bSuccess = TRUE;
|
|
|
|
// ----
|
|
// Exit
|
|
// ----
|
|
|
|
Exit:
|
|
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::CreateTemporaryStorage()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::CreateTemporaryStorage()
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::RenameTemporaryStorage
|
|
//
|
|
// Synopsis: Rename the link source file (who's name is in m_wszTemporaryStorage)
|
|
// to the m_cDirectoryFinal directory, with a new name.
|
|
// The current name is "MKR#.tmp" (where "#" is a random number
|
|
// generated by the system), and the new name is "RKM#.tmp" (where
|
|
// "#" is the same random number). (We must rename the base file
|
|
// name, rather than its extension, because otherwise the default
|
|
// link-tracking would fail (it would only score the renamed file
|
|
// a 32 - by matching the file extension the score is 40.)
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Output: TRUE if successful, FALSE otherwise.
|
|
//
|
|
// Effects: The link source file is renamed, and it's new name is
|
|
// put into m_wszTemporaryStorage.
|
|
//
|
|
//+-------------------------------------------------------------------------
|
|
|
|
|
|
BOOL CMoniker::RenameTemporaryStorage()
|
|
{
|
|
// ---------------
|
|
// Local Variables
|
|
// ---------------
|
|
|
|
BOOL bSuccess = FALSE;
|
|
int nError = 0;
|
|
|
|
WCHAR wszNewName[ MAX_PATH + sizeof( L'\0' ) ];
|
|
WCHAR* wszOldFileName;
|
|
WCHAR wszNewFileName[ MAX_PATH + sizeof( L'\0' ) ];
|
|
|
|
char szOldName[ MAX_PATH + sizeof( L'\0' ) ];
|
|
char szNewName[ MAX_PATH + sizeof( L'\0' ) ];
|
|
|
|
|
|
// -----
|
|
// Begin
|
|
// -----
|
|
|
|
m_hr = S_OK;
|
|
|
|
// Verify that we already have a link source created.
|
|
|
|
if( !wcslen( m_wszTemporaryStorage ))
|
|
EXIT( L"No temporary storage to rename." );
|
|
|
|
// Locate the file name within the complete path.
|
|
// (E.g., find the "foo.txt" in "C:\TEMP\foot.txt".)
|
|
|
|
wszOldFileName = wcsrchr( m_wszTemporaryStorage, L'\\' );
|
|
if( !wszOldFileName )
|
|
EXIT( L"Could not extract old file name from temporary storage name\n" );
|
|
wszOldFileName++; // Get past the '\\'
|
|
|
|
// Generate the new file name (change "MKR" to "RKM").
|
|
|
|
wcscpy( wszNewFileName, wszOldFileName );
|
|
|
|
wszNewFileName[0] = L'R';
|
|
wszNewFileName[1] = L'K';
|
|
wszNewFileName[2] = L'M';
|
|
|
|
// Generate the complete path spec of the new file.
|
|
|
|
wcscpy( wszNewName, m_pcDirectoryFinal->GetDirectoryName() );
|
|
wcscat( wszNewName, wszNewFileName );
|
|
|
|
|
|
// Convert the new and old file names to ANSI.
|
|
|
|
if( m_hr = UnicodeToAnsi( m_wszTemporaryStorage, szOldName, sizeof( szOldName )) )
|
|
{
|
|
EXIT( L"Could not convert convert Unicode to Ansi for old name" );
|
|
}
|
|
|
|
if( m_hr = UnicodeToAnsi( wszNewName, szNewName, sizeof( szNewName )) )
|
|
{
|
|
EXIT( L"Could not convert convert Unicode to Ansi for new name" );
|
|
}
|
|
|
|
|
|
// Rename the file.
|
|
|
|
nError = rename( szOldName, szNewName );
|
|
if( nError )
|
|
{
|
|
m_hr = (HRESULT) errno;
|
|
EXIT( L"Failed rename()" );
|
|
}
|
|
|
|
// Record the new name.
|
|
|
|
wcscpy( m_wszTemporaryStorage, wszNewName );
|
|
|
|
|
|
bSuccess = TRUE;
|
|
|
|
// ----
|
|
// Exit
|
|
// ----
|
|
|
|
Exit:
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::RenameTemporaryStorage()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::RenameTemporaryStorage()
|
|
|
|
|
|
//+--------------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::DeleteTemporaryStorage
|
|
//
|
|
// Synopsis: Delete the temporary storage that this object uses
|
|
// as a link source for the moniker. The name of the
|
|
// storage is in m_wszTemporaryStorage.
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Output: TRUE if successful, FALSE otherwise.
|
|
//
|
|
// Effects: The link source file is deleted, and m_wszTemporaryStorage
|
|
// is set to a NULL string.
|
|
//
|
|
//+--------------------------------------------------------------------
|
|
|
|
|
|
BOOL CMoniker::DeleteTemporaryStorage()
|
|
{
|
|
// ---------------
|
|
// Local Variables
|
|
// ---------------
|
|
|
|
BOOL bSuccess = FALSE;
|
|
|
|
int nError = 0;
|
|
CHAR szTemporaryStorage[ MAX_PATH + sizeof( '\0' ) ];
|
|
|
|
// -----
|
|
// Begin
|
|
// -----
|
|
|
|
m_hr = S_OK;
|
|
|
|
// Don't do anything if we have no file (don't report an
|
|
// error either; the caller wants the file deleted, and it's
|
|
// already not there).
|
|
|
|
if( wcslen( m_wszTemporaryStorage ))
|
|
{
|
|
|
|
// Get the file name in ANSI.
|
|
|
|
if( m_hr = UnicodeToAnsi( m_wszTemporaryStorage, szTemporaryStorage, sizeof( szTemporaryStorage )))
|
|
EXIT( L"Could not convert unicode path to ANSI path" );
|
|
|
|
// Delete the file.
|
|
|
|
nError = unlink( szTemporaryStorage );
|
|
if( nError )
|
|
{
|
|
m_hr = (HRESULT) errno;
|
|
EXIT( L"Failed unlink()" );
|
|
}
|
|
|
|
// Clear the file name.
|
|
|
|
wcscpy( m_wszTemporaryStorage, L"" );
|
|
}
|
|
|
|
bSuccess = TRUE;
|
|
|
|
// ----
|
|
// Exit
|
|
// ----
|
|
|
|
Exit:
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::DeleteTemporaryStorage()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::DeleteTemporaryStorage()
|
|
|
|
|
|
|
|
|
|
//+-----------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::Reduce
|
|
//
|
|
// Synopsis: Perform a IMoniker::Reduce on the member moniker.
|
|
//
|
|
// Inputs: - Number of ticks until the deadline for completion of
|
|
// the operation.
|
|
// - A buffer into which to put the reduced IMoniker*
|
|
// (may be NULL).
|
|
//
|
|
// Output: TRUE if successful, FALSE otherwise.
|
|
//
|
|
// Effects: None.
|
|
//
|
|
//+-----------------------------------------------------------------
|
|
|
|
|
|
BOOL CMoniker::Reduce( DWORD dwDelay, IMoniker** ppmkReturn )
|
|
{
|
|
// ---------------
|
|
// Local Variables
|
|
// ---------------
|
|
|
|
BOOL bSuccess = FALSE;
|
|
IMoniker* pmkReduced = NULL;
|
|
BIND_OPTS2 bind_opts;
|
|
bind_opts.cbStruct = sizeof( BIND_OPTS2 );
|
|
|
|
// -----
|
|
// Begin
|
|
// -----
|
|
|
|
m_hr = S_OK;
|
|
|
|
// ----------
|
|
// Initialize
|
|
// ----------
|
|
|
|
// Initialize the return buffer, if extant.
|
|
|
|
if( ppmkReturn )
|
|
*ppmkReturn = NULL;
|
|
|
|
// Validate our state.
|
|
|
|
if( !m_pIMoniker )
|
|
EXIT( L"No moniker exists to be reduced" );
|
|
|
|
// ----------------
|
|
// Set the deadline
|
|
// ----------------
|
|
|
|
// Get the BIND_OPTS from the bind context.
|
|
|
|
m_hr = m_pIBindCtx->GetBindOptions( (LPBIND_OPTS) &bind_opts );
|
|
EXIT_ON_FAILED( L"Failed IBindCtx::GetBindOptions" );
|
|
|
|
// Determine what the tick count of the deadline is.
|
|
|
|
if( dwDelay == INFINITE )
|
|
{
|
|
bind_opts.dwTickCountDeadline = 0;
|
|
}
|
|
else
|
|
{
|
|
bind_opts.dwTickCountDeadline = GetTickCount() + dwDelay;
|
|
|
|
// Make sure the resulting tick count is not 0 (indicating no
|
|
// deadline).
|
|
|
|
if( bind_opts.dwTickCountDeadline == 0 )
|
|
bind_opts.dwTickCountDeadline++;
|
|
}
|
|
|
|
// Put the resulting BIND_OPTS back into the bind context.
|
|
|
|
m_hr = m_pIBindCtx->SetBindOptions( (LPBIND_OPTS) &bind_opts );
|
|
EXIT_ON_FAILED( L"Failed IBindCtx::SetBindOptions" );
|
|
|
|
|
|
// ------------------
|
|
// Reduce the Moniker
|
|
// ------------------
|
|
|
|
m_hr = m_pIMoniker->Reduce( m_pIBindCtx,
|
|
MKRREDUCE_ALL,
|
|
NULL,
|
|
&pmkReduced );
|
|
EXIT_ON_FAILED( L"Failed IMoniker::Reduce" );
|
|
|
|
// Return the reduced moniker to the caller (if so requested).
|
|
|
|
if( ppmkReturn )
|
|
{
|
|
// Transfer responsibility for the release to the caller.
|
|
*ppmkReturn = pmkReduced;
|
|
pmkReduced = NULL;
|
|
}
|
|
|
|
bSuccess = TRUE;
|
|
|
|
// ----
|
|
// Exit
|
|
// ----
|
|
|
|
Exit:
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::Reduce()" );
|
|
|
|
if( pmkReduced )
|
|
pmkReduced->Release();
|
|
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::Reduce()
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::GetDisplayName
|
|
//
|
|
// Synopsis: Get the moniker's display name.
|
|
//
|
|
// Inputs: A Unicode buffer for the display name, and (optionally)
|
|
// a moniker from which to get the display name. If such
|
|
// a moniker is not provided by the caller, then the member
|
|
// moniker is used.
|
|
//
|
|
// The unicode buffer must be long enough for MAX_PATH characters
|
|
// and a terminating NULL.
|
|
//
|
|
// Outputs: TRUE if successful, FALSE otherwise.
|
|
//
|
|
// Effects: None.
|
|
//
|
|
//+----------------------------------------------------------------------
|
|
|
|
|
|
BOOL CMoniker::GetDisplayName( WCHAR * wszDisplayName, IMoniker* pmnkCaller )
|
|
{
|
|
// ---------------
|
|
// Local Variables
|
|
// ---------------
|
|
|
|
BOOL bSuccess = FALSE;
|
|
|
|
WCHAR* wszReturnedDisplayName = NULL;
|
|
IMoniker* pmnk = NULL;
|
|
|
|
// -----
|
|
// Begin
|
|
// -----
|
|
|
|
m_hr = NOERROR;
|
|
|
|
// Determine which moniker to use, the caller-specified one or
|
|
// the member one.
|
|
|
|
if( pmnkCaller != NULL )
|
|
pmnk = pmnkCaller;
|
|
else
|
|
pmnk = m_pIMoniker;
|
|
|
|
if( !pmnk )
|
|
EXIT( L"Attempt to GetDisplayName on NULL moniker" );
|
|
|
|
// Get the display name from the moniker.
|
|
|
|
m_hr = pmnk->GetDisplayName( m_pIBindCtx,
|
|
NULL,
|
|
&wszReturnedDisplayName );
|
|
EXIT_ON_FAILED( L"Failed IMoniker::GetDisplayName()" );
|
|
|
|
if( wcslen( wszReturnedDisplayName ) > MAX_UNICODE_PATH )
|
|
EXIT( L"IMoniker::GetDisplayName() returned a path which was too long" );
|
|
|
|
// Copy the display name into the caller's buffer, and free it.
|
|
|
|
wcscpy( wszDisplayName, wszReturnedDisplayName );
|
|
|
|
|
|
bSuccess = TRUE;
|
|
|
|
// ----
|
|
// Exit
|
|
// ----
|
|
|
|
Exit:
|
|
|
|
if( wszReturnedDisplayName )
|
|
{
|
|
CoTaskMemFree( wszReturnedDisplayName );
|
|
wszReturnedDisplayName = NULL;
|
|
}
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::GetDisplayName()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::GetDisplayName()
|
|
|
|
|
|
//+-------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::InitializeBindContext
|
|
//
|
|
// Synopsis: Create a new bind context, and store it
|
|
// in a member pointer.
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Output: TRUE if successful, FALSE otherwise.
|
|
//
|
|
// Effects: Updates m_pIBindCtx.
|
|
//
|
|
//+-------------------------------------------------------------
|
|
|
|
|
|
|
|
BOOL CMoniker::InitializeBindContext( )
|
|
{
|
|
// ---------------
|
|
// Local Variables
|
|
// ---------------
|
|
|
|
BOOL bSuccess = FALSE;
|
|
|
|
// -----
|
|
// Begin
|
|
// -----
|
|
|
|
m_hr = S_OK;
|
|
|
|
// Release the old bind context if we have one.
|
|
|
|
if( m_pIBindCtx )
|
|
m_pIBindCtx->Release();
|
|
|
|
// Create the new bind context.
|
|
|
|
m_hr = CreateBindCtx( 0L, &m_pIBindCtx );
|
|
EXIT_ON_FAILED( L"Failed CreateBindCtx()" );
|
|
|
|
|
|
bSuccess = TRUE;
|
|
|
|
// ----
|
|
// Exit
|
|
// ----
|
|
|
|
Exit:
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::InitializeBindContext()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::InitializeBindContext()
|
|
|
|
|
|
//+----------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::GetTimeOfLastChange
|
|
//
|
|
// Synopsis: Request the time-of-last-change from our member
|
|
// moniker.
|
|
//
|
|
// Inputs: A buffer into which to put the FILETIME.
|
|
//
|
|
// Output: TRUE if successful, FALSE otherwise.
|
|
//
|
|
// Effects: None.
|
|
//
|
|
//+----------------------------------------------------------------
|
|
|
|
|
|
BOOL CMoniker::GetTimeOfLastChange( FILETIME* pft )
|
|
{
|
|
// ---------------
|
|
// Local Variables
|
|
// ---------------
|
|
|
|
BOOL bSuccess = FALSE;
|
|
|
|
// -----
|
|
// Begin
|
|
// -----
|
|
|
|
m_hr = S_OK;
|
|
|
|
// Validate our state.
|
|
|
|
if( !m_pIMoniker )
|
|
EXIT( L"Cannot GetTimeOfLastChange on a NULL moniker" );
|
|
|
|
// Get the time from the moniker.
|
|
|
|
m_hr = m_pIMoniker->GetTimeOfLastChange( m_pIBindCtx,
|
|
NULL,
|
|
pft );
|
|
EXIT_ON_FAILED( L"Failed IMoniker::GetTimeOfLastChange()" );
|
|
|
|
|
|
bSuccess = TRUE;
|
|
|
|
// ----
|
|
// Exit
|
|
// ----
|
|
|
|
Exit:
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::GetTimeOfLastChange()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::GetTimeOfLastChange()
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::BindToStorage
|
|
//
|
|
// Synopsis: Bind our member moniker to its Structured Storage object.
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Outputs: TRUE if successful, FALSE otherwise.
|
|
//
|
|
// Effects: None.
|
|
//
|
|
//+------------------------------------------------------------------------
|
|
|
|
|
|
BOOL CMoniker::BindToStorage()
|
|
{
|
|
// ---------------
|
|
// Local Variables
|
|
// ---------------
|
|
|
|
BOOL bSuccess = FALSE;
|
|
BIND_OPTS2 bind_opts;
|
|
bind_opts.cbStruct = sizeof( BIND_OPTS2 );
|
|
|
|
// -----
|
|
// Begin
|
|
// -----
|
|
|
|
m_hr = S_OK;
|
|
|
|
// Validate our state.
|
|
|
|
if( !m_pIMoniker )
|
|
EXIT( L"Cannot GetTimeOfLastChange on a NULL moniker" );
|
|
|
|
// Release the IStorage interface if we have one.
|
|
|
|
if( m_pIStorage )
|
|
{
|
|
m_pIStorage->Release();
|
|
m_pIStorage = NULL;
|
|
}
|
|
|
|
// Get the bind_opts and set the flags for StgOpenStorage.
|
|
|
|
m_hr = m_pIBindCtx->GetBindOptions( (LPBIND_OPTS) &bind_opts );
|
|
EXIT_ON_FAILED( L"Failed IBindCtx::GetBindOptions" );
|
|
|
|
bind_opts.grfMode = STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT;
|
|
|
|
m_hr = m_pIBindCtx->SetBindOptions( (LPBIND_OPTS) &bind_opts );
|
|
EXIT_ON_FAILED( L"Failed IBindCtx::SetBindOptions" );
|
|
|
|
|
|
// Bind to the storage.
|
|
|
|
m_hr = m_pIMoniker->BindToStorage( m_pIBindCtx,
|
|
NULL,
|
|
IID_IStorage,
|
|
(void **) &m_pIStorage );
|
|
EXIT_ON_FAILED( L"Failed IMoniker::BindToStorage()" );
|
|
|
|
|
|
bSuccess = TRUE;
|
|
|
|
// ----
|
|
// Exit
|
|
// ----
|
|
|
|
Exit:
|
|
|
|
// Release the Storage if we got it.
|
|
|
|
if( m_pIStorage )
|
|
{
|
|
m_pIStorage->Release();
|
|
m_pIStorage = NULL;
|
|
}
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::BindToStorage()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::BindToStorage()
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::BindToObject
|
|
//
|
|
// Synopsis: Bind to our member moniker's object.
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Outputs: TRUE if successful, FALSE otherwise.
|
|
//
|
|
// Effects: None.
|
|
//
|
|
// Notes: Since the member moniker represents a storage with no
|
|
// associated server, BindToObject will fail. We will
|
|
// consider it a success if the failure is do to an
|
|
// object-related problem, rather than a Storage-related
|
|
// problem.
|
|
//
|
|
//+-------------------------------------------------------------------
|
|
|
|
BOOL CMoniker::BindToObject()
|
|
{
|
|
// ---------------
|
|
// Local Variables
|
|
// ---------------
|
|
|
|
BOOL bSuccess = FALSE;
|
|
IUnknown* pUnk = NULL;
|
|
|
|
// -----
|
|
// Begin
|
|
// -----
|
|
|
|
m_hr = S_OK;
|
|
|
|
// Validate our state.
|
|
|
|
if( !m_pIMoniker )
|
|
EXIT( L"Cannot bind to an object with a NULL moniker" );
|
|
|
|
// Bind to the object.
|
|
|
|
m_hr = m_pIMoniker->BindToObject( m_pIBindCtx,
|
|
NULL,
|
|
IID_IUnknown,
|
|
(void **) &pUnk );
|
|
|
|
// If the bind succeeded, or failed for a valid reason,
|
|
// then return Success to the caller.
|
|
|
|
if( SUCCEEDED( m_hr )
|
|
||
|
|
( m_hr = MK_E_INVALIDEXTENSION ) // No handler for ".tmp" files.
|
|
)
|
|
{
|
|
bSuccess = TRUE;
|
|
}
|
|
else
|
|
{
|
|
EXIT( L"Failed BindToObject" );
|
|
}
|
|
|
|
// ----
|
|
// Exit
|
|
// ----
|
|
|
|
Exit:
|
|
|
|
// If we got an IUnknown interface on the Bind, release it.
|
|
|
|
if( pUnk )
|
|
{
|
|
pUnk->Release();
|
|
pUnk = NULL;
|
|
}
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::BindToObject()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::BindToObject()
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::GetTemporaryStorageTime
|
|
//
|
|
// Synopsis: Get the time from the link source file
|
|
// (identified by m_wszTemporaryStorage).
|
|
//
|
|
// Inputs: A buffer in which to put the FILETIME structure.
|
|
//
|
|
// Outputs: TRUE if successful, FALSE otherwise.
|
|
//
|
|
// Effects: None.
|
|
//
|
|
//+-------------------------------------------------------------------
|
|
|
|
|
|
BOOL CMoniker::GetTemporaryStorageTime( FILETIME * pft)
|
|
{
|
|
// ---------------
|
|
// Local Variables
|
|
// ---------------
|
|
|
|
BOOL bSuccess = FALSE;
|
|
HANDLE hFile = NULL;
|
|
|
|
// -----
|
|
// Begin
|
|
// -----
|
|
|
|
m_hr = NOERROR;
|
|
|
|
// Get a handle to the file.
|
|
|
|
hFile = CreateFile( m_wszTemporaryStorage, // File name
|
|
GENERIC_READ, // Desired access
|
|
FILE_SHARE_READ, // Share mode
|
|
NULL, // Security attributes
|
|
OPEN_EXISTING, // Creation distribution
|
|
0L, // Flags & Attributes
|
|
NULL ); // hTemplateFile
|
|
if( hFile == NULL )
|
|
{
|
|
m_hr = (HRESULT) GetLastError();
|
|
EXIT( L"Failed call to CreateFile()" );
|
|
}
|
|
|
|
// Get the time on the file.
|
|
|
|
if( !GetFileTime( hFile, // File to check
|
|
NULL, // Create Time
|
|
NULL, // Access Time
|
|
pft ) // Write Time
|
|
)
|
|
{
|
|
m_hr = (HRESULT) GetLastError();
|
|
EXIT( L"Failed call to GetFileTime()" );
|
|
}
|
|
|
|
bSuccess = TRUE;
|
|
|
|
// ----
|
|
// Exit
|
|
// ----
|
|
|
|
Exit:
|
|
|
|
// Close the file if we opened it.
|
|
|
|
if( hFile )
|
|
{
|
|
CloseHandle( hFile );
|
|
hFile = NULL;
|
|
}
|
|
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::GetTemporaryStorageTime()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::GetTemporaryStorageTime()
|
|
|
|
|
|
//+------------------------------------------------------------------------
|
|
//
|
|
// Function: CMoniker::TouchTemporaryStorage
|
|
//
|
|
// Synopsis: Set the Access time on the link source file.
|
|
//
|
|
// Inputs: None.
|
|
//
|
|
// Output: TRUE if successful, FALSE otherwise.
|
|
//
|
|
// Effects: The link source file (identified by m_wszTemporaryStorage)
|
|
// has its Access time set to the current time.
|
|
//
|
|
//+------------------------------------------------------------------------
|
|
|
|
|
|
BOOL CMoniker::TouchTemporaryStorage( )
|
|
{
|
|
// ---------------
|
|
// Local Variables
|
|
// ---------------
|
|
|
|
BOOL bSuccess = FALSE;
|
|
HANDLE hFile = NULL;
|
|
STATSTG statStorage;
|
|
FILETIME ftNow;
|
|
|
|
// -----
|
|
// Begin
|
|
// -----
|
|
|
|
m_hr = NOERROR;
|
|
|
|
// Open the root Storage.
|
|
|
|
m_hr = StgOpenStorage( m_wszTemporaryStorage,
|
|
NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_DIRECT,
|
|
NULL,
|
|
0L,
|
|
&m_pIStorage );
|
|
EXIT_ON_FAILED( L"Failed StgOpenStorage()" );
|
|
|
|
// Get the current time.
|
|
|
|
m_hr = CoFileTimeNow( &ftNow );
|
|
EXIT_ON_FAILED( L"Failed CoFileTimeNow()" );
|
|
|
|
// Set the access time
|
|
|
|
m_pIStorage->SetElementTimes( NULL, // Set the storage itself
|
|
NULL, // Create time
|
|
NULL, // Access time
|
|
&ftNow );
|
|
EXIT_ON_FAILED( L"Failed IStorage::SetTimes()" );
|
|
|
|
|
|
bSuccess = TRUE;
|
|
|
|
// ----
|
|
// Exit
|
|
// ----
|
|
|
|
Exit:
|
|
|
|
// If we got the storage, release it.
|
|
|
|
if( m_pIStorage )
|
|
{
|
|
m_pIStorage->Release();
|
|
m_pIStorage = NULL;
|
|
}
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::TouchTemporaryStorage()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::TouchTemporaryStorage()
|
|
|
|
|
|
|
|
#ifdef _FUTURE_
|
|
|
|
/*
|
|
BOOL CMoniker::OpenLinkTrackingRegistryKey()
|
|
{
|
|
|
|
BOOL bSuccess = FALSE;
|
|
DWORD dwDisposition = 0L;
|
|
long lResult = 0L;
|
|
|
|
m_hr = S_OK;
|
|
|
|
lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
|
|
OLETRACKING_KEY,
|
|
0L,
|
|
KEY_ALL_ACCESS,
|
|
&m_hkeyLinkTracking
|
|
);
|
|
|
|
if( lResult != ERROR_SUCCESS
|
|
&&
|
|
lResult != ERROR_FILE_NOT_FOUND
|
|
)
|
|
{
|
|
m_hr = (HRESULT) lResult;
|
|
EXIT( L"Failed RegOpenKeyEx()" );
|
|
}
|
|
|
|
|
|
bSuccess = TRUE;
|
|
|
|
Exit:
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::OpenLinkTrackingRegistryKey()" );
|
|
return( bSuccess );
|
|
|
|
|
|
} // CMoniker::OpenLinkTrackingRegistryKey()
|
|
|
|
|
|
BOOL CMoniker::CreateLinkTrackingRegistryKey()
|
|
{
|
|
|
|
BOOL bSuccess = FALSE;
|
|
HKEY hkey = NULL;
|
|
DWORD dwDisposition = 0L;
|
|
long lResult = 0L;
|
|
|
|
m_hr = S_OK;
|
|
|
|
if( m_hkeyLinkTracking )
|
|
CloseLinkTrackingRegistryKey();
|
|
|
|
lResult = RegCreateKeyEx( HKEY_LOCAL_MACHINE,
|
|
OLETRACKING_KEY,
|
|
0L,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&m_hkeyLinkTracking,
|
|
&dwDisposition
|
|
);
|
|
|
|
if( lResult != ERROR_SUCCESS )
|
|
{
|
|
m_hr = (HRESULT) lResult;
|
|
EXIT( L"Failed RegCreateKeyEx()" );
|
|
}
|
|
|
|
bSuccess = TRUE;
|
|
|
|
Exit:
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::CreateLinkTrackingRegistryKey()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::CreateLinkTrackingRegistryKey()
|
|
|
|
|
|
|
|
BOOL CMoniker::CloseLinkTrackingRegistryKey()
|
|
{
|
|
m_hr = S_OK;
|
|
|
|
if( m_hkeyLinkTracking )
|
|
RegCloseKey( m_hkeyLinkTracking );
|
|
|
|
m_hkeyLinkTracking = NULL;
|
|
|
|
return TRUE;
|
|
|
|
} // CMoniker::CloseLinkTrackingRegistryKey()
|
|
|
|
|
|
|
|
BOOL CMoniker::SaveRegistryTrackFlags()
|
|
{
|
|
BOOL bSuccess = FALSE;
|
|
|
|
long lResult = 0L;
|
|
DWORD dwType = 0L;
|
|
DWORD dwcbData = sizeof( m_dwTrackFlags );
|
|
|
|
|
|
m_hr = S_OK;
|
|
|
|
if( !OpenLinkTrackingRegistryKey() )
|
|
EXIT( L"Could not open the registry" );
|
|
|
|
lResult = RegQueryValueEx( m_hkeyLinkTracking,
|
|
OLETRACKING_FILEMONIKER_VALUE,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE) &m_dwTrackFlags,
|
|
&dwcbData );
|
|
|
|
if( lResult != ERROR_SUCCESS )
|
|
{
|
|
CloseLinkTrackingRegistryKey();
|
|
|
|
if( lResult != ERROR_FILE_NOT_FOUND )
|
|
{
|
|
m_hr = (HRESULT) lResult;
|
|
EXIT( L"Failed RegQueryValueEx()" );
|
|
}
|
|
}
|
|
|
|
|
|
bSuccess = TRUE;
|
|
|
|
Exit:
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::SaveRegistryTrackFlags()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::SaveRegistryTrackFlags()
|
|
|
|
|
|
|
|
BOOL CMoniker::DeleteRegistryTrackFlags()
|
|
{
|
|
BOOL bSuccess = FALSE;
|
|
|
|
long lResult = 0L;
|
|
DWORD dwType = 0L;
|
|
DWORD dwcbData = sizeof( m_dwTrackFlags );
|
|
|
|
|
|
m_hr = S_OK;
|
|
|
|
if( !CreateLinkTrackingRegistryKey() )
|
|
EXIT( L"Could not open the registry" );
|
|
|
|
|
|
lResult = RegDeleteValue( m_hkeyLinkTracking,
|
|
OLETRACKING_FILEMONIKER_VALUE );
|
|
|
|
|
|
if( lResult != ERROR_SUCCESS
|
|
&&
|
|
lResult != ERROR_FILE_NOT_FOUND
|
|
)
|
|
{
|
|
if( lResult != ERROR_FILE_NOT_FOUND )
|
|
{
|
|
m_hr = (HRESULT) lResult;
|
|
EXIT( L"Failed RegDeleteValue()" );
|
|
}
|
|
}
|
|
|
|
bSuccess = TRUE;
|
|
|
|
Exit:
|
|
|
|
CloseLinkTrackingRegistryKey();
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::DeleteRegistryTrackFlags()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::DeleteRegistryTrackFlags()
|
|
|
|
|
|
|
|
BOOL CMoniker::RestoreRegistryTrackFlags()
|
|
{
|
|
BOOL bSuccess = FALSE;
|
|
long lResult = 0L;
|
|
|
|
|
|
m_hr = S_OK;
|
|
|
|
// If the registry key doesn't exist, then there's no flags
|
|
// to restore.
|
|
|
|
if( m_hkeyLinkTracking )
|
|
{
|
|
|
|
lResult = RegSetValueEx( m_hkeyLinkTracking,
|
|
OLETRACKING_FILEMONIKER_VALUE,
|
|
0L,
|
|
REG_DWORD,
|
|
(LPBYTE) &m_dwTrackFlags,
|
|
sizeof( m_dwTrackFlags )
|
|
);
|
|
|
|
if( lResult != ERROR_SUCCESS )
|
|
{
|
|
m_hr = (HRESULT) lResult;
|
|
EXIT( L"Failed RegSetValueEx()" );
|
|
}
|
|
|
|
CloseLinkTrackingRegistryKey();
|
|
|
|
}
|
|
|
|
|
|
bSuccess = TRUE;
|
|
|
|
Exit:
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::RestoreRegistryTrackFlags()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::RestoreRegistryTrackFlags()
|
|
|
|
CMoniker::SetTrackFlagsInRegistry( DWORD dwTrackFlags )
|
|
{
|
|
BOOL bSuccess = FALSE;
|
|
long lResult = 0L;
|
|
HKEY hkey = NULL;
|
|
|
|
|
|
m_hr = S_OK;
|
|
|
|
if( !CreateLinkTrackingRegistryKey() )
|
|
EXIT( L"Could not create registry key" );
|
|
|
|
lResult = RegSetValueEx( m_hkeyLinkTracking,
|
|
OLETRACKING_FILEMONIKER_VALUE,
|
|
0L,
|
|
REG_DWORD,
|
|
(LPBYTE) &dwTrackFlags,
|
|
sizeof( dwTrackFlags )
|
|
);
|
|
|
|
if( lResult != ERROR_SUCCESS )
|
|
{
|
|
m_hr = (HRESULT) lResult;
|
|
EXIT( L"Failed RegSetValueEx()" );
|
|
}
|
|
|
|
|
|
bSuccess = TRUE;
|
|
|
|
Exit:
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::SetTrackFlagsInRegistry()" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::SetTrackFlagsInRegistry()
|
|
|
|
|
|
BOOL CMoniker::CreateFileMoniker()
|
|
{
|
|
|
|
BOOL bSuccess = FALSE;
|
|
|
|
m_hr = S_OK;
|
|
|
|
// Free any existing IMoniker.
|
|
|
|
if( m_pIMoniker )
|
|
{
|
|
m_pIMoniker->Release();
|
|
m_pIMoniker = NULL;
|
|
}
|
|
|
|
// Create a root storage.
|
|
|
|
if( !CreateTemporaryStorage() )
|
|
EXIT( L"Could not create a temporary storage" );
|
|
|
|
// Create a default File Moniker on that root storage.
|
|
|
|
m_hr = ::CreateFileMoniker( m_wszTemporaryStorage, &m_pIMoniker );
|
|
EXIT_ON_FAILED( L"Failed CreateFileMoniker" );
|
|
|
|
|
|
bSuccess = TRUE;
|
|
|
|
|
|
Exit:
|
|
|
|
DisplayErrors( bSuccess, L"CMoniker::CreateFileMoniker" );
|
|
return( bSuccess );
|
|
|
|
} // CMoniker::CreateFileMoniker()
|
|
*/
|
|
#endif // _FUTURE_
|