582 lines
19 KiB
C++
582 lines
19 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1999 - 1999
|
|
//
|
|
// File: cclvctl.h
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#ifndef _CCLVCTL_H_
|
|
#define _CCLVCTL_H_
|
|
|
|
// cclvctl.h : header file
|
|
//
|
|
#include <objbase.h>
|
|
#include <atlbase.h>
|
|
#include <atlcom.h>
|
|
#include "imagemap.h"
|
|
#include "ndmgr.h"
|
|
#include "fontlink.h"
|
|
#include "amcnav.h"
|
|
#include "dd.h"
|
|
#include "columninfo.h"
|
|
|
|
// Don't let macro override CWnd method
|
|
#undef SubclassWindow
|
|
|
|
class CAMCView;
|
|
class CCCListViewCtrl;
|
|
class CResultItem;
|
|
|
|
class CListFontLinker : public CFontLinker
|
|
{
|
|
public:
|
|
CListFontLinker (CCCListViewCtrl* pListCtrl) : m_pListCtrl (pListCtrl)
|
|
{ ASSERT (m_pListCtrl != NULL); }
|
|
|
|
protected:
|
|
virtual bool IsAnyItemLocalizable () const;
|
|
virtual std::wstring GetItemText (NMCUSTOMDRAW* pnmcd) const;
|
|
|
|
private:
|
|
CCCListViewCtrl* const m_pListCtrl;
|
|
};
|
|
|
|
|
|
class CSysColorImageList : public CImageList
|
|
{
|
|
public:
|
|
CSysColorImageList (HINSTANCE hInst, UINT nID)
|
|
: m_hInst (hInst),
|
|
m_hRsrc (::FindResource (m_hInst, MAKEINTRESOURCE (nID), RT_BITMAP))
|
|
{
|
|
CreateSysColorImageList();
|
|
}
|
|
|
|
void OnSysColorChange ()
|
|
{
|
|
DeleteImageList();
|
|
CreateSysColorImageList();
|
|
}
|
|
|
|
operator HIMAGELIST() const
|
|
{
|
|
return (CImageList::operator HIMAGELIST());
|
|
}
|
|
|
|
private:
|
|
void CreateSysColorImageList ()
|
|
{
|
|
CBitmap bmp;
|
|
bmp.Attach (AfxLoadSysColorBitmap (m_hInst, m_hRsrc));
|
|
|
|
/*
|
|
* get the dimensions of the bitmap
|
|
*/
|
|
BITMAP bm;
|
|
bmp.GetBitmap (&bm);
|
|
|
|
/*
|
|
* assume square images (cx == cy)
|
|
*/
|
|
Create (bm.bmHeight, bm.bmHeight, ILC_COLORDDB, bm.bmWidth / bm.bmHeight, 2);
|
|
Add (&bmp, CLR_NONE);
|
|
}
|
|
|
|
HINSTANCE m_hInst;
|
|
HRSRC m_hRsrc;
|
|
};
|
|
|
|
|
|
class CAMCHeaderCtrl : public CHeaderCtrl
|
|
{
|
|
public:
|
|
bool IsColumnHidden(int iCol);
|
|
|
|
protected:
|
|
afx_msg void OnSetFocus(CWnd *pOldWnd);
|
|
afx_msg BOOL OnSetCursor( CWnd* pWnd, UINT nHitTest, UINT message );
|
|
|
|
DECLARE_MESSAGE_MAP()
|
|
};
|
|
|
|
|
|
class CFocusHandler
|
|
{
|
|
public:
|
|
virtual void OnKeyboardFocus(UINT nState, UINT nStateMask) = 0;
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CAMCListView
|
|
|
|
class CAMCListView :
|
|
public CListView,
|
|
public CAMCNavigator,
|
|
public CFocusHandler,
|
|
public CMMCViewDropTarget,
|
|
public CEventSource<CListViewActivationObserver>
|
|
{
|
|
// Construction
|
|
public:
|
|
CAMCListView() :
|
|
m_bVirtual(false),
|
|
m_iDropTarget(-1),
|
|
m_pAMCView(NULL),
|
|
m_bColumnsNeedToBeRestored(true),
|
|
m_bColumnsBeingRestored(false)
|
|
{
|
|
DEBUG_INCREMENT_INSTANCE_COUNTER(CAMCListView);
|
|
}
|
|
~CAMCListView()
|
|
{
|
|
if (m_header.m_hWnd)
|
|
m_header.UnsubclassWindow();
|
|
|
|
DEBUG_DECREMENT_INSTANCE_COUNTER(CAMCListView);
|
|
}
|
|
|
|
// CFocusHandler implementation
|
|
virtual void OnKeyboardFocus(UINT nState, UINT nStateMask);
|
|
|
|
// CAMCNavigator implementation
|
|
virtual BOOL ChangePane(AMCNavDir eDir);
|
|
virtual BOOL TakeFocus(AMCNavDir eDir);
|
|
|
|
SC ScOnColumnsAttributeChanged(NMHEADER *pNMHeader, UINT code);
|
|
|
|
// Setup header width/order/hiddenness from columninfolist data.
|
|
SC ScRestoreColumnsFromPersistedData();
|
|
|
|
SC ScGetColumnInfoList(CColumnInfoList *pColumnsList);
|
|
SC ScModifyColumns(const CColumnInfoList& colInfoList);
|
|
SC ScSaveColumnInfoList();
|
|
SC ScGetDefaultColumnInfoList(CColumnInfoList& columnsList);
|
|
|
|
SC ScResetColumnStatusData();
|
|
|
|
// Overrides
|
|
// ClassWizard generated virtual function overrides
|
|
//{{AFX_VIRTUAL(CAMCListView)
|
|
public:
|
|
virtual void OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint);
|
|
virtual BOOL OnCmdMsg( UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo );
|
|
protected:
|
|
virtual void OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView);
|
|
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
|
|
//}}AFX_VIRTUAL
|
|
|
|
public:
|
|
|
|
virtual SC ScDropOnTarget(bool bHitTestOnly, IDataObject * pDataObject, CPoint pt, bool& bCopyOperation);
|
|
virtual void RemoveDropTargetHiliting();
|
|
|
|
void SetVirtual()
|
|
{
|
|
m_bVirtual = true;
|
|
}
|
|
|
|
bool IsInLargeIconMode() const
|
|
{
|
|
return (GetMode() == LVS_ICON);
|
|
}
|
|
|
|
bool IsInSmallIconMode() const
|
|
{
|
|
return (GetMode() == LVS_SMALLICON);
|
|
}
|
|
|
|
bool IsInListMode() const
|
|
{
|
|
return (GetMode() == LVS_LIST);
|
|
}
|
|
|
|
bool IsInReportMode() const
|
|
{
|
|
return (GetMode() == LVS_REPORT);
|
|
}
|
|
|
|
bool IsInFilteredReportMode() const
|
|
{
|
|
if (!IsInReportMode())
|
|
return (false);
|
|
|
|
CWnd* pwndHeader = GetHeaderCtrl();
|
|
if (pwndHeader == NULL)
|
|
return (false);
|
|
|
|
return (pwndHeader->GetStyle() & HDS_FILTERBAR);
|
|
}
|
|
|
|
DWORD SetExtendedListViewStyle (DWORD dwExStyle, DWORD dwExMask = 0)
|
|
{
|
|
return (SendMessage (LVM_SETEXTENDEDLISTVIEWSTYLE, dwExMask, dwExStyle));
|
|
}
|
|
|
|
CAMCView* GetAMCView() const
|
|
{
|
|
return (m_pAMCView);
|
|
}
|
|
|
|
CAMCHeaderCtrl* GetHeaderCtrl() const;
|
|
|
|
bool AreColumnsNeedToBeRestored() const { return m_bColumnsNeedToBeRestored;}
|
|
void SetColumnsNeedToBeRestored(bool b = false) {m_bColumnsNeedToBeRestored = b;}
|
|
|
|
bool IsColumnHidden(int iCol) const;
|
|
|
|
protected:
|
|
//{{AFX_MSG(CAMCListView)
|
|
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
|
|
afx_msg void OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags);
|
|
afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
|
|
afx_msg void OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
|
|
afx_msg void OnSysChar(UINT nChar, UINT nRepCnt, UINT nFlags);
|
|
afx_msg void OnBeginDrag(NMHDR* pNMHDR, LRESULT* pResult);
|
|
afx_msg void OnBeginRDrag(NMHDR* pNMHDR, LRESULT* pResult);
|
|
afx_msg int OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message);
|
|
afx_msg void OnSetFocus(CWnd* pOldWnd);
|
|
afx_msg void OnPaint();
|
|
afx_msg void OnSize(UINT nType, int cx, int cy);
|
|
afx_msg void OnBeginTrack(NMHDR * pNotifyStruct, LRESULT * result);
|
|
//}}AFX_MSG
|
|
|
|
afx_msg LRESULT OnColumnPersistedDataChanged (WPARAM, LPARAM);
|
|
|
|
DECLARE_MESSAGE_MAP()
|
|
|
|
private:
|
|
bool m_bVirtual;
|
|
|
|
CAMCView* m_pAMCView;
|
|
mutable CAMCHeaderCtrl m_header; // mutable so GetHeaderCtrl can call CWnd::SubclassWindow
|
|
int m_iDropTarget;
|
|
CColumnInfoList m_defaultColumnInfoList;
|
|
|
|
|
|
INodeCallback* GetNodeCallback();
|
|
HNODE GetScopePaneSelNode();
|
|
void SelectDropTarget(int iDropTarget);
|
|
bool ActivateSelf (bool fNotify = true);
|
|
bool NeedsCustomPaint ();
|
|
|
|
SC ScGetDropTarget(const CPoint& point, HNODE& hNode, bool& bScope, LPARAM& lvData, int& iDrop);
|
|
|
|
DWORD GetMode () const
|
|
{
|
|
return (GetStyle() & LVS_TYPEMASK);
|
|
}
|
|
|
|
private:
|
|
// For columns
|
|
static const UINT m_nColumnPersistedDataChangedMsg;
|
|
|
|
// To allow hidden column width changes.
|
|
bool m_bColumnsBeingRestored;
|
|
|
|
// We dont care if restore is success or failure.
|
|
bool m_bColumnsNeedToBeRestored;
|
|
};
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CCCListViewCtrl window
|
|
|
|
class CCCListViewCtrl :
|
|
public IMMCListView,
|
|
public CComObjectRoot,
|
|
public CEventSource<CListViewObserver>,
|
|
public CTiedObject
|
|
{
|
|
// Construction
|
|
public:
|
|
CCCListViewCtrl();
|
|
virtual ~CCCListViewCtrl();
|
|
|
|
// initialization
|
|
SC ScInitialize();
|
|
|
|
BEGIN_COM_MAP(CCCListViewCtrl)
|
|
COM_INTERFACE_ENTRY(IMMCListView)
|
|
END_COM_MAP()
|
|
|
|
typedef struct _SortParams
|
|
{
|
|
BOOL bAscending; // sort direction
|
|
BOOL bLexicalSort; // apply default sort to all items
|
|
int nCol; // Which column to sort on.
|
|
COMPONENTID OwnerID;
|
|
void * lpListView; // CCCListViewCtrl *
|
|
IResultDataComparePtr spResultCompare; // Snap-in component interface
|
|
IResultDataCompareExPtr spResultCompareEx; // "
|
|
LPNODECALLBACK lpNodeCallback;
|
|
LPARAM lpUserParam; // parameter user passes in
|
|
HNODE hSelectedNode; // Currently selected node in scope pane.
|
|
} SortParams;
|
|
|
|
|
|
//DECLARE_AGGREGATABLE(CCCListViewCtrl)
|
|
//DECLARE_REGISTRY(CNodeInitObject, _T("NODEMGR.NodeInitObject.1"), _T("NODEMGR.NodeInitObject.1"), IDS_NODEINIT_DESC, THREADFLAGS_BOTH)
|
|
|
|
// Operations
|
|
public:
|
|
#ifdef IMPLEMENT_LIST_SAVE // See nodemgr.idl (t-dmarm)
|
|
long GetColCount() const { return m_colCount; }
|
|
long GetItemCount() const { return m_itemCount; }
|
|
#endif
|
|
|
|
CAMCListView* GetListViewPtr() const { return m_pListView; }
|
|
CListCtrl& GetListCtrl() const { return m_pListView->GetListCtrl(); }
|
|
CAMCHeaderCtrl* GetHeaderCtrl() const { return m_pListView->GetHeaderCtrl(); }
|
|
|
|
bool AreColumnsNeedToBeRestored() const { return m_pListView->AreColumnsNeedToBeRestored();}
|
|
void SetColumnsNeedToBeRestored(bool b = true) {m_pListView->SetColumnsNeedToBeRestored(b);}
|
|
|
|
bool IsColumnHidden(int iCol) const {return m_pListView->IsColumnHidden(iCol);}
|
|
|
|
SC ScGetAMCView(CAMCView **ppAMCView);
|
|
|
|
HWND GetListViewHWND() const { return m_pListView->GetSafeHwnd(); }
|
|
|
|
BOOL IsVirtual() const { return m_bVirtual; }
|
|
BOOL Create( DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext=NULL);
|
|
|
|
SC ScAttachToListPad (HWND hwnd, HWND* phwnd); // NULL hwnd == detach
|
|
BOOL IsListPad () const { return m_SavedHWND != NULL; }
|
|
|
|
LRESULT OnCustomDraw (NMLVCUSTOMDRAW* plvcd);
|
|
void OnSysColorChange();
|
|
|
|
// IMMCListView Methods
|
|
STDMETHOD(GetListStyle) ();
|
|
STDMETHOD(SetListStyle) (long nNewValue);
|
|
STDMETHOD(GetViewMode) ();
|
|
STDMETHOD(SetViewMode) (long nViewMode);
|
|
STDMETHOD(InsertItem) (LPOLESTR str, long iconNdx, LPARAM lParam, long state, COMPONENTID ownerID, long itemIndex, CResultItem*& pri);
|
|
STDMETHOD(DeleteItem) (HRESULTITEM itemID, long nCol);
|
|
STDMETHOD(FindItemByLParam) (COMPONENTID ownerID, LPARAM lParam, CResultItem*& pri);
|
|
STDMETHOD(InsertColumn) (int nCol, LPCOLESTR str, long nFormat, long width);
|
|
STDMETHOD(DeleteColumn) (int nCol);
|
|
STDMETHOD(DeleteAllItems) (COMPONENTID ownerID);
|
|
STDMETHOD(SetColumn) (long nCol, LPCOLESTR str, long nFormat, long width);
|
|
STDMETHOD(GetColumn) (long nCol, LPOLESTR* str, LPLONG nFormat, int FAR* width);
|
|
STDMETHOD(GetColumnCount) (int* pnColCnt);
|
|
STDMETHOD(SetItem) (int nIndex, CResultItem* pri, long nCol, LPOLESTR str, long nImage, LPARAM lParam, long nState, COMPONENTID ownerID);
|
|
STDMETHOD(GetItem) (int nIndex, CResultItem*& pri, long nCol, LPOLESTR* str, int FAR *nImage, LPARAM* lParam, unsigned int FAR *nState, BOOL* pbScopeItem);
|
|
STDMETHOD(GetNextItem) (COMPONENTID ownerID, long nIndex, UINT nState, CResultItem*& pri, long& nIndexNextItem);
|
|
STDMETHOD(GetLParam) (long nItem, CResultItem*& pri);
|
|
STDMETHOD(ModifyItemState) (long nItem, CResultItem* pri, UINT add, UINT remove);
|
|
STDMETHOD(SetIcon) (long nID, HICON hIcon, long nLoc);
|
|
STDMETHOD(SetImageStrip) (long nID, HBITMAP hbmSmall, HBITMAP hbmLarge, long nStartLoc, long cMask);
|
|
STDMETHOD(MapImage) (COMPONENTID nID, long nLoc, int far *pResult);
|
|
STDMETHOD(Reset) ();
|
|
STDMETHOD(Arrange) (long style);
|
|
STDMETHOD(UpdateItem) (HRESULTITEM itemID);
|
|
STDMETHOD(Sort) (LPARAM lUserParam, long* lpParams);
|
|
STDMETHOD(SetItemCount) (int nItemCount, DWORD dwOptions);
|
|
STDMETHOD(SetVirtualMode) (BOOL bVirtual);
|
|
STDMETHOD(Repaint) (BOOL bErase);
|
|
STDMETHOD(SetChangeTimeOut) (ULONG lTimeout);
|
|
STDMETHOD(SetColumnFilter) (int nCol, DWORD dwType, MMC_FILTERDATA* pFilterData);
|
|
STDMETHOD(GetColumnFilter) (int nCol, DWORD* dwType, MMC_FILTERDATA* pFilterData);
|
|
STDMETHOD(SetColumnSortIcon) (int nNewCol, int nOldCol, BOOL bAscending, BOOL bSetSortIcon);
|
|
STDMETHOD(SetLoadMode) (BOOL bState);
|
|
STDMETHOD(GetColumnInfoList) (CColumnInfoList *pColumnsList);
|
|
STDMETHOD(ModifyColumns) (const CColumnInfoList& columnsList);
|
|
STDMETHOD(RenameItem) (HRESULTITEM itemID);
|
|
STDMETHOD(GetDefaultColumnInfoList)( CColumnInfoList& columnsList);
|
|
|
|
|
|
STDMETHOD(OnModifyItem)(CResultItem* pri);
|
|
|
|
void CutSelectedItems(BOOL b);
|
|
bool UseFontLinking() const;
|
|
|
|
UINT GetSelectedCount()
|
|
{ return (GetListCtrl().GetSelectedCount()); }
|
|
|
|
// these methods implement access to enumerations for AMCView
|
|
SC Scget_ListItems( PPNODES ppNodes );
|
|
SC Scget_SelectedItems( PPNODES ppNodes);
|
|
SC ScSelect( PNODE pNode);
|
|
SC ScDeselect( PNODE pNode);
|
|
SC ScIsSelected( PNODE pNode, PBOOL pIsSelected);
|
|
SC ScSelectAll();
|
|
|
|
// method used from Nodes collections
|
|
SC ScValidateItem( int iItem, bool &bScopeNode );
|
|
|
|
// method transfering requests from Nodes to AMCView (for scope nodes only)
|
|
SC ScGetScopeNodeForItem ( int iItem, PPNODE ppNode );
|
|
|
|
// Columns access methods
|
|
SC Scget_Columns( PPCOLUMNS Columns );
|
|
SC ScItem( long Index, PPCOLUMN ppColumn );
|
|
SC Scget_Count( PLONG pCount );
|
|
SC ScEnumNext(int &pos, PDISPATCH & pDispatch); // should return the next element.
|
|
SC ScEnumSkip(unsigned long celt, unsigned long& celtSkipped, int &pos);
|
|
SC ScEnumReset(int &pos);
|
|
// methods called from Column instances
|
|
SC ScName( /*[out, retval]*/ BSTR *Name, int iColIndex );
|
|
SC Scget_Width( /*[out, retval]*/ PLONG Width, int iColIndex );
|
|
SC Scput_Width( /*[in]*/ long Width, int iColIndex );
|
|
SC Scget_DisplayPosition( /*[out, retval]*/ PLONG DisplayPosition, int iColIndex );
|
|
SC Scput_DisplayPosition( /*[in]*/ long Index, int iColIndex );
|
|
SC Scget_Hidden( /*[out, retval]*/ PBOOL Hidden, int iColIndex );
|
|
SC Scput_Hidden( /*[in]*/ BOOL Hidden , int iColIndex );
|
|
SC ScSetAsSortColumn( /*[in]*/ ColumnSortOrder SortOrder, int iColIndex );
|
|
SC ScIsSortColumn( PBOOL IsSortColumn, int iColIndex );
|
|
// Column/Columns implementation helpers
|
|
struct ColumnData
|
|
{
|
|
int iColumnWidth;
|
|
int iColumnOrder;
|
|
bool bIsHidden;
|
|
// initialization
|
|
void Init() { iColumnWidth = 0; iColumnOrder = -1; bIsHidden = false; }
|
|
ColumnData() { Init(); }
|
|
// comparison
|
|
bool operator == (const ColumnData& other) const
|
|
{ return ( 0 == memcmp(this, &other, sizeof(ColumnData)) ); }
|
|
};
|
|
SC ScGetColumnData( int iZeroBasedColIndex, ColumnData *pColData );
|
|
SC ScSetColumnData( int iZeroBasedColIndex, const ColumnData& ColData );
|
|
|
|
SC ScFindResultItem ( PNODE pNode, int &iItem );
|
|
|
|
private:
|
|
// helper methods
|
|
SC ScGetNodesEnum ( bool bSelectedItemsOnly, PPNODES ppNodes );
|
|
SC ScAllocResultItem ( CResultItem*& pResultItem, COMPONENTID id, LPARAM lSnapinData, int nImage);
|
|
SC ScFreeResultItem ( CResultItem* pResultItem);
|
|
|
|
SC ScRedrawItem (int nIndex);
|
|
SC ScGetItemIndexFromHRESULTITEM(const HRESULTITEM& itemID, int& nIndex);
|
|
|
|
SC ScRedrawHeader(bool bRedraw);
|
|
|
|
protected:
|
|
CAMCListView* m_pListView; // current list (points to m_StandardList or m_VirtualList)
|
|
CAMCListView* m_pStandardList;
|
|
CAMCListView* m_pVirtualList;
|
|
|
|
HWND m_SavedHWND;
|
|
WINDOWPLACEMENT m_wp;
|
|
|
|
CWnd* m_pParentWnd;
|
|
|
|
//void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
|
|
//void OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
|
|
|
|
long m_itemCount; // internal item counter
|
|
long m_nScopeItems; // scope item count
|
|
long m_colCount; // internal column counter
|
|
|
|
// ImageList members
|
|
CImageList m_smallIL;
|
|
CImageList m_largeIL;
|
|
CImageIndexMap m_resultIM;
|
|
|
|
// Header Sorting (Up/Down arrow) Icons.
|
|
CSysColorImageList m_headerIL;
|
|
|
|
// Sorting members
|
|
SortParams m_sortParams;
|
|
static int CALLBACK SortCompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM pSortParams);
|
|
static int SnapinCompare(SortParams* pSortParams, CResultItem* pri1, CResultItem* pri2);
|
|
static int SnapinCompareEx(SortParams* pSortParams, CResultItem* pri1, CResultItem* pri2);
|
|
static int CALLBACK DefaultCompare(LPARAM lParam1, LPARAM lParam2, LPARAM pSortParams);
|
|
|
|
private:
|
|
CListFontLinker m_FontLinker;
|
|
NodesPtr m_spAllNodes;
|
|
NodesPtr m_spSelNodes;
|
|
ColumnsPtr m_spColumns;
|
|
|
|
BOOL m_bVirtual;
|
|
BOOL m_bFiltered; // filtering on now
|
|
BOOL m_bEnsureFocusVisible; // force focused item to be visible
|
|
BOOL m_bLoading;
|
|
BOOL m_bDeferredSort;
|
|
|
|
void SetFilterHeader(void);
|
|
SC ScSetImageLists ();
|
|
int ResultItemToIndex (CResultItem* pri) const;
|
|
CResultItem* IndexToResultItem (int nItem);
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// CQFilterDll
|
|
//
|
|
// This class dynamically loads and initializes the quickfilter DLL.
|
|
// A single instance of the class should be declared at the global level.
|
|
//
|
|
class CQFilterDll
|
|
{
|
|
public:
|
|
CQFilterDll()
|
|
{
|
|
m_hModule = LoadLibrary(_T("qfctrl.dll"));
|
|
|
|
if (m_hModule != NULL)
|
|
{
|
|
void (*pfnInitQuickFilter)();
|
|
pfnInitQuickFilter = (void (*)())GetProcAddress(m_hModule, "InitQuickFilter");
|
|
|
|
if (pfnInitQuickFilter != NULL)
|
|
(*pfnInitQuickFilter)();
|
|
}
|
|
}
|
|
|
|
CQFilterDll::~CQFilterDll()
|
|
{
|
|
if (m_hModule != NULL)
|
|
FreeLibrary(m_hModule);
|
|
}
|
|
|
|
private:
|
|
HMODULE m_hModule;
|
|
};
|
|
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CHiddenColumnInfo
|
|
*
|
|
* Contains information about a hidden column in report view: a flag
|
|
* indicating it's hidden and its width when it's not hidden.
|
|
*
|
|
* This class is stored in HDITEM.lParam for hidden columns, so it *must*
|
|
* be the same size as an LPARAM.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
class CHiddenColumnInfo
|
|
{
|
|
public:
|
|
CHiddenColumnInfo (LPARAM lParam_) : lParam (lParam_)
|
|
{
|
|
COMPILETIME_ASSERT (sizeof(CHiddenColumnInfo) == sizeof(LPARAM));
|
|
}
|
|
|
|
CHiddenColumnInfo (int cx_, bool fHidden_) : cx (cx_), fHidden (fHidden_)
|
|
{
|
|
COMPILETIME_ASSERT (sizeof(CHiddenColumnInfo) == sizeof(LPARAM));
|
|
}
|
|
|
|
union
|
|
{
|
|
LPARAM lParam;
|
|
struct
|
|
{
|
|
int cx : 16;
|
|
int fHidden : 1;
|
|
};
|
|
};
|
|
};
|
|
|
|
|
|
#endif _CCLVCTL_H_
|