able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/activec/nodemgr/colwidth.cpp

1937 lines
57 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1999
//
// File: colwidth.cpp
//
// Contents: Column Persistence data structures and property pages
// implementation.
//
// History: 16-Oct-98 AnandhaG Created
//
//--------------------------------------------------------------------------
#include "stdafx.h"
#include "colwidth.h"
#include "macros.h"
#include "comdbg.h"
#include "columninfo.h"
#define MAX_COLUMNS_PERSISTED 50
//+-------------------------------------------------------------------
//
// Class: ViewToColSetDataMapPersistor (wrapper, helper)
//
// Purpose: wraps ViewToColSetDataMap implementing XML persistence
// map is persisted as linear list
//
// see "Data structures used to persist column information" comment
// int file colwidth.h for more information
//--------------------------------------------------------------------
class ViewToColSetDataMapPersistor : public XMLListCollectionBase
{
public:
ViewToColSetDataMapPersistor(ViewToColSetDataMap &map, ColSetDataList &list)
: m_map(map), m_list(list) {}
DEFINE_XML_TYPE(XML_TAG_COLUMN_SET);
virtual void Persist(CPersistor &persistor);
virtual void OnNewElement(CPersistor& persistor);
private:
ViewToColSetDataMap &m_map; // wrapped map
ColSetDataList &m_list; // value list to persist actual information
};
//+-------------------------------------------------------------------
//
// Class: ColSetIDToViewTableMapPersistor (wrapper, helper)
//
// Purpose: wraps ColSetIDToViewTableMap implementing XML persistence
// map is persisted as linear list
//
// see "Data structures used to persist column information" comment
// int file colwidth.h for more information
//--------------------------------------------------------------------
class ColSetIDToViewTableMapPersistor : public XMLListCollectionBase
{
public:
ColSetIDToViewTableMapPersistor(ColSetIDToViewTableMap &map, ColSetDataList &list)
: m_map(map), m_list(list) {}
DEFINE_XML_TYPE(XML_TAG_COLUMN_PERIST_ENTRY);
virtual void Persist(CPersistor &persistor);
virtual void OnNewElement(CPersistor& persistor);
private:
ColSetIDToViewTableMap &m_map; // wrapped map
ColSetDataList &m_list; // value list to persist actual information
};
//+-------------------------------------------------------------------
//
// Class: SnapinToColSetIDMapPersistor (wrapper, helper)
//
// Purpose: wraps SnapinToColSetIDMap implementing XML persistence
// map is persisted as linear list
//
// see "Data structures used to persist column information" comment
// int file colwidth.h for more information
//--------------------------------------------------------------------
class SnapinToColSetIDMapPersistor : public XMLListCollectionBase
{
public:
SnapinToColSetIDMapPersistor(SnapinToColSetIDMap &map, ColSetDataList &list)
: m_map(map), m_list(list) {}
DEFINE_XML_TYPE(XML_TAG_COLUMN_PERIST_ENTRY);
virtual void Persist(CPersistor &persistor);
virtual void OnNewElement(CPersistor& persistor);
// prior-to-save cleanup
SC ScPurgeUnusedColumnData();
private:
SnapinToColSetIDMap &m_map; // wrapped map
ColSetDataList &m_list; // value list to persist actual information
};
//+-------------------------------------------------------------------
//
// Member: ReadSerialObject
//
// Synopsis: Read the given version of CColumnSortInfo object from
// the given stream.
//
// Arguments: [stm] - The input stream.
// [nVersion] - version of CColumnSortInfo to be read.
//
// The format is :
// INT column index
// DWORD Sort options
// ULONG_PTR Any user (snapin) param
//
//--------------------------------------------------------------------
HRESULT CColumnSortInfo::ReadSerialObject(IStream &stm, UINT nVersion /*,LARGE_INTEGER nBytes*/)
{
HRESULT hr = S_FALSE; // assume bad version
if (GetVersion() >= nVersion)
{
try
{
stm >> m_nCol;
// In version we stored just ascending or descending flag
if (1 == nVersion)
{
BYTE bAscend;
stm >> bAscend;
m_dwSortOptions |= (bAscend ? 0 : RSI_DESCENDING);
}
else if (nVersion > 1)
{
// Versions greater than 1 has these sort data which
// includes ascend/descend flags and a user param.
stm >> m_dwSortOptions;
stm >> m_lpUserParam;
}
hr = S_OK;
}
catch (_com_error& err)
{
hr = err.Error();
ASSERT (false && "Caught _com_error");
}
}
return (hr);
}
//+-------------------------------------------------------------------
//
// Member: CColumnSortInfo::Persist
//
// Synopsis: Persists object data
//
// Arguments:
//
// History: 10-10-1999 AudriusZ Created
//
//--------------------------------------------------------------------
void CColumnSortInfo::Persist(CPersistor &persistor)
{
persistor.PersistAttribute(XML_ATTR_COLUMN_SORT_INFO_COLMN, m_nCol) ;
static const EnumLiteral sortOptions[] =
{
{ RSI_DESCENDING, XML_BITFLAG_COL_SORT_DESCENDING },
{ RSI_NOSORTICON, XML_BITFLAG_COL_SORT_NOSORTICON },
};
CXMLBitFlags optionPersistor(m_dwSortOptions, sortOptions, countof(sortOptions));
persistor.PersistAttribute(XML_ATTR_COLUMN_SORT_INFO_OPTNS, optionPersistor) ;
}
//+-------------------------------------------------------------------
//
// Member: ReadSerialObject
//
// Synopsis: Reads CColumnSortList data from stream.
//
// Format: number of columns : each CColumnSortInfo entry.
//
// Arguments: [stm] - The input stream.
// [nVersion] - Version of CColumnSortList to be read.
//
//
//--------------------------------------------------------------------
HRESULT CColumnSortList::ReadSerialObject (IStream &stm, UINT nVersion /*,LARGE_INTEGER nBytes*/)
{
HRESULT hr = S_FALSE; // assume bad version
if (GetVersion() == nVersion)
{
try
{
// Number of columns.
DWORD dwCols;
stm >> dwCols;
clear();
for (int i = 0; i < dwCols; i++)
{
CColumnSortInfo colSortEntry;
// Read data into colSortEntry structure.
if (colSortEntry.Read(stm) != S_OK)
continue;
push_back(colSortEntry);
}
hr = S_OK;
}
catch (_com_error& err)
{
hr = err.Error();
ASSERT (false && "Caught _com_error");
}
}
return (hr);
}
/***************************************************************************\
*
* METHOD: CColumnSortList::Persist
*
* PURPOSE: persists object to XML
*
* PARAMETERS:
* CPersistor& persistor [in/out] persistor to persist under
*
* RETURNS:
* void
*
\***************************************************************************/
void CColumnSortList::PersistSortList(CPersistor& persistor)
{
DECLARE_SC(sc, TEXT("CColumnSortList::PersistSortList"));
if (persistor.IsLoading())
{
clear();
CColumnSortInfo sortInfo;
if (persistor.HasElement(sortInfo.GetXMLType(), NULL))
{
persistor.Persist(sortInfo);
insert(end(), sortInfo);
}
}
else
{
if (size() > 1)
sc.Throw(E_UNEXPECTED);
else if (size())
persistor.Persist(*begin());
}
}
//+-------------------------------------------------------------------
//
// Member: ReadSerialObject
//
// Synopsis: Read CColumnSetData data from the stream.
//
// Arguments: [stm] - The input stream.
// [nVersion] - Version of CColumnSetData structure.
//
// Format : CColumnInfoList : CColumnSortList
//
//
//--------------------------------------------------------------------
HRESULT CColumnSetData::ReadSerialObject (IStream &stm, UINT nVersion /*,LARGE_INTEGER nBytes*/)
{
HRESULT hr = S_FALSE; // assume bad version
if (GetVersion() == nVersion)
{
try
{
do // not a loop
{
// Read the rank
stm >> m_dwRank;
// Read the CColumnInfoList
hr = get_ColumnInfoList()->Read(stm);
if (hr != S_OK)
break;
// Read the CColumnSortList
hr = get_ColumnSortList()->Read(stm);
if (hr != S_OK)
break;
ASSERT (hr == S_OK);
} while (false);
}
catch (_com_error& err)
{
hr = err.Error();
ASSERT (false && "Caught _com_error");
}
}
return (hr);
}
//+-------------------------------------------------------------------
//
// Member: CColumnSetData::Persist
//
// Synopsis: Persists object data
//
// Arguments:
//
// History: 10-10-1999 AudriusZ Created
//
//--------------------------------------------------------------------
void CColumnSetData::Persist(CPersistor &persistor)
{
DECLARE_SC(sc, TEXT("CColumnSetData::Persist"));
sc = ScCheckPointers(get_ColumnInfoList(), get_ColumnSortList());
if (sc)
sc.Throw();
persistor.PersistAttribute(XML_ATTR_COLUMN_SET_RANK, m_dwRank);
// Write CColumnInfoList
persistor.Persist(*get_ColumnInfoList());
// Write CColumnSortList
get_ColumnSortList()->PersistSortList(persistor);
}
//------------------------------------------------------------------
// class CColumnPersistInfo
//------------------------------------------------------------------
CColumnPersistInfo::CColumnPersistInfo() :
m_bInitialized(FALSE), m_dwMaxItems(MAX_COLUMNS_PERSISTED),
m_bDirty(FALSE)
{
}
CColumnPersistInfo::~CColumnPersistInfo()
{
}
//+-------------------------------------------------------------------
//
// Member: RetrieveColumnData
//
// Synopsis: Copy and return the persisted column information
// for given column id and view id.
//
// Arguments: [refSnapinCLSID] - Snapin Guid
// [SColumnSetID] - Column Set Identifier.
// [nViewID] - View ID.
// [columnSetData] - CColumnSetData, used to return the
// persisted column information.
//
// Returns: TRUE - Loaded successfully.
//
// History: 10-16-1998 AnandhaG Created
//
//--------------------------------------------------------------------
BOOL CColumnPersistInfo::RetrieveColumnData( const CLSID& refSnapinCLSID,
const SColumnSetID& colID,
INT nViewID,
CColumnSetData& columnSetData)
{
BOOL bFound = FALSE;
// Make sure we are initialized.
if (!m_bInitialized && !Init())
{
ASSERT(FALSE);
return bFound;
}
// Construct CColumnSetID.
CColumnSetID colSetID(colID);
// Use the snapin clsid to get the ColSetIDToViewTableMap.
SnapinToColSetIDMap::iterator itSnapins;
itSnapins = m_spSnapinsMap->find(refSnapinCLSID);
if (itSnapins == m_spSnapinsMap->end())
return bFound;
// The ColSetIDToViewTableMap is a simple map.
ColSetIDToViewTableMap::iterator itColSetIDMap;
ColSetIDToViewTableMap& colSetIDMap = itSnapins->second;
// Get the data for colSetID.
itColSetIDMap = colSetIDMap.find(colSetID);
if (colSetIDMap.end() == itColSetIDMap)
return bFound;
ViewToColSetDataMap& viewData = itColSetIDMap->second;
ViewToColSetDataMap::iterator itViews;
// See if our view is present.
itViews = viewData.find(nViewID);
if (viewData.end() != itViews)
{
// Found the item.
bFound = TRUE;
ItColSetDataList itColSetData = itViews->second;
// Copy the data.
columnSetData = *itColSetData;
// So move this item to the top of the queue.
m_spColSetList->erase(itColSetData);
itColSetData = m_spColSetList->insert(m_spColSetList->begin(), columnSetData);
itViews->second = itColSetData;
}
return bFound;
}
//+-------------------------------------------------------------------
//
// Member: SaveColumnData
//
// Synopsis: Save/Modify the column information for persistence into
// CColumnPersistInfo.
//
// Arguments:
// [refSnapinCLSID] - Snapin Guid.
// [SColumnSetID] - Column Set Identifier.
// [nViewID] - View ID.
// [columnSetData] - CColumnSetData, Column data.
//
// Returns: TRUE - Saved successfully.
//
// History: 10-16-1998 AnandhaG Created
//
//--------------------------------------------------------------------
BOOL CColumnPersistInfo::SaveColumnData( const CLSID& refSnapinCLSID,
const SColumnSetID& colID,
INT nViewID,
CColumnSetData& columnSetData)
{
// Make sure we are init
if (!m_bInitialized && !Init())
{
ASSERT(FALSE);
return FALSE;
}
// Construct the CColumnSetID.
CColumnSetID colSetID(colID);
// Garbage collect if the number of items in the list is 40% more then pre-set limit.
if (m_spColSetList->size() >= (m_dwMaxItems * (1 + COLUMNS_MAXLIMIT)) )
GarbageCollectItems();
// Insert this item to the top of the queue.
ItColSetDataList itColData;
itColData = m_spColSetList->insert(m_spColSetList->begin(), columnSetData);
SnapinToColSetIDMap::iterator itSnapins;
itSnapins = m_spSnapinsMap->find(refSnapinCLSID);
if (itSnapins != m_spSnapinsMap->end())
{
// Snapin is already in the map.
// Look if the col-id is already inserted.
ColSetIDToViewTableMap::iterator itColSetIDMap;
ColSetIDToViewTableMap& colSetIDMap = itSnapins->second;
// Get the data for the colSetID.
itColSetIDMap = colSetIDMap.find(colSetID);
if (colSetIDMap.end() == itColSetIDMap)
{
// The column-id not found.
// So insert new one.
// Construct the view-id to column-data map
ViewToColSetDataMap viewIDMap;
viewIDMap.insert( ViewToColSetDataVal(nViewID, itColData) );
colSetIDMap.insert(ColSetIDToViewTableVal(colSetID, viewIDMap) );
}
else
{
// The data for Col-ID exists.
// find if the given view exists in the map.
ViewToColSetDataMap::iterator itViewIDMap;
ViewToColSetDataMap& viewIDMap = itColSetIDMap->second;
itViewIDMap = viewIDMap.find(nViewID);
if (viewIDMap.end() != itViewIDMap)
{
// The map from ViewID to column list exists.
// So delete the old data and insert new data
// at the top of the queue.
m_spColSetList->erase(itViewIDMap->second);
itViewIDMap->second = itColData;
}
else
{
// This view is not found.
// So insert new one.
viewIDMap.insert( ViewToColSetDataVal(nViewID, itColData) );
}
}
}
else
{
// Insert the snapin into the map.
// Construct the ViewID to column-data map.
ViewToColSetDataMap viewIDMap;
viewIDMap.insert( ViewToColSetDataVal(nViewID, itColData) );
// Insert the above into the col-id map.
ColSetIDToViewTableMap colIDMap;
colIDMap.insert( ColSetIDToViewTableVal(colSetID, viewIDMap) );
// Insert into the snapins map.
m_spSnapinsMap->insert( SnapinToColSetIDVal(refSnapinCLSID, colIDMap) );
}
// Set dirty after modifying the column-data.
m_bDirty = TRUE;
return TRUE;
}
//+-------------------------------------------------------------------
//
// Member: DeleteColumnData
//
// Synopsis: Delete the persisted column information for the given
// snapin, col-id and view id.
//
// Arguments:
// [refSnapinCLSID] - Snapin Guid.
// [SColumnSetID] - Column Set Identifier.
// [nViewID] - View ID.
//
// Returns: None.
//
// History: 02-13-1999 AnandhaG Created
//
//--------------------------------------------------------------------
VOID CColumnPersistInfo::DeleteColumnData( const CLSID& refSnapinCLSID,
const SColumnSetID& colID,
INT nViewID)
{
// Make sure we are initialized.
if (!m_bInitialized && !Init())
{
ASSERT(FALSE);
return;
}
// Construct CColumnSetID.
CColumnSetID colSetID(colID);
// Use the snapin clsid to get the ColSetIDToViewTableMap.
SnapinToColSetIDMap::iterator itSnapins;
itSnapins = m_spSnapinsMap->find(refSnapinCLSID);
if (itSnapins == m_spSnapinsMap->end())
return;
// The ColSetIDToViewTableMap is a simple map.
ColSetIDToViewTableMap::iterator itColSetIDMap;
ColSetIDToViewTableMap& colSetIDMap = itSnapins->second;
// Get the data for colSetID.
itColSetIDMap = colSetIDMap.find(colSetID);
if (colSetIDMap.end() == itColSetIDMap)
return;
ViewToColSetDataMap& viewData = itColSetIDMap->second;
ViewToColSetDataMap::iterator itViews;
// See if our view is present.
itViews = viewData.find(nViewID);
if (viewData.end() == itViews)
return;
ItColSetDataList itColSetData = itViews->second;
itColSetData->m_bInvalid = TRUE;
// Delete the invalid items.
DeleteMarkedItems();
return;
}
//+-------------------------------------------------------------------
//
// Member: DeleteColumnDataOfSnapin
//
// Synopsis: Delete the column data of given snapin.
//
// Arguments: [refSnapinCLSID] - Snapin Guid.
//
// Returns: TRUE - Data removed successfully.
//
// History: 02-11-1999 AnandhaG Created
//
//--------------------------------------------------------------------
BOOL CColumnPersistInfo::DeleteColumnDataOfSnapin( const CLSID& refSnapinCLSID)
{
// Make sure we are init
if (!m_bInitialized)
{
return FALSE;
}
SnapinToColSetIDMap::iterator itSnapinsMap;
itSnapinsMap = m_spSnapinsMap->find(refSnapinCLSID);
// Find the given snapin.
// Iterate thro all the col-ids of this snapin and
// all the views of those col-id and set the data
// to be invalid.
if (m_spSnapinsMap->end() != itSnapinsMap)
{
ColSetIDToViewTableMap& colSets = itSnapinsMap->second;
// Iterate thro' all colset ids of this snapin.
ColSetIDToViewTableMap::iterator itColumnSetIDMap;
for (itColumnSetIDMap = colSets.begin();
itColumnSetIDMap != colSets.end();
++itColumnSetIDMap)
{
// Get the view map
ViewToColSetDataMap& viewIDMap = itColumnSetIDMap->second;
ViewToColSetDataMap::iterator itViewIDMap;
// Iterate thro' all views and set the data invalid.
for (itViewIDMap = viewIDMap.begin();
itViewIDMap != viewIDMap.end();
++itViewIDMap)
{
ItColSetDataList itColSetData = itViewIDMap->second;
itColSetData->m_bInvalid = TRUE;
}
}
}
// Delete the invalid items.
DeleteMarkedItems();
return TRUE;
}
//+-------------------------------------------------------------------
//
// Member: DeleteColumnDataOfView
//
// Synopsis: Delete the column data of given view.
//
// Arguments: [nViewID] - View ID.
//
// Returns: TRUE - Data removed successfully.
//
// History: 02-11-1999 AnandhaG Created
//
//--------------------------------------------------------------------
BOOL CColumnPersistInfo::DeleteColumnDataOfView( int nViewID)
{
// Make sure we are init
if (!m_bInitialized)
{
return FALSE;
}
// Iterate thro all snapins, col-ids and find the matching
// view and set data to be invalid.
SnapinToColSetIDMap::iterator itSnapinsMap;
// Iterate thro all snapins.
for (itSnapinsMap = m_spSnapinsMap->begin();
m_spSnapinsMap->end() != itSnapinsMap;
++itSnapinsMap)
{
ColSetIDToViewTableMap& colSets = itSnapinsMap->second;
ColSetIDToViewTableMap::iterator itColumnSetIDMap;
// Iterate thro' all colset ids of this snapin.
for (itColumnSetIDMap = colSets.begin();
itColumnSetIDMap != colSets.end();
++itColumnSetIDMap)
{
// Get the view map
ViewToColSetDataMap& viewIDMap = itColumnSetIDMap->second;
ViewToColSetDataMap::iterator itViewIDMap;
// Find the matching views and mark them to be deleted.
for (itViewIDMap = viewIDMap.begin();
itViewIDMap != viewIDMap.end();
++itViewIDMap)
{
if (nViewID == itViewIDMap->first)
{
ItColSetDataList itColSetData = itViewIDMap->second;
itColSetData->m_bInvalid = TRUE;
}
}
}
}
// Delete the invalid items.
DeleteMarkedItems();
return TRUE;
}
//+-------------------------------------------------------------------
//
// Member: Init
//
// Synopsis: Create the Map and the list for CColumnSetData.
//
// Returns: TRUE - for success.
//
// History: 10-16-1998 AnandhaG Created
//
//--------------------------------------------------------------------
BOOL CColumnPersistInfo::Init()
{
// Create the data structures to store column data.
m_spSnapinsMap = auto_ptr<SnapinToColSetIDMap>(new SnapinToColSetIDMap);
m_spColSetList = auto_ptr<ColSetDataList> (new ColSetDataList);
// Now the objects are created, so now set initialized to true.
m_bInitialized = TRUE;
// Now read the registry to see if m_dwMaxItems is specified.
// Check if the settings key exists.
CRegKeyEx rSettingsKey;
if (rSettingsKey.ScOpen (HKEY_LOCAL_MACHINE, SETTINGS_KEY, KEY_READ).IsError())
return m_bInitialized;
// Read the values for MaxColDataPersisted.
if (rSettingsKey.IsValuePresent(g_szMaxColumnDataPersisted))
{
DWORD dwType = REG_DWORD;
DWORD dwSize = sizeof(DWORD);
SC sc = rSettingsKey.ScQueryValue (g_szMaxColumnDataPersisted, &dwType,
&m_dwMaxItems, &dwSize);
if (sc)
sc.TraceAndClear();
}
return m_bInitialized;
}
//+-------------------------------------------------------------------
//
// Member: GarbageCollectItems
//
// Synopsis: Free least used column data.
//
// Arguments: None.
//
// History: 02-11-1999 AnandhaG Created
//
//--------------------------------------------------------------------
VOID CColumnPersistInfo::GarbageCollectItems()
{
INT nItemsToBeRemoved = COLUMNS_MAXLIMIT * m_dwMaxItems;
// Go thro' the list and set the nItemsToBeRemoved that was least recently
// accessed to be invalid.
INT nIndex = 0;
ItColSetDataList itColList;
// Skip first m_dwMaxItems.
for (itColList = m_spColSetList->begin();
( (itColList != m_spColSetList->end()) && (nIndex <= m_dwMaxItems) );
++itColList, nIndex++)
{
nIndex++;
}
// Mark rest of the items to be garbage.
while (itColList != m_spColSetList->end())
{
itColList->m_bInvalid = TRUE;
++itColList;
}
// Delete the invalid items.
DeleteMarkedItems();
return;
}
//+-------------------------------------------------------------------
//
// Member: DeleteMarkedItems
//
// Synopsis: Delete invalidated items. This involves iterating thro
// the maps to find the invalid items. Then deleting the
// items. If the map becomes empty then delete the map.
//
// History: 02-11-1999 AnandhaG Created
//
//--------------------------------------------------------------------
VOID CColumnPersistInfo::DeleteMarkedItems()
{
SnapinToColSetIDMap::iterator itSnapinsMap, itSnapinsMapNew;
// Now iterate thro the map and remove those elements.
itSnapinsMap = m_spSnapinsMap->begin();
while (itSnapinsMap != m_spSnapinsMap->end())
{
ColSetIDToViewTableMap& colSets = itSnapinsMap->second;
ColSetIDToViewTableMap::iterator itColumnSetIDMap;
// Iterate thro this snapins col-ids.
itColumnSetIDMap = colSets.begin();
while (itColumnSetIDMap != colSets.end())
{
// Get the view map
ViewToColSetDataMap& viewIDMap = itColumnSetIDMap->second;
ViewToColSetDataMap::iterator itViewIDMap;
// Iterate thro all the views.
itViewIDMap = viewIDMap.begin();
while (itViewIDMap != viewIDMap.end())
{
ItColSetDataList itColSetData = itViewIDMap->second;
if (itColSetData->m_bInvalid)
{
// Delete the item ref from the map.
// Erase returns iterator to next item.
itViewIDMap = viewIDMap.erase(itViewIDMap);
// Delete the item from the list.
m_spColSetList->erase(itColSetData);
}
else
// Item is valid item.
++itViewIDMap;
}
// If the view has zero items we need to remove this
// view map. (ColID to ViewMap).
if (0 == viewIDMap.size())
{
// Delete the col-id map.
// Erase returns iterator to next item.
itColumnSetIDMap = colSets.erase(itColumnSetIDMap);
}
else
++itColumnSetIDMap;
}
// If there are no col-id's remove the
// Snapin to this col-id map.
if (0 == colSets.size())
{
// Delete this snapin map.
// Erase returns iterator to next item.
itSnapinsMap = m_spSnapinsMap->erase(itSnapinsMap);
}
else
++itSnapinsMap;
}
return;
}
//+-------------------------------------------------------------------
//
// Member: Load
//
// Synopsis: Load the persisted column information.
//
// Arguments: [pStream]- ISteam from which column widths to be loaded.
//
// Returns: S_OK - Loaded successfully.
//
// History: 10-16-1998 AnandhaG Created
//
//--------------------------------------------------------------------
STDMETHODIMP CColumnPersistInfo::Load (IStream* pStream)
{
HRESULT hr = E_FAIL;
if (!m_bInitialized && !Init())
{
ASSERT(FALSE);
return hr;
}
// read the column width information.
try
{
do
{
// Read the version. If it did not match return
INT nVersion = 0;
*pStream >> nVersion;
if (COLPersistenceVersion != nVersion)
return S_FALSE;
// Read the # of Snapins
DWORD dwSnapins = 0;
*pStream >> dwSnapins;
m_spColSetList->clear();
m_spSnapinsMap->clear();
// For each snapin...
for (int nSnapIdx = 0; nSnapIdx < dwSnapins; nSnapIdx++)
{
// Read snapin CLSID.
CLSID clsidSnapin;
*pStream >> clsidSnapin;
// Read the number of col-ids for this snapin.
DWORD dwColIDs = 0;
*pStream >> dwColIDs;
ColSetIDToViewTableMap colSetsMap;
// For each col-id...
for (int nColIDIdx = 0; nColIDIdx < dwColIDs; nColIDIdx++)
{
// Read the col-id
CColumnSetID colSetID;
*pStream >> colSetID;
// Read the number of views.
DWORD dwNumViews = 0;
*pStream >> dwNumViews;
ViewToColSetDataMap ViewIDMap;
// For each view...
for (int nViewIdx = 0; nViewIdx < dwNumViews; nViewIdx++)
{
// Read view id.
DWORD dwViewID;
*pStream >> dwViewID;
// Read the CColumnSetData.
CColumnSetData ColData;
ColData.Read(*pStream);
// Insert the data into the global linked list.
ItColSetDataList itColSetData;
itColSetData = m_spColSetList->insert(m_spColSetList->begin(), ColData);
// Insert the pointer to the data in to view map.
ViewIDMap.insert(ViewToColSetDataVal(dwViewID, itColSetData));
}
// Insert the view map into the col-id map.
colSetsMap.insert(ColSetIDToViewTableVal(colSetID, ViewIDMap));
}
// Insert the col-id map into the snapin map.
m_spSnapinsMap->insert(SnapinToColSetIDVal(clsidSnapin, colSetsMap));
}
// Now sort the list.
m_spColSetList->sort();
} while (FALSE);
}
catch (_com_error& err)
{
hr = err.Error();
}
catch (...)
{
ASSERT (0 && "Unexpected exception");
throw;
}
return S_OK;
}
//+-------------------------------------------------------------------
//
// Member: Save
//
// Synopsis: Persist the column information.
//
// Arguments: [pStream]- IStream in which column widths are to be saved.
//
// Returns: S_OK - Saved successfully.
//
// History: 10-16-1998 AnandhaG Created
//
//--------------------------------------------------------------------
STDMETHODIMP CColumnPersistInfo::Save (IStream* pStream, BOOL bClearDirty)
{
// absolete method.
// this method is left here since we use IPersistStream to export
// persistence to CONUI side and need to implement it.
// But this interface will never be called to save data
// [we will use CPersistor-based XML saving instead]
// so the method will always fail.
ASSERT(FALSE && "Should never come here");
return E_NOTIMPL;
}
//+-------------------------------------------------------------------
//
// Member: Persist
//
// Synopsis: Persists the column information.
//
// Arguments: [persistor]- CPersistor in/from which column widths are persisted.
//
// Returns: void.
//
// History: 10-08-1999 AudriusZ Created
//
//--------------------------------------------------------------------
void CColumnPersistInfo::Persist(CPersistor &persistor)
{
DECLARE_SC(sc, TEXT("CColumnPersistInfo::Persist"));
if (!m_bInitialized && !Init())
sc.Throw(E_FAIL);
sc = ScCheckPointers(m_spColSetList.get(), m_spSnapinsMap.get(), E_UNEXPECTED);
if (sc)
sc.Throw();
if (persistor.IsStoring())
{
// Give ranking to each column data.
ItColSetDataList itColList;
DWORD dwRank = 0;
for (itColList = m_spColSetList->begin();
itColList != m_spColSetList->end();
++itColList)
{
itColList->m_dwRank = dwRank++;
}
}
else // if (persistor.IsLoading())
{
m_spColSetList->clear();
m_spSnapinsMap->clear();
}
SnapinToColSetIDMapPersistor childPersisot(*m_spSnapinsMap, *m_spColSetList);
childPersisot.Persist(persistor);
if (persistor.IsStoring())
m_bDirty = FALSE;
}
//+-------------------------------------------------------------------
//
// Member: OnInitDialog
//
// Synopsis: Initialize the Columns dialog.
//
// Arguments:
//
// History: 11-16-1998 AnandhaG Created
//
//--------------------------------------------------------------------
LRESULT CColumnsDlg::OnInitDialog (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
m_btnAdd = ::GetDlgItem(m_hWnd, IDC_ADD_COLUMNS);
m_btnRemove = ::GetDlgItem(m_hWnd, IDC_REMOVE_COLUMNS);
m_btnRestoreDefaultColumns = ::GetDlgItem(m_hWnd, IDC_RESTORE_DEFAULT_COLUMNS);
m_btnMoveUp = ::GetDlgItem(m_hWnd, IDC_MOVEUP_COLUMN);
m_btnMoveDown = ::GetDlgItem(m_hWnd, IDC_MOVEDOWN_COLUMN);
m_HiddenColList.Attach(::GetDlgItem(m_hWnd, IDC_HIDDEN_COLUMNS));
m_DisplayedColList.Attach(::GetDlgItem(m_hWnd, IDC_DISPLAYED_COLUMNS));
m_bUsingDefaultColumnSettings = (*m_pColumnInfoList == m_DefaultColumnInfoList);
InitializeLists();
EnableUIObjects();
return 0;
}
//+-------------------------------------------------------------------
//
// Member: OnOK
//
// Synopsis: Get the hidden and visible columns.
//
// Arguments:
//
// History: 11-16-1998 AnandhaG Created
//
//--------------------------------------------------------------------
LRESULT CColumnsDlg::OnOK (WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
if (! m_bDirty) // column settings are not modified
{
EndDialog (IDCANCEL);
return 1;
}
if (m_bUsingDefaultColumnSettings)
{
EndDialog(IDC_RESTORE_DEFAULT_COLUMNS);
return 1;
}
ASSERT(NULL != m_pColumnInfoList);
if (NULL == m_pColumnInfoList)
return 0;
WTL::CString strColumnName;
CColumnInfoList::iterator it;
CColumnInfo colinfo;
// Get the strings from Hidden_List_Box.
// These cols are to be hidden. So put them first in the list.
int cItems = m_HiddenColList.GetCount();
for (int i = 0; i < cItems; i++)
{
// Get the text from list box
int nRet = m_HiddenColList.GetText(i, strColumnName);
if (LB_ERR == nRet)
{
ASSERT(FALSE);
break;
}
// Use the string to get the actual index of the column.
int nIndex = GetColIndex(strColumnName);
if (0 > nIndex )
{
ASSERT(FALSE);
break;
}
// With the index get the column and insert it at beginning.
it = find_if(m_pColumnInfoList->begin(), m_pColumnInfoList->end(),
bind2nd(ColPosCompare(), nIndex));
if (it == m_pColumnInfoList->end())
{
ASSERT(FALSE);
break;
}
// Set the *it flag to be hidden. Insert it at beginning.
colinfo = *it;
colinfo.SetColHidden();
// Move the item to the head of the list
m_pColumnInfoList->erase(it);
m_pColumnInfoList->push_front(colinfo);
}
// Then get the strings from DisplayedColumns_List_Box.
cItems = m_DisplayedColList.GetCount();
for (i = 0; i < cItems; i++)
{
// Get the text from list box
int nRet = m_DisplayedColList.GetText(i, strColumnName);
if (LB_ERR == nRet)
{
ASSERT(FALSE);
break;
}
// Use the column name to get the column index.
int nIndex = GetColIndex(strColumnName);
if (0 > nIndex )
{
ASSERT(FALSE);
break;
}
// Get the CColumnInfo and insert at end.
it = find_if(m_pColumnInfoList->begin(), m_pColumnInfoList->end(),
bind2nd(ColPosCompare(), nIndex));
if (it == m_pColumnInfoList->end())
break;
colinfo = *it;
if (colinfo.IsColHidden())
{
// If hidden column is made visible
// reset the hidden flag and set the width
// to auto_width.
colinfo.SetColHidden(false);
if (colinfo.GetColWidth() <= 0)
colinfo.SetColWidth(AUTO_WIDTH);
}
// Move it to the end of the list.
m_pColumnInfoList->erase(it);
m_pColumnInfoList->push_back(colinfo);
}
EndDialog (IDOK);
return 1;
}
LRESULT CColumnsDlg::OnCancel (WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
EndDialog (IDCANCEL);
return 0;
}
LRESULT CColumnsDlg::OnMoveUp (WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
MoveItem(TRUE);
return 0;
}
LRESULT CColumnsDlg::OnMoveDown (WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
MoveItem(FALSE);
return 0;
}
//+-------------------------------------------------------------------
//
// Member: OnAdd
//
// Synopsis: Adds a column to displayed columns list by removing
// the currently selected column from hidden column list.
//
// Arguments:
//
//--------------------------------------------------------------------
LRESULT CColumnsDlg::OnAdd (WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
// First remove from hidden column list.
int nCurSel = m_HiddenColList.GetCurSel();
WTL::CString strColumnName;
int nRet = m_HiddenColList.GetText(nCurSel, strColumnName);
if (LB_ERR == nRet)
{
ASSERT(FALSE);
return 0;
}
m_HiddenColList.DeleteString(nCurSel);
// now add it to Displayed column list.
m_DisplayedColList.AddString(strColumnName);
SetDirty();
if (nCurSel > m_HiddenColList.GetCount()-1)
nCurSel = m_HiddenColList.GetCount()-1;
m_HiddenColList.SetCurSel(nCurSel);
m_DisplayedColList.SelectString(0, strColumnName);
SetListBoxHScrollSize();
EnableUIObjects();
return 0;
}
//+-------------------------------------------------------------------
//
// Member: OnRemove
//
// Synopsis: Removes the currently selected column from displayed
// columns list by removing and adds it to hidden column list.
//
// Arguments:
//
//--------------------------------------------------------------------
LRESULT CColumnsDlg::OnRemove (WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
// Get the currently selected item in Displayed Columns list.
int nCurSel = m_DisplayedColList.GetCurSel();
WTL::CString strColumnName;
int nRet = m_DisplayedColList.GetText(nCurSel, strColumnName);
if (LB_ERR == nRet)
{
ASSERT(FALSE);
return 0;
}
// If column zero do not hide it.
if (0 == GetColIndex(strColumnName))
return 0;
m_DisplayedColList.DeleteString(nCurSel);
// Add it to hidden column list.
m_HiddenColList.AddString(strColumnName);
SetDirty();
if (nCurSel > m_DisplayedColList.GetCount()-1)
nCurSel = m_DisplayedColList.GetCount()-1;
m_DisplayedColList.SetCurSel(nCurSel);
m_HiddenColList.SelectString(0, strColumnName);
EnableUIObjects();
SetListBoxHScrollSize();
return 0;
}
LRESULT CColumnsDlg::OnRestoreDefaultColumns (WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
DECLARE_SC(sc, TEXT("CColumnsDlg::OnRestoreDefaultColumns"));
// Get the default data and populate the columns dialog.
*m_pColumnInfoList = m_DefaultColumnInfoList;
SetUsingDefaultColumnSettings();
InitializeLists();
EnableUIObjects();
// Button is disabled so put the focus on the dialog.
SetFocus();
return 0;
}
LRESULT CColumnsDlg::OnSelChange (WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
EnableUIObjects();
return 0;
}
//+-------------------------------------------------------------------
//
// Member: MoveItem
//
// Synopsis: Moves an item in the displayed columns list up or down.
// The up down order is same as column visible order from
// left to right.
//
// Arguments: [BOOL] - up or down.
//
//--------------------------------------------------------------------
void CColumnsDlg::MoveItem (BOOL bMoveUp)
{
int nCurSel = m_DisplayedColList.GetCurSel();
WTL::CString strColumnName;
int nRet = m_DisplayedColList.GetText(nCurSel, strColumnName);
if (LB_ERR == nRet)
{
ASSERT(FALSE);
return;
}
m_DisplayedColList.DeleteString(nCurSel);
if (bMoveUp)
m_DisplayedColList.InsertString(nCurSel-1, strColumnName);
else
m_DisplayedColList.InsertString(nCurSel+1, strColumnName);
m_DisplayedColList.SelectString(0, strColumnName);
SetDirty();
EnableUIObjects();
return;
}
//+-------------------------------------------------------------------
//
// Member: EnableUIObjects
//
// Synopsis: Enable/Disable the UI objects in the dialog.
//
// Arguments:
//
//--------------------------------------------------------------------
void CColumnsDlg::EnableUIObjects()
{
int curselAvailable = m_HiddenColList.GetCurSel();
int curselShow = m_DisplayedColList.GetCurSel();
int cItems = m_HiddenColList.GetCount();
BOOL bEnableAdd = ((curselAvailable != LB_ERR) && (curselAvailable || cItems)) ? TRUE: FALSE;
BOOL bEnableRemove = ((curselShow != LB_ERR)) ? TRUE: FALSE;
BOOL bEnableMoveUp = ((curselShow != LB_ERR) && curselShow) ? TRUE: FALSE;
cItems = m_DisplayedColList.GetCount();
BOOL bEnableMoveDown = cItems && (curselShow != LB_ERR) && (cItems!=curselShow+1);
BOOL bRet = FALSE;
bRet = m_btnAdd.EnableWindow(bEnableAdd);
bRet = m_btnRemove.EnableWindow(bEnableRemove);
bRet = m_btnMoveUp.EnableWindow(bEnableMoveUp);
bRet = m_btnMoveDown.EnableWindow(bEnableMoveDown);
// Enable restore defaults only if columns are already customized before bringing the dialog
bRet = m_btnRestoreDefaultColumns.EnableWindow( (!m_bUsingDefaultColumnSettings));
// Disable Remove/Move Up/Move Down buttons for Col zero.
int nCurSel = m_DisplayedColList.GetCurSel();
WTL::CString strColumnName;
int nRet = m_DisplayedColList.GetText(nCurSel, strColumnName);
if (LB_ERR == nRet)
{
ASSERT(FALSE);
return;
}
if (0 == GetColIndex(strColumnName)) // Column 0
m_btnRemove.EnableWindow(FALSE);
}
int CColumnsDlg::GetColIndex(LPCTSTR lpszColName)
{
TStringVector::iterator itStrVec1;
USES_CONVERSION;
itStrVec1 = find(m_pStringVector->begin(), m_pStringVector->end(), lpszColName);
if (m_pStringVector->end() != itStrVec1)
return (itStrVec1 - m_pStringVector->begin());
else
// Unknown column
return -1;
}
//+-------------------------------------------------------------------
//
// Member: SetListBoxHorizontalScrollbar
//
// Synopsis: For the given list box enumerate the strings added and find
// the largest string. Calculate scrollbar size for this string
// and set it.
//
// Arguments: [listBox] - Given list box.
//
//--------------------------------------------------------------------
void CColumnsDlg::SetListBoxHorizontalScrollbar(WTL::CListBox& listBox)
{
int dx=0;
WTL::CDC dc(listBox.GetWindowDC());
if (dc.IsNull())
return;
// Find the longest string in the list box.
for (int i=0;i < listBox.GetCount();i++)
{
WTL::CString str;
int nRet = listBox.GetText( i, str );
if (nRet == LB_ERR)
return;
WTL::CSize sz;
if (! dc.GetTextExtent(str, str.GetLength(), &sz))
return;
if (sz.cx > dx)
dx = sz.cx;
}
// Set the horizontal extent so every character of all strings
// can be scrolled to.
listBox.SetHorizontalExtent(dx);
return;
}
/* CColumnsDlg::InitializeLists
*
* PURPOSE:
*
* PARAMETERS:
*
* RETURNS:
* void
*/
void CColumnsDlg::InitializeLists()
{
CColumnInfoList::iterator it;
int j = 0;
if (!m_pColumnInfoList)
{
ASSERT(FALSE);
return;
}
m_HiddenColList.ResetContent();
m_DisplayedColList.ResetContent();
USES_CONVERSION;
for (it = m_pColumnInfoList->begin(); it != m_pColumnInfoList->end(); ++it)
{
if (it->IsColHidden())
{
m_HiddenColList.AddString(m_pStringVector->at(it->GetColIndex()).data());
}
else
{
m_DisplayedColList.InsertString(j++, m_pStringVector->at(it->GetColIndex()).data());
}
}
m_DisplayedColList.SetCurSel(m_DisplayedColList.GetCount()-1);
m_HiddenColList.SetCurSel(m_HiddenColList.GetCount()-1);
SetListBoxHScrollSize();
}
//+-------------------------------------------------------------------
//
// Member: CColumnSetID::Persist
//
// Synopsis: Persists object data
//
// Arguments:
//
// History: 10-10-1999 AudriusZ Created
//
//--------------------------------------------------------------------
void CColumnSetID::Persist(CPersistor &persistor)
{
DECLARE_SC(sc, TEXT("CColumnSetID::Persist"));
CXMLAutoBinary binary;
if (persistor.IsStoring() && m_vID.size()) // fill only if have data
{
sc = binary.ScAlloc(m_vID.size());
if (sc)
sc.Throw();
CXMLBinaryLock sLock(binary); // will unlock in destructor
LPBYTE pData = NULL;
sc = sLock.ScLock(&pData);
if (sc)
sc.Throw();
sc = ScCheckPointers(pData, E_UNEXPECTED);
if (sc)
sc.Throw();
std::copy(m_vID.begin(), m_vID.end(), pData);
}
persistor.PersistAttribute(XML_ATTR_COLUMN_SET_ID_PATH, binary);
if (persistor.IsLoading())
{
m_vID.clear();
if (binary.GetSize())
{
CXMLBinaryLock sLock(binary); // will unlock in destructor
LPBYTE pData = NULL;
sc = sLock.ScLock(&pData);
if (sc)
sc.Throw();
sc = ScCheckPointers(pData, E_UNEXPECTED);
if (sc)
sc.Throw();
m_vID.insert(m_vID.end(), pData, pData + binary.GetSize());
}
}
persistor.PersistAttribute(XML_ATTR_COLUMN_SET_ID_FLAGS, m_dwFlags);
}
/***************************************************************************\
*
* METHOD: ViewToColSetDataMapPersistor::Persist
*
* PURPOSE: called by the base class to create and persist the new element
*
* PARAMETERS:
* CPersistor& persistor - [in] persistor from which to persist new element
*
* RETURNS:
* void
*
* see "Data structures used to persist column information" comment
* int file colwidth.h for more information
\***************************************************************************/
void ViewToColSetDataMapPersistor::Persist(CPersistor &persistor)
{
if (persistor.IsStoring())
{
// iterate and save all elements as linear list
ViewToColSetDataMap::iterator it;
for (it = m_map.begin(); it != m_map.end(); ++it)
{
// we will sneak under child's element to persist the KEY value as an attribute
// of the child element. To do that we use tag got from _GetXMLType() of the child
CPersistor persistorChild(persistor, it->second->GetXMLType());
int view_id = it->first; // just to cast constness out (we do not have const Persist)
persistorChild.PersistAttribute(XML_ATTR_COLUMN_SET_ID_VIEW, view_id);
// note: we are asking the child to persist on the same level.
// thats to save on depth
it->second->Persist(persistorChild);
}
}
else
{
// use base class to read. it will call OnNewElement for each found
m_map.clear();
XMLListCollectionBase::Persist(persistor);
}
}
/***************************************************************************\
*
* METHOD: ViewToColSetDataMapPersistor::OnNewElement
*
* PURPOSE: called by the base class to create and persist the new element
*
* PARAMETERS:
* CPersistor& persistor - [in] persistor from which to persist new element
*
* RETURNS:
* void
*
* see "Data structures used to persist column information" comment
* int file colwidth.h for more information
\***************************************************************************/
void ViewToColSetDataMapPersistor::OnNewElement(CPersistor& persistor)
{
// we will sneak under child's element to persist the KEY value as an attribute
// of the child element. To do that we use tag got from GetXMLType() of the child
CColumnSetData setData;
CPersistor persistorChild(persistor, setData.GetXMLType());
// read the key value from the child element
int view_id = 0;
persistorChild.PersistAttribute(XML_ATTR_COLUMN_SET_ID_VIEW, view_id);
// insert value to the list
ColSetDataList::iterator it = m_list.insert(m_list.end(), setData);
// ad list iterator to the map
m_map[view_id] = it;
// persist contents of the list item
it->Persist(persistorChild);
}
/***************************************************************************\
*
* METHOD: ColSetIDToViewTableMapPersistor::Persist
*
* PURPOSE: called as a request for the object to persist it's data
*
* PARAMETERS:
* CPersistor &persistor [in] persistor to persist to/from
*
* RETURNS:
* void
*
* see "Data structures used to persist column information" comment
* int file colwidth.h for more information
\***************************************************************************/
void ColSetIDToViewTableMapPersistor::Persist(CPersistor &persistor)
{
if (persistor.IsStoring())
{
// iterate and save all elements as linear list
ColSetIDToViewTableMap::iterator it;
for (it = m_map.begin(); it != m_map.end(); ++it)
{
// we will sneak under child's element to persist the KEY value as an attribute
// of the child element. To do that we use tag got from _GetXMLType() of the child
CPersistor persistorChild(persistor, ViewToColSetDataMapPersistor::_GetXMLType());
CColumnSetID& rID = *const_cast<CColumnSetID *>(&it->first);
rID.Persist(persistorChild);
// note: we are asking the child to persist on the same level.
// thats to save on depth
ViewToColSetDataMapPersistor mapPersistor(it->second, m_list);
mapPersistor.Persist(persistorChild);
}
}
else
{
// use base class to read. it will call OnNewElement for each found
m_map.clear();
XMLListCollectionBase::Persist(persistor);
}
}
/***************************************************************************\
*
* METHOD: ColSetIDToViewTableMapPersistor::OnNewElement
*
* PURPOSE: called by the base class to create and persist the new element
*
* PARAMETERS:
* CPersistor& persistor - [in] persistor from which to persist new element
*
* RETURNS:
* void
*
* see "Data structures used to persist column information" comment
* int file colwidth.h for more information
\***************************************************************************/
void ColSetIDToViewTableMapPersistor::OnNewElement(CPersistor& persistor)
{
// we will sneak under child's element to persist the KEY value as an attribute
// of the child element. To do that we use tag got from _GetXMLType() of the child
CPersistor persistorChild(persistor, ViewToColSetDataMapPersistor::_GetXMLType());
// read the key value from the child element
// note that we are forcing CColumnSetID to share the same element,
// therefore we are not using persistor.Persist()
CColumnSetID ID;
ID.Persist(persistorChild);
// insert the new element into the map
ViewToColSetDataMap &rMap = m_map[ID];
// create the wrapper on inserted map value
// (pass a list to wrapper. we actually have it [list] for this only reason)
ViewToColSetDataMapPersistor mapPersistor(m_map[ID], m_list);
// ask wrapper to read the rest
mapPersistor.Persist(persistorChild);
}
/***************************************************************************\
*
* METHOD: SnapinToColSetIDMapPersistor::Persist
*
* PURPOSE:
*
* PARAMETERS:
* CPersistor &persistor
*
* RETURNS:
* void
*
* see "Data structures used to persist column information" comment
* int file colwidth.h for more information
\***************************************************************************/
void SnapinToColSetIDMapPersistor::Persist(CPersistor &persistor)
{
DECLARE_SC(sc, TEXT("SnapinToColSetIDMapPersistor::Persist"));
if (persistor.IsStoring())
{
// prior-to-save cleanup
sc = ScPurgeUnusedColumnData();
if (sc)
sc.Throw();
// iterate and save all elements as linear list
SnapinToColSetIDMap::iterator it;
for (it = m_map.begin(); it != m_map.end(); ++it)
{
// we will sneak under child's element to persist the KEY value as an attribute
// of the child element. To do that we use tag got from _GetXMLType() of the child
CPersistor persistorChild(persistor, ColSetIDToViewTableMapPersistor::_GetXMLType());
// write the key value.
// just to cast constness out (we do not have const Persist)
GUID& guid = *const_cast<GUID *>(&it->first);
persistorChild.PersistAttribute(XML_ATTR_COLUMN_INFO_SNAPIN, guid);
// create a wrapper on the value (which is also a map)
// (pass a list to wrapper. though it's not used for storing)
ColSetIDToViewTableMapPersistor mapPersistor(it->second, m_list);
// persist the wrapper
mapPersistor.Persist(persistorChild);
}
}
else
{
// use base class to read. it will call OnNewElement for each found
m_map.clear();
XMLListCollectionBase::Persist(persistor);
}
}
/***************************************************************************\
*
* METHOD: SnapinToColSetIDMapPersistor::OnNewElement
*
* PURPOSE: called by the base class to create and persist the new element
*
* PARAMETERS:
* CPersistor& persistor - [in] persistor from which to persist new element
*
* RETURNS:
* void
*
* see "Data structures used to persist column information" comment
* int file colwidth.h for more information
\***************************************************************************/
void SnapinToColSetIDMapPersistor::OnNewElement(CPersistor& persistor)
{
// we will sneak under child's element to persist the KEY value as an attribute
// of the child element. To do that we use tag got from _GetXMLType() of the child
CPersistor persistorChild(persistor, ColSetIDToViewTableMapPersistor::_GetXMLType());
GUID guid;
// read the key value
persistorChild.PersistAttribute(XML_ATTR_COLUMN_INFO_SNAPIN, guid);
// insert the new element into the map
ColSetIDToViewTableMap &rMap = m_map[guid];
// create the wrapper on inserted map value
// (pass a list to wrapper. we actually have it [list] for this only reason)
ColSetIDToViewTableMapPersistor mapPersistor(rMap, m_list);
// ask wrapper to read the rest
mapPersistor.Persist(persistorChild);
}
/***************************************************************************\
*
* METHOD: SnapinToColSetIDMapPersistor::ScPurgeUnusedColumnData
*
* PURPOSE: prior-to-save cleanup. removes unused snapin entries
*
* PARAMETERS:
*
* RETURNS:
* SC - result code
*
\***************************************************************************/
SC SnapinToColSetIDMapPersistor::ScPurgeUnusedColumnData()
{
DECLARE_SC(sc, TEXT("SnapinToColSetIDMapPersistor::ScPurgeUnusedColumnData"));
// get the scopetree pointer
CScopeTree *pScopeTree = CScopeTree::GetScopeTree();
// check it
sc = ScCheckPointers(pScopeTree, E_UNEXPECTED);
if (sc)
return sc;
// iterate and remove unused entries
SnapinToColSetIDMap::iterator it = m_map.begin();
while (it != m_map.end())
{
// ask the scope tree if snapin is in use
BOOL bInUse = FALSE;
sc = pScopeTree->IsSnapinInUse(it->first, &bInUse);
if (sc)
return sc;
// act depending on usage
if (bInUse)
{
++it; // skip also the stuff currently in use
}
else
{
// to the trash can
ColSetIDToViewTableMap& colSets = it->second;
// Iterate thro' all colset ids of this snapin.
ColSetIDToViewTableMap::iterator itColumnSetIDMap = colSets.begin();
while(itColumnSetIDMap != colSets.end())
{
// Get the view map
ViewToColSetDataMap& viewIDMap = itColumnSetIDMap->second;
ViewToColSetDataMap::iterator itViewIDMap = viewIDMap.begin();
// Iterate thro' all views and remove entries
while (itViewIDMap != viewIDMap.end())
{
m_list.erase(/*(ItColSetDataList)*/itViewIDMap->second);
itViewIDMap = viewIDMap.erase(itViewIDMap);
}
itColumnSetIDMap = colSets.erase(itColumnSetIDMap);
}
it = m_map.erase(it);
}
}
return sc;
}
Reference in a new issue Copy permalink