You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
685 lines
21 KiB
685 lines
21 KiB
//+-------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1994 - 1999
|
|
//
|
|
// File: colwidth.h
|
|
//
|
|
// Contents: Classes related to column persistence.
|
|
//
|
|
// Classes: CColumnInfo, CColumnPersistInfo
|
|
// CColumnsDlg.
|
|
//
|
|
// History: 14-Oct-98 AnandhaG Created
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
#ifndef COLWIDTH_H
|
|
#define COLWIDTH_H
|
|
#pragma once
|
|
|
|
#pragma warning(disable: 4503) // Disable long name limit warnings
|
|
|
|
#include "columninfo.h"
|
|
|
|
using namespace std;
|
|
|
|
class CColumnPersistInfo;
|
|
class CColumnsDlg;
|
|
|
|
// Column Persistence Versioning
|
|
// Version 1 has
|
|
// "Col index (seen by snapin)" "Width" "Format" in order.
|
|
static const INT COLPersistenceVersion = 2;
|
|
|
|
// We allow the list to grow COLUMNS_MAXLIMIT times more,
|
|
// then we do garbage collection.
|
|
#define COLUMNS_MAXLIMIT 0.4
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Class: CColumnSortInfo
|
|
//
|
|
// Purpose: Columns sort information.
|
|
// The column that is sorted and direction.
|
|
//
|
|
// History: 10-27-1998 AnandhaG Created
|
|
//
|
|
//--------------------------------------------------------------------
|
|
class CColumnSortInfo : public CSerialObject, public CXMLObject
|
|
{
|
|
public:
|
|
friend class CColumnPersistInfo;
|
|
friend class CNode;
|
|
friend class CColumnsDlg;
|
|
friend struct ColPosCompare;
|
|
friend class CColumnData;
|
|
|
|
public:
|
|
CColumnSortInfo () : m_nCol(-1), m_dwSortOptions(0),
|
|
m_lpUserParam(NULL)
|
|
{}
|
|
|
|
CColumnSortInfo (INT nCol, DWORD dwSortOptions)
|
|
: m_nCol(nCol), m_dwSortOptions(dwSortOptions),
|
|
m_lpUserParam(NULL)
|
|
{
|
|
}
|
|
|
|
CColumnSortInfo(const CColumnSortInfo& colInfo)
|
|
{
|
|
m_nCol = colInfo.m_nCol;
|
|
m_dwSortOptions = colInfo.m_dwSortOptions;
|
|
m_lpUserParam = colInfo.m_lpUserParam;
|
|
}
|
|
|
|
CColumnSortInfo& operator=(const CColumnSortInfo& colInfo)
|
|
{
|
|
if (this != &colInfo)
|
|
{
|
|
m_nCol = colInfo.m_nCol;
|
|
m_dwSortOptions = colInfo.m_dwSortOptions;
|
|
m_lpUserParam = colInfo.m_lpUserParam;
|
|
}
|
|
|
|
return (*this);
|
|
}
|
|
|
|
bool operator ==(const CColumnSortInfo &colinfo) const
|
|
{
|
|
return ( (m_nCol == colinfo.m_nCol) &&
|
|
(m_dwSortOptions == colinfo.m_dwSortOptions) &&
|
|
(m_lpUserParam == colinfo.m_lpUserParam) );
|
|
}
|
|
|
|
INT getColumn() const { return m_nCol;}
|
|
DWORD getSortOptions() const { return m_dwSortOptions;}
|
|
ULONG_PTR getUserParam() const { return m_lpUserParam;}
|
|
|
|
protected:
|
|
INT m_nCol; // The index supplied when snapin inserted the column.
|
|
// This is not the index viewed by the user.
|
|
DWORD m_dwSortOptions; // Sort flags like Ascending/Descending, Sort icon...
|
|
ULONG_PTR m_lpUserParam; // Snapin supplied user param.
|
|
|
|
protected:
|
|
// CSerialObject methods
|
|
virtual UINT GetVersion() {return 2;}
|
|
virtual HRESULT ReadSerialObject (IStream &stm, UINT nVersion /*,LARGE_INTEGER nBytes*/);
|
|
|
|
protected:
|
|
DEFINE_XML_TYPE(XML_TAG_COLUMN_SORT_INFO);
|
|
virtual void Persist(CPersistor &persistor);
|
|
};
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Class: CColumnSortList
|
|
//
|
|
// Purpose: linked list with CColumnInfo's.
|
|
//
|
|
// History: 02-11-1999 AnandhaG Created
|
|
//
|
|
//--------------------------------------------------------------------
|
|
class CColumnSortList : public list<CColumnSortInfo>, public CSerialObject
|
|
{
|
|
public:
|
|
friend class CColumnSetData;
|
|
|
|
public:
|
|
CColumnSortList ()
|
|
{
|
|
}
|
|
|
|
~CColumnSortList()
|
|
{
|
|
}
|
|
|
|
protected:
|
|
|
|
void PersistSortList(CPersistor& persistor);
|
|
|
|
// CSerialObject methods
|
|
virtual UINT GetVersion() {return 1;}
|
|
virtual HRESULT ReadSerialObject (IStream &stm, UINT nVersion /*,LARGE_INTEGER nBytes*/);
|
|
};
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Class: CColumnSetData
|
|
//
|
|
// Purpose: Data for a ColumnSetID. That is the data pertaining to
|
|
// set of columns associated with a node. This data includes
|
|
// column width, order, hidden/visible status. It also
|
|
// includes the column on which we have sorted and the
|
|
// order.
|
|
//
|
|
// History: 01-13-1998 AnandhaG Created
|
|
//
|
|
//--------------------------------------------------------------------
|
|
class CColumnSetData : public CSerialObject, public CXMLObject
|
|
{
|
|
public:
|
|
friend class CColumnPersistInfo;
|
|
friend class CColumnsDlg;
|
|
|
|
public:
|
|
CColumnSetData ()
|
|
{
|
|
m_colInfoList.clear();
|
|
m_colSortList.clear();
|
|
|
|
m_dwRank = -1;
|
|
m_bInvalid = FALSE;
|
|
}
|
|
|
|
~CColumnSetData()
|
|
{
|
|
m_colInfoList.clear();
|
|
m_colSortList.clear();
|
|
|
|
m_dwRank = -1;
|
|
m_bInvalid = FALSE;
|
|
}
|
|
|
|
CColumnSetData(const CColumnSetData& colSetInfo)
|
|
{
|
|
m_colInfoList = colSetInfo.m_colInfoList;
|
|
m_colSortList = colSetInfo.m_colSortList;
|
|
|
|
m_dwRank = colSetInfo.m_dwRank;
|
|
m_bInvalid = FALSE;
|
|
}
|
|
|
|
CColumnSetData& operator=(const CColumnSetData& colSetInfo)
|
|
{
|
|
if (this != &colSetInfo)
|
|
{
|
|
m_colInfoList = colSetInfo.m_colInfoList;
|
|
m_colSortList = colSetInfo.m_colSortList;
|
|
|
|
m_dwRank = colSetInfo.m_dwRank;
|
|
m_bInvalid = colSetInfo.m_bInvalid;
|
|
}
|
|
|
|
return (*this);
|
|
}
|
|
|
|
bool operator ==(const CColumnSetData &colinfo) const
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
bool operator< (const CColumnSetData& colSetInfo)
|
|
{
|
|
return (m_dwRank < colSetInfo.m_dwRank);
|
|
}
|
|
|
|
CColumnInfoList* get_ColumnInfoList()
|
|
{
|
|
return &m_colInfoList;
|
|
}
|
|
|
|
void set_ColumnInfoList(const CColumnInfoList& colInfoList)
|
|
{
|
|
m_colInfoList = colInfoList;
|
|
}
|
|
|
|
CColumnSortList* get_ColumnSortList()
|
|
{
|
|
return &m_colSortList;
|
|
}
|
|
|
|
void set_ColumnSortList(CColumnSortList& colSortList)
|
|
{
|
|
m_colSortList = colSortList;
|
|
}
|
|
|
|
protected:
|
|
// Needed for book keeping.
|
|
DWORD m_dwRank; // Usage rank.
|
|
BOOL m_bInvalid; // For garbage collection.
|
|
|
|
protected:
|
|
// Persisted data.
|
|
CColumnInfoList m_colInfoList;
|
|
CColumnSortList m_colSortList;
|
|
|
|
protected:
|
|
// CSerialObject methods
|
|
// Version 2 had view settings removed. This data should be skipped while reading
|
|
// version 1 files.
|
|
virtual UINT GetVersion() {return 2;}
|
|
virtual HRESULT ReadSerialObject (IStream &stm, UINT nVersion /*,LARGE_INTEGER nBytes*/);
|
|
|
|
protected:
|
|
DEFINE_XML_TYPE(XML_TAG_COLUMN_SET_DATA);
|
|
virtual void Persist(CPersistor &persistor);
|
|
};
|
|
|
|
typedef const BYTE * LPCBYTE;
|
|
typedef std::vector<BYTE> ByteVector;
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Class: CColumnSetID
|
|
//
|
|
// Purpose: Identifier for a Column-Set. A a column-set is a set of
|
|
// columns inserted by a snapin. When the user selects a
|
|
// different node in that snapin same or different column-set
|
|
/// may be shown by the snapin. MMC asks snapin to provide an
|
|
// ID (either SColumnSetID or NodeTypeGuid) to uniquely identify
|
|
// each column-set so that it can persist the column data.
|
|
// This enables MMC to use this GUID to load and use the column
|
|
// data across different instances,locales and systems.
|
|
//
|
|
// History: 02-08-1998 AnandhaG Created
|
|
//
|
|
//--------------------------------------------------------------------
|
|
class CColumnSetID : public CXMLObject
|
|
{
|
|
public:
|
|
friend class CColumnPersistInfo;
|
|
|
|
friend IStream& operator>> (IStream& stm, CColumnSetID& colID);
|
|
friend IStream& operator<< (IStream& stm, const CColumnSetID& colID);
|
|
|
|
private:
|
|
void CommonConstruct (const SColumnSetID& refColID)
|
|
{
|
|
m_vID.clear();
|
|
m_dwFlags = refColID.dwFlags;
|
|
m_vID.insert (m_vID.begin(), refColID.id, refColID.id + refColID.cBytes);
|
|
}
|
|
|
|
void CommonConstruct (const CLSID& clsidNodeType)
|
|
{
|
|
m_dwFlags = 0;
|
|
BYTE* pbByte = (BYTE*)&clsidNodeType;
|
|
|
|
if (pbByte != NULL)
|
|
{
|
|
m_vID.clear();
|
|
m_vID.insert (m_vID.begin(), pbByte, pbByte + sizeof(CLSID));
|
|
}
|
|
}
|
|
|
|
public:
|
|
CColumnSetID() : m_dwFlags(0)
|
|
{
|
|
}
|
|
|
|
~CColumnSetID() {}
|
|
|
|
CColumnSetID(LPCBYTE& pbInit)
|
|
{
|
|
// pbInit now points to a SColumnSetID; initialize from it
|
|
const SColumnSetID* pColID = reinterpret_cast<const SColumnSetID*>(pbInit);
|
|
CommonConstruct (*pColID);
|
|
|
|
// bump the input pointer to the next element
|
|
pbInit += sizeof (pColID->cBytes) + pColID->cBytes;
|
|
}
|
|
|
|
CColumnSetID(const SColumnSetID& refColID)
|
|
{
|
|
CommonConstruct (refColID);
|
|
}
|
|
|
|
|
|
CColumnSetID(const CLSID& clsidNodeType)
|
|
{
|
|
CommonConstruct (clsidNodeType);
|
|
}
|
|
|
|
CColumnSetID(const CColumnSetID& colID)
|
|
{
|
|
m_dwFlags = colID.m_dwFlags;
|
|
m_vID = colID.m_vID;
|
|
}
|
|
|
|
CColumnSetID& operator=(const CColumnSetID& colID)
|
|
{
|
|
if (this != &colID)
|
|
{
|
|
m_dwFlags = colID.m_dwFlags;
|
|
m_vID = colID.m_vID;
|
|
}
|
|
|
|
return (*this);
|
|
}
|
|
|
|
bool operator ==(const CColumnSetID& colID) const
|
|
{
|
|
return (m_vID == colID.m_vID);
|
|
}
|
|
|
|
bool operator <(const CColumnSetID& colID) const
|
|
{
|
|
return (m_vID < colID.m_vID);
|
|
}
|
|
|
|
DWORD GetFlags() const { return m_dwFlags; }
|
|
int empty () const { return (m_vID.empty()); }
|
|
|
|
DEFINE_XML_TYPE(NULL); // not to be persisted as alone element
|
|
virtual void Persist(CPersistor &persistor);
|
|
|
|
protected:
|
|
DWORD m_dwFlags;
|
|
ByteVector m_vID;
|
|
};
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: operator>>
|
|
//
|
|
// Synopsis: Writes CColumnSetID data to stream.
|
|
//
|
|
// Arguments: [stm] - The input stream.
|
|
// [colID] - CColumnSetID structure.
|
|
//
|
|
// The format is :
|
|
// DWORD flags
|
|
// ByteVector
|
|
//
|
|
//--------------------------------------------------------------------
|
|
inline IStream& operator>> (IStream& stm, CColumnSetID& colID)
|
|
{
|
|
return (stm >> colID.m_dwFlags >> colID.m_vID);
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: operator<<
|
|
//
|
|
// Synopsis: Reads CColumnSortInfo data from the stream.
|
|
//
|
|
// Arguments: [stm] - The stream to write to.
|
|
// [colID] - CColumnSetID structure.
|
|
//
|
|
// The format is :
|
|
// DWORD flags
|
|
// ByteVector
|
|
//
|
|
//--------------------------------------------------------------------
|
|
inline IStream& operator<< (IStream& stm, const CColumnSetID& colID)
|
|
{
|
|
return (stm << colID.m_dwFlags << colID.m_vID);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Data structures used to persist column information:
|
|
//
|
|
// Column information is persisted as follows:
|
|
// Internally, the following data structure is used. Column information
|
|
// is recorded per snapin, per column ID, per view.
|
|
// map map map
|
|
// CLSID ------> column ID ------> view ID -----> iterator to a list
|
|
// containing data.
|
|
//
|
|
// The data itself is stored in an object of type CColumnSetData.
|
|
// This has subobjects to store column width, column sorting, and view
|
|
// options.
|
|
//
|
|
// The list contains CColumnSetData to all the views, all snapins
|
|
// and all col-ids.
|
|
//
|
|
// Persistence: The information is serialized as follows:
|
|
//
|
|
// 1) Stream version
|
|
// 2) Number of snapins
|
|
// 3) For each snapin:
|
|
// i) snapin CLSID
|
|
// ii) number of column IDs
|
|
// For each column ID:
|
|
// i) column ID
|
|
// ii) Number of views
|
|
// For each view:
|
|
// i) View ID
|
|
// ii) Column data (CColumnSetData).
|
|
//--------------------------------------------------------------------
|
|
|
|
//*********************************************************************
|
|
//
|
|
// Note:
|
|
// The alpha compiler is unable to resolve long names and calls
|
|
// wrong version of stl::map::erase (bug# 295465).
|
|
// So we derive dummy classes like I1, V1, C1, S1 to shorten
|
|
// those names.
|
|
//
|
|
// To repro the problem define _ALPHA_BUG_IN_MMC and compile mmc
|
|
//
|
|
// Classes: I1, V1, C1, S1
|
|
//
|
|
// For version 2.0 the change was undone. But the names are not
|
|
// long anymore, since classes are derived from maps (not typedef'ed)
|
|
//
|
|
//*********************************************************************
|
|
//*********************************************************************
|
|
|
|
// A list of all ColumnSet datas.
|
|
typedef list<CColumnSetData > ColSetDataList;
|
|
|
|
typedef ColSetDataList::iterator ItColSetDataList;
|
|
|
|
// A one to one map from ViewID to iterator to CColumnSetData.
|
|
class ViewToColSetDataMap : public map<int /*nViewID*/, ItColSetDataList>
|
|
{
|
|
};
|
|
typedef ViewToColSetDataMap::value_type ViewToColSetDataVal;
|
|
|
|
// A one to one map from CColumnSetID to ViewToColSetDataMap.
|
|
class ColSetIDToViewTableMap : public map<CColumnSetID, ViewToColSetDataMap>
|
|
{
|
|
};
|
|
typedef ColSetIDToViewTableMap::value_type ColSetIDToViewTableVal;
|
|
|
|
// A one to one map from Snapin GUID to ColSetIDToToViewTableMap (snapins widthsets)
|
|
class SnapinToColSetIDMap : public map<CLSID, ColSetIDToViewTableMap>
|
|
{
|
|
};
|
|
typedef SnapinToColSetIDMap::value_type SnapinToColSetIDVal;
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Some helper data structures that wont be persisted.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
// A vector of strings to store column names
|
|
typedef vector<tstring> TStringVector;
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Class: CColumnPersistInfo
|
|
//
|
|
// Purpose: This class has column persistence information for all
|
|
// views (therefore one per instance of mmc).
|
|
// Knows to load/save the info from streams.
|
|
//
|
|
// History: 10-27-1998 AnandhaG Created
|
|
//
|
|
// Data structures used to persist column information:
|
|
// A map from the ViewID to the CColumnSetData class.
|
|
// A multimap from ColumnSet-ID to above map.
|
|
// A map that maps snapin GUID to above map.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
class CColumnPersistInfo : public IPersistStream, public CComObjectRoot, public CXMLObject
|
|
{
|
|
private:
|
|
BOOL m_bInitialized;
|
|
auto_ptr<ColSetDataList> m_spColSetList;
|
|
auto_ptr<SnapinToColSetIDMap> m_spSnapinsMap;
|
|
|
|
// This is the max number of items specified by user???
|
|
// We go 40% more so that we dont do garbage collection often.
|
|
DWORD m_dwMaxItems;
|
|
|
|
BOOL m_bDirty;
|
|
|
|
private:
|
|
BOOL ClearAllEntries();
|
|
|
|
public:
|
|
/*
|
|
* ATL COM map
|
|
*/
|
|
BEGIN_COM_MAP (CColumnPersistInfo)
|
|
COM_INTERFACE_ENTRY (IPersistStream)
|
|
END_COM_MAP ()
|
|
|
|
public:
|
|
CColumnPersistInfo();
|
|
~CColumnPersistInfo();
|
|
|
|
BOOL Init();
|
|
|
|
BOOL RetrieveColumnData( const CLSID& refSnapinCLSID, const SColumnSetID& colID,
|
|
INT nViewID, CColumnSetData& columnSetData);
|
|
BOOL SaveColumnData( const CLSID& refSnapinCLSID, const SColumnSetID& colID,
|
|
INT nViewID, CColumnSetData& columnSetData);
|
|
VOID DeleteColumnData( const CLSID& refSnapinCLSID, const SColumnSetID& colID,
|
|
INT nViewID);
|
|
|
|
BOOL DeleteColumnDataOfSnapin( const CLSID& refSnapinCLSID);
|
|
BOOL DeleteColumnDataOfView( int nViewID);
|
|
|
|
VOID GarbageCollectItems();
|
|
VOID DeleteMarkedItems();
|
|
|
|
// IPersistStream methods
|
|
STDMETHOD(IsDirty)(void)
|
|
{
|
|
if (m_bDirty)
|
|
return S_OK;
|
|
|
|
return S_FALSE;
|
|
}
|
|
|
|
STDMETHOD(GetSizeMax)(ULARGE_INTEGER *pcbSize)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHOD(GetClassID)(LPCLSID lpClsid)
|
|
{
|
|
lpClsid = NULL;
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHOD(Load)(IStream *pStm);
|
|
STDMETHOD(Save)(IStream *pStm, BOOL fClearDirty);
|
|
|
|
DEFINE_XML_TYPE(XML_TAG_COLUMN_PERIST_INFO);
|
|
virtual void Persist(CPersistor &persistor);
|
|
};
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Class: CColumnDlg
|
|
//
|
|
// Purpose: The column modification dialog.
|
|
//
|
|
// History: 11-15-1998 AnandhaG Created
|
|
//
|
|
//--------------------------------------------------------------------
|
|
class CColumnsDlg : public CDialogImpl<CColumnsDlg>
|
|
{
|
|
typedef CColumnsDlg ThisClass;
|
|
typedef CDialogImpl<CColumnsDlg> BaseClass;
|
|
|
|
// Constructor/Destrcutor
|
|
public:
|
|
|
|
CColumnsDlg(CColumnInfoList *pColumnInfoList, TStringVector* pStringVector, CColumnInfoList& defaultColumnInfoList)
|
|
: m_pColumnInfoList(pColumnInfoList), m_pStringVector(pStringVector), m_bDirty(false),
|
|
m_DefaultColumnInfoList(defaultColumnInfoList), m_bUsingDefaultColumnSettings(false)
|
|
{}
|
|
|
|
|
|
~CColumnsDlg()
|
|
{}
|
|
|
|
|
|
//MSGMAP
|
|
public:
|
|
BEGIN_MSG_MAP(ThisClass)
|
|
MESSAGE_HANDLER (WM_INITDIALOG, OnInitDialog)
|
|
CONTEXT_HELP_HANDLER()
|
|
COMMAND_ID_HANDLER (IDOK, OnOK)
|
|
COMMAND_ID_HANDLER (IDCANCEL, OnCancel)
|
|
COMMAND_ID_HANDLER (IDC_MOVEUP_COLUMN, OnMoveUp)
|
|
COMMAND_ID_HANDLER (IDC_MOVEDOWN_COLUMN , OnMoveDown)
|
|
COMMAND_ID_HANDLER (IDC_ADD_COLUMNS, OnAdd)
|
|
COMMAND_ID_HANDLER (IDC_REMOVE_COLUMNS, OnRemove)
|
|
COMMAND_ID_HANDLER (IDC_RESTORE_DEFAULT_COLUMNS, OnRestoreDefaultColumns)
|
|
COMMAND_HANDLER (IDC_HIDDEN_COLUMNS, LBN_SELCHANGE, OnSelChange);
|
|
COMMAND_HANDLER (IDC_DISPLAYED_COLUMNS, LBN_SELCHANGE, OnSelChange);
|
|
COMMAND_HANDLER (IDC_HIDDEN_COLUMNS, LBN_DBLCLK, OnAdd);
|
|
COMMAND_HANDLER (IDC_DISPLAYED_COLUMNS, LBN_DBLCLK, OnRemove);
|
|
END_MSG_MAP()
|
|
|
|
IMPLEMENT_CONTEXT_HELP(g_aHelpIDs_IDD_COLUMNS);
|
|
|
|
public:
|
|
// Operators
|
|
enum { IDD = IDD_COLUMNS };
|
|
|
|
// Generated message map functions
|
|
protected:
|
|
LRESULT OnInitDialog (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
|
|
LRESULT OnOK (WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
|
|
LRESULT OnCancel (WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
|
|
LRESULT OnMoveUp (WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
|
|
LRESULT OnMoveDown (WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
|
|
LRESULT OnAdd (WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
|
|
LRESULT OnRemove (WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
|
|
LRESULT OnRestoreDefaultColumns (WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
|
|
|
|
LRESULT OnSelChange (WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
|
|
|
|
LRESULT OnHelp (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
|
|
|
|
private:
|
|
void MoveItem (BOOL bMoveUp);
|
|
void InitializeLists ();
|
|
void EnableUIObjects ();
|
|
int GetColIndex(LPCTSTR lpszColName);
|
|
void SetListBoxHorizontalScrollbar(WTL::CListBox& listBox);
|
|
void SetDirty() { m_bDirty = true; m_bUsingDefaultColumnSettings = false;}
|
|
void SetUsingDefaultColumnSettings() { m_bDirty = true; m_bUsingDefaultColumnSettings = true;}
|
|
bool EnableControl(HWND hwnd, bool bEnable);
|
|
|
|
void SetListBoxHScrollSize()
|
|
{
|
|
SetListBoxHorizontalScrollbar(m_DisplayedColList);
|
|
SetListBoxHorizontalScrollbar(m_HiddenColList);
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
WTL::CListBox m_HiddenColList;
|
|
WTL::CListBox m_DisplayedColList;
|
|
WTL::CButton m_btnAdd;
|
|
WTL::CButton m_btnRemove;
|
|
WTL::CButton m_btnRestoreDefaultColumns;
|
|
WTL::CButton m_btnMoveUp;
|
|
WTL::CButton m_btnMoveDown;
|
|
|
|
CColumnInfoList* m_pColumnInfoList;
|
|
TStringVector* m_pStringVector;
|
|
CColumnInfoList& m_DefaultColumnInfoList;
|
|
bool m_bDirty;
|
|
bool m_bUsingDefaultColumnSettings;
|
|
};
|
|
|
|
#endif /* COLWIDTH_H */
|