Microsoft/WindowsXP-SP1
Microsoft
/
WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
WindowsXP-SP1/enduser/stuff/hhctrl/subset.cpp

2212 lines
66 KiB
C++
Raw Permalink Blame History

/*****************************************************************************
* Subset.cpp
*
* Copyright (C) Microsoft, 1989-1998
* Feb 22, 1998
*
* Modification History:
*
* Ported to hhctrl.ocx from the old B2 code base.
*
*****************************************************************************/
#include "header.h"
#include "subset.h"
#include "resource.h"
#include "toc.h"
#include "cdefinss.h"
#include "verdef.h"
#include "secwin.h"
#define CmdID LOWORD(wParam)
#define CmdCode HIWORD(wParam)
#define CmdHwnd (HWND)lParam
/*
* Defines, the EXPANDED define aids in intrepreting the proper bit in the
* FGT data structure depending on which LB we're operating on.
*/
#define EXPANDED(lb_id, ds) ((lb_id) ? ds->f_A_Open : ds->f_F_Open)
#define PRESENT(lb_id, ds) ((lb_id) ? ds->f_Available : ds->f_Filter)
// declare a static this pointer for our window procedures.
//
CDefineSS* CDefineSS::m_pThis;
//********************************************************************************
//
// CStructuralSubset Implementation - This is object representation of a subset.
//
//********************************************************************************
CSSList::CSSList()
{
m_iSubSetCount = 0;
m_pHeadSubSets = m_pFTS_SS = m_pF1_SS = m_pTOC_SS = m_pNew_SS = m_pEC_SS = NULL;
}
CSSList::~CSSList()
{
CStructuralSubset *pSS, *pSSNext;
pSS = m_pHeadSubSets;
while ( pSS )
{
pSSNext = pSS->m_pNext;
delete pSS;
pSS = pSSNext;
}
}
CStructuralSubset* CSSList::GetSubset(PSTR pszSSName)
{
CStructuralSubset *pSS = m_pHeadSubSets;
while ( pSS )
{
if (! lstrcmpi(pSS->GetName(), pszSSName) )
return pSS;
pSS = pSS->m_pNext;
}
return NULL;
}
void CSSList::DeleteSubset(CStructuralSubset* pSS, CStructuralSubset* pSSNew, /* == NULL */ HWND hWndUI /* == NULL */)
{
CStructuralSubset *pSSCurrCB, *pSSl = m_pHeadSubSets;
TCHAR szSel[MAX_SS_NAME_LEN];
HWND hWndCB;
INT_PTR i;
CHHWinType* phh;
if (! pSSNew )
pSSNew = m_pEC_SS;
if ( pSS->m_dwFlags & SS_READ_ONLY )
return;
if ( pSS == m_pFTS_SS )
m_pFTS_SS = pSSNew;
if ( pSS == m_pF1_SS )
m_pF1_SS = pSSNew;
if ( pSS == m_pTOC_SS )
m_pTOC_SS = pSSNew;
//
// If we're given an hwnd, update the combo-box UI.
//
if ( hWndUI && (hWndCB = GetDlgItem(hWndUI, IDC_SS_PICKER)) )
{
//
// Get the current CB selection and see if it's the one we're deleting ?
//
if ( ((i = SendMessage(hWndCB, CB_GETCURSEL, 0, 0L)) != -1) )
{
GetDlgItemText(hWndUI, IDC_SS_PICKER, szSel, sizeof(szSel));
pSSCurrCB = GetSubset(szSel);
if ( pSSCurrCB == pSS ) // Yep, we're deleting the current one, select the new one.
{
SendMessage(hWndCB, CB_SELECTSTRING, -1, (LPARAM)pSSNew->GetName());
if ( (phh = FindWindowIndex(hWndUI)) )
{
pSSNew->SelectAsTOCSubset(phh->m_phmData->m_pTitleCollection);
phh->UpdateInformationTypes(); // This call re-draws the TOC.
}
}
}
if ( lstrcmpi(pSS->GetName(), pSSNew->GetName()) )
{
if ( (i = SendMessage(hWndCB, CB_FINDSTRING, -1, (LPARAM)pSS->GetName())) != -1 )
SendMessage(hWndCB, CB_DELETESTRING, i, 0L);
}
}
//
// Take the delete victum out of the linked list.
//
while ( pSSl )
{
if ( pSSl->m_pNext == pSS )
{
pSSl->m_pNext = pSS->m_pNext;
delete pSS;
break;
}
pSSl = pSSl->m_pNext;
}
m_iSubSetCount--;
}
HRESULT CSSList::PersistSubsets(CExCollection* pCollection)
{
LPCSTR lpszFQSSStore;
HANDLE hFile;
SSHEADER ssHeader;
CStructuralSubset* pSS;
CStructuralSubset* pSSCurr = NULL;
PSS pSSFile = NULL;
unsigned long ulCnt;
int iSSSize;
int i = 0;
if (! (pSS = m_pHeadSubSets) )
return S_OK;
//
// Count'em
//
do
{
if ( pSS->IsTOC() )
pSSCurr = pSS;
if ( !pSS->IsEntire() && !pSS->IsEmpty() && !pSS->IsReadOnly() )
i++;
} while ( (pSS = GetNextSubset(pSS)) );
//
// Prepare a file.
//
if (! (lpszFQSSStore = pCollection->GetUserCHSLocalStoragePathnameByLanguage()) )
return E_FAIL;
hFile = CreateFile(lpszFQSSStore, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH, 0);
if ( hFile == INVALID_HANDLE_VALUE )
return E_FAIL;
//
// Fill in the header, write out the header.
//
// Need to store the persisted subset in the header since it may be a predefine.
//
ssHeader.dwSig = SS_FILE_SIGNATURE;
ssHeader.dwVer = (VER_PRODUCTVERSION_DW & 0x0000);
ssHeader.iSSCount = i;
ssHeader.dwFlags = 0;
if ( pSSCurr )
lstrcpy(ssHeader.lpszCurrentSSName, pSSCurr->GetName());
if (! WriteFile(hFile, &ssHeader, sizeof(SSHEADER), &ulCnt, NULL) )
{
MsgBox(IDS_PERSIST_SUBSET_ERR, MB_OK | MB_ICONHAND);
return E_FAIL;
}
//
// Write out the subsets.
//
pSS = m_pHeadSubSets;
do
{
if ( pSS->IsEntire() || pSS->IsEmpty() || pSS->IsReadOnly() )
continue;
int iHashCnt = pSS->GetHashCount();
iSSSize = (sizeof(SS) + ((iHashCnt - 1) * sizeof(DWORD)));
if ( (pSSFile = (PSS)lcReAlloc(pSSFile, iSSSize)) )
{
pSSFile->iHashCount = iHashCnt;
lstrcpy(pSSFile->lpszSSName, pSS->GetName());
lstrcpy(pSSFile->lpszSSID, pSS->GetID());
pSSFile->dwFlags = pSS->m_dwFlags;
while ( --iHashCnt >= 0)
pSSFile->dwHashes[iHashCnt] = pSS->EnumHashes(iHashCnt);
if (! WriteFile(hFile, pSSFile, iSSSize, &ulCnt, NULL) )
{
MsgBox(IDS_PERSIST_SUBSET_ERR, MB_OK | MB_ICONHAND);
lcFree(pSSFile);
CloseHandle(hFile);
return E_FAIL;
}
}
} while ( (pSS = GetNextSubset(pSS)) );
lcFree(pSSFile);
CloseHandle(hFile);
return S_OK;
}
HRESULT CSSList::RestoreSubsets(CExCollection* pCollection, PSTR pszRestoreSS)
{
LPCSTR lpszFQSSStore;
HANDLE hFile;
SSHEADER ssHeader;
PSS pSSFile;
CStructuralSubset* pSS;
unsigned long ulHashCnt, ulRead;
HRESULT hr = E_FAIL;
if (! (pSSFile = (PSS)lcMalloc(sizeof(SS) + sizeof(DWORD) * 50)) )
return hr;
lpszFQSSStore = pCollection->GetUserCHSLocalStoragePathnameByLanguage();
hFile = CreateFile(lpszFQSSStore, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if ( hFile == INVALID_HANDLE_VALUE)
{
lpszFQSSStore = pCollection->GetUserCHSLocalStoragePathname();
hFile = CreateFile(lpszFQSSStore, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if ( hFile == INVALID_HANDLE_VALUE)
{
lpszFQSSStore = pCollection->GetLocalStoragePathname(".chs");
hFile = CreateFile(lpszFQSSStore, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if ( hFile == INVALID_HANDLE_VALUE )
{
lcFree(pSSFile);
return hr;
}
}
}
//
// Read the header.
//
if (! ReadFile(hFile, &ssHeader, sizeof(SSHEADER), &ulRead, NULL) )
goto crap_out;
if ( ssHeader.dwSig != SS_FILE_SIGNATURE )
goto crap_out;
//
// Get the subsets.
//
while ( ssHeader.iSSCount-- )
{
if (! ReadFile(hFile, &ulHashCnt, sizeof(int), &ulRead, NULL) )
goto crap_out;
if ( ulHashCnt > 51 )
{
if (! (pSSFile = (PSS)lcReAlloc(pSSFile, sizeof(SS) + (sizeof(DWORD) * ulHashCnt))) )
goto crap_out;
}
pSSFile->iHashCount = ulHashCnt;
unsigned long ulAmt = ((sizeof(SS) - sizeof(int)) + (sizeof(DWORD) * (ulHashCnt - 1)));
if (! ReadFile(hFile, (((BYTE*)pSSFile) + sizeof(int)), ulAmt, &ulRead, NULL) )
goto crap_out;
//
// Now create a CStructuralSubset from the data.
//
pSS = new CStructuralSubset(pSSFile->lpszSSName);
pSS->m_dwFlags = pSSFile->dwFlags;
pSS->m_dwFlags &= ~(SS_FTS | SS_TOC | SS_F1); // Insure selection bits are reset.
lstrcpy(pSS->m_szSSID, pSSFile->lpszSSID);
while ( ulHashCnt )
pSS->AddHash(pSSFile->dwHashes[--ulHashCnt]);
//
// Add the subset to the list appropiatly.
//
AddSubset(pSS);
if (! lstrcmpi(ssHeader.lpszCurrentSSName, pSS->GetName() ) )
{
SetFTS(pSS);
SetTOC(pSS);
SetF1(pSS);
}
}
if ( pszRestoreSS )
lstrcpy(pszRestoreSS, ssHeader.lpszCurrentSSName);
hr = S_OK;
crap_out:
lcFree(pSSFile);
CloseHandle(hFile);
return hr;
}
HRESULT CSSList::ReadPreDefinedSubsets(CExCollection* pCollection, PSTR pszRestoreSS)
{
SSHEADER ssHeader;
PSS pSSFile;
CStructuralSubset* pSS;
CSubFileSystem* pSubFS;
unsigned long ulHashCnt, ulRead;
HRESULT hr = E_FAIL;
if (! (pSSFile = (PSS)lcMalloc(sizeof(SS) + sizeof(DWORD) * 50)) )
return hr;
if (! pCollection || !pCollection->GetMasterTitle() )
return hr;
pSubFS = new CSubFileSystem(pCollection->GetMasterTitle()->GetTitleIdxFileSystem());
if ( !SUCCEEDED(pSubFS->OpenSub("predef.chs")) )
goto crap_out;
//
// Read the header.
//
if ( !SUCCEEDED(pSubFS->ReadSub(&ssHeader, sizeof(SSHEADER), &ulRead)) )
goto crap_out;
if ( ssHeader.dwSig != SS_FILE_SIGNATURE )
goto crap_out;
//
// Get the subsets.
//
while ( ssHeader.iSSCount-- )
{
if ( !SUCCEEDED(pSubFS->ReadSub(&ulHashCnt, sizeof(int), &ulRead)) )
goto crap_out;
if ( ulHashCnt > 51 )
{
if (! (pSSFile = (PSS)lcReAlloc(pSSFile, sizeof(SS) + (sizeof(DWORD) * ulHashCnt))) )
goto crap_out;
}
pSSFile->iHashCount = ulHashCnt;
unsigned long ulAmt = ((sizeof(SS) - sizeof(int)) + (sizeof(DWORD) * (ulHashCnt - 1)));
if ( !SUCCEEDED(pSubFS->ReadSub((((BYTE*)pSSFile) + sizeof(int)), ulAmt, &ulRead)) )
goto crap_out;
//
// Now create a CStructuralSubset from the data.
//
pSS = new CStructuralSubset(pSSFile->lpszSSName);
pSS->m_dwFlags = pSSFile->dwFlags;
pSS->m_dwFlags &= ~(SS_FTS | SS_TOC | SS_F1); // Insure selection bits are reset.
pSS->m_dwFlags |= SS_READ_ONLY;
lstrcpy(pSS->m_szSSID, pSSFile->lpszSSID);
while ( ulHashCnt )
pSS->AddHash(pSSFile->dwHashes[--ulHashCnt]);
//
// Add the subset to the list appropiatly.
//
AddSubset(pSS);
if (! lstrcmpi(pszRestoreSS, pSS->GetName() ) )
{
SetFTS(pSS);
SetTOC(pSS);
SetF1(pSS);
}
}
hr = S_OK;
crap_out:
lcFree(pSSFile);
delete pSubFS;
return hr;
}
HRESULT CSSList::AddSubset(CStructuralSubset* pSS, HWND hWndUI /* == NULL */)
{
CStructuralSubset *pSSl;
HWND hWndCB;
if (! m_pHeadSubSets )
m_pHeadSubSets = pSS;
else
{
pSSl = m_pHeadSubSets;
while ( pSSl->m_pNext )
pSSl = pSSl->m_pNext;
pSSl->m_pNext = pSS;
pSS->m_pNext = NULL;
}
m_iSubSetCount++;
if ( hWndUI && (hWndCB = GetDlgItem(hWndUI, IDC_SS_PICKER)) )
{
if ( SendMessage(hWndCB, CB_FINDSTRING, -1, (LPARAM)pSS->GetName()) == -1 )
SendMessage(hWndCB, CB_ADDSTRING, 0, (LPARAM)pSS->GetName());
}
return S_OK;
}
void CSSList::Set(CStructuralSubset* pSSNew, CStructuralSubset** pSSOld, DWORD dwFlags)
{
if (! pSSNew )
return;
pSSNew->m_dwFlags |= dwFlags;
if ( *pSSOld && (pSSNew != *pSSOld) )
(*pSSOld)->m_dwFlags &= ~dwFlags;
*pSSOld = pSSNew;
}
//********************************************************************************
//
// CStructuralSubset Implementation - This is object representation of a subset.
//
//********************************************************************************
CStructuralSubset::CStructuralSubset(PCSTR pszSubSetName)
{
TCHAR* psz;
int i = 0;
m_szSSID[0] = '\0';
if ( pszSubSetName )
{
if ( (psz = StrChr(pszSubSetName, '|')) ) // If the subset name contains an identifier, process it.
{
psz = AnsiNext(psz);
lstrcpyn(m_szSubSetName, psz, MAX_SS_NAME_LEN);
while ( pszSubSetName[i] != '|' && (i < MAX_SS_NAME_LEN) )
{
m_szSSID[i] = pszSubSetName[i];
i++;
}
m_szSSID[i] = '\0'; // terminate.
}
else
lstrcpyn(m_szSubSetName, pszSubSetName, MAX_SS_NAME_LEN);
}
else
{
m_szSubSetName[0] = '\0';
m_szSSID[0] = '\0';
}
m_pdwHashes = NULL;
m_iAllocatedCount = m_iHashCount = 0;
m_dwFlags = 0;
m_pNext = NULL;
}
CStructuralSubset::~CStructuralSubset()
{
if ( m_pdwHashes )
lcFree(m_pdwHashes);
}
HASH CStructuralSubset::EnumHashes(int pos)
{
if ( !m_iHashCount || (pos >= m_iHashCount) || (pos < 0) )
return 0;
return m_pdwHashes[pos];
}
void CStructuralSubset::AddHash(DWORD dwHash)
{
if ( (m_iHashCount && (!(m_iHashCount % 12))) || (m_iAllocatedCount == 0) )
{
m_iAllocatedCount += 12;
m_pdwHashes = (HASH*)lcReAlloc(m_pdwHashes, sizeof(HASH) * m_iAllocatedCount);
}
m_pdwHashes[m_iHashCount] = dwHash;
m_iHashCount++;
}
BOOL CStructuralSubset::IsTitleInSubset(CExTitle* pTitle)
{
int i;
for (i = 0; i < m_iHashCount; i++)
{
if ( m_pdwHashes[i] == pTitle->m_dwHash )
return TRUE;
}
return FALSE;
}
//
// Function selects the subset as the current TOC filter by setting the f_IsVisable bit accordingly.
// NOTE: we don't bother selecting the bits for entire contents, this is special cased for performance reasons.
//
void CStructuralSubset::SelectAsTOCSubset(CExCollection* pCollection)
{
CFolder* pFgt; // pointer to filtered group tree.
UINT i = 0;
HASH Hash;
if ( IsEntire() || IsEmpty() )
return;
pFgt = pCollection->m_Collection.GetVisableRootFolder();
//
// De-select all node's filter bits and select the proper
// tree nodes based on the hash list!
//
while ( pFgt )
{
MarkNode(pFgt, 0); // Remove nodes by marking as not visable. // RemoveNodeFromFilter(pFgt);
pFgt = pFgt->pNext;
}
while ( Hash = EnumHashes(i++) )
{
if ( (pFgt = pCollection->m_pCSlt->HashToCFolder(Hash)) )
MarkNode(pFgt, 1); // Add nodes by marking as "visable". // AddNode2Filter(pFgt);
}
}
void CStructuralSubset::MarkNode(CFolder* pFgti, BOOL bVisable)
{
CFolder* pFgt;
CFolder* pFgtLast;
// First, mark the node and any children of the node.
//
pFgt = pFgti;
if ( pFgt->pKid )
{
while ( pFgt )
{
do
{
pFgt->f_IsVisable = bVisable;
pFgtLast = pFgt;
pFgt = pFgt->pKid;
} while ( pFgt );
pFgt = pFgtLast;
while ( pFgt && (! (pFgt->pNext)) )
{
if ( pFgt->pParent != pFgti )
pFgt = pFgt->pParent;
else
break;
}
if ( pFgt )
pFgt = pFgt->pNext;
}
}
// Next, assure any parents of the node are properly marked.
//
pFgt = pFgti;
pFgt->f_IsVisable = bVisable;
while ( (pFgt = pFgt->pParent) )
pFgt->f_IsVisable = bVisable;
}
//****************************************************************************
//
// CDefineSS Implementation - This is the guy that does all the UI.
//
//*****************************************************************************
CDefineSS::CDefineSS(CExCollection* pCollection)
{
m_bShouldSave = FALSE;
m_pSS = NULL;
m_pCollection = pCollection;
m_hIL = 0;
m_hWndParent = 0;
}
CDefineSS::~CDefineSS()
{
}
/****************************************************************************
* IDefineFilter()
*
* Internal entry point for filter manipulation dialog.
*
* ENTRY:
* none.
*
* EXIT:
* none.
*
****************************************************************************/
CStructuralSubset* CDefineSS::DefineSubset(HWND hWnd, CStructuralSubset* pSS)
{
m_pSS = pSS;
if (! m_hIL )
{
m_hIL = ImageList_LoadImage(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDBMP_CNT_IMAGE_LIST), CWIDTH_IMAGE_LIST,
0, 0x00FF00FF, IMAGE_BITMAP, 0);
if (! m_hIL )
return NULL;
}
//
// Create the model dialog.
//
m_pThis = this;
m_hWndParent = hWnd;
if(g_bWinNT5)
return (CStructuralSubset*)DialogBoxW(_Module.GetResourceInstance(), MAKEINTRESOURCEW(DLG_FILTERS), hWnd, FilterDlgProc);
else
return (CStructuralSubset*)DialogBox(_Module.GetResourceInstance(), MAKEINTRESOURCE(DLG_FILTERS), hWnd, FilterDlgProc);
}
/*****************************************************************************
* MyFilterLBFunc()
*
* ListBox subclasser. Used for our filter construction LB's. Needed so
* we can do proper mouse move processing for diddiling the cursor and
* implementing the silly collpase feature.
*
* ENTRY:
* The usual window procedure parameters.
*
* EXIT:
* a long LRESULT.
*
*****************************************************************************/
LRESULT CDefineSS::MyFilterLBFunc(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
int iTop, iHeight, iItem;
POINT pt;
CFolder* pFgt;
switch (uiMsg)
{
case WM_SETCURSOR:
m_pThis->m_giXpos = -1;
iTop = (int)SendMessage(hWnd, LB_GETTOPINDEX, 0, 0L);
iHeight = (int)SendMessage(hWnd, LB_GETITEMHEIGHT, 0, 0L);
GetCursorPos(&pt);
ScreenToClient(hWnd, &pt);
//
// Compute index of the item the cursor is currently hovering over
// and then get the item data for that item so we can determine it's
// level and diddle the cursor appropiatly.
//
iItem = ((pt.y / iHeight) + iTop);
if ( (pFgt = (CFolder*)SendMessage(hWnd, LB_GETITEMDATA, iItem, (LPARAM)0)) != (CFolder*)LB_ERR )
{
if ( pFgt->iLevel >= 1 )
{
if ( pt.x < (pFgt->iLevel * m_pThis->m_giIndentSpacing) )
{
SetCursor(LoadCursor(_Module.GetResourceInstance(),MAKEINTRESOURCE(IDC_COLLAPSE)));
m_pThis->m_giXpos = pt.x;
return(TRUE);
}
}
}
break;
case WM_KEYDOWN:
PostMessage(hWnd, WM_SETCURSOR, 0, 0L);
break;
// HACKHACK - we have a hidden button called IDOK that
// we use to trap VK_RETURNs so we can send these to
// the list boxes or other controls
case WM_SETFOCUS:
m_pThis->SetDefaultButton( GetParent(hWnd), IDOK, FALSE );
break;
}
return(CallWindowProc(m_pThis->m_lpfnOrigLBProc, hWnd, uiMsg, wParam, lParam));
}
/*****************************************************************************
* FilterDlgProc()
*
* Filter dialog handler
*
* ENTRY:
* Standard windows callback params.
*
* EXIT:
* BOOL - TRUE if we handled it. FALSE if we didn't.
*
****************************************************************************/
INT_PTR CDefineSS::FilterDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
int i;
CFolder* pfgt;
switch(msg)
{
case WM_INITDIALOG: {
//
// Set the this pointers for our LB message hook procedures. Also, set the procedure hooks
// for our LB's so we can do cursor changes, tree collapse and proper keyboard interface.
//
SendMessage(GetDlgItem(hDlg,IDF_AVAIL), WM_SETFONT, (WPARAM)m_pThis->m_pCollection->m_phmData->GetContentFont(), 0);
SendMessage(GetDlgItem(hDlg,IDF_RANGE), WM_SETFONT, (WPARAM)m_pThis->m_pCollection->m_phmData->GetContentFont(), 0);
SendMessage(GetDlgItem(hDlg,IDF_RANGES), WM_SETFONT, (WPARAM)m_pThis->m_pCollection->m_phmData->GetContentFont(), 0);
// SendMessage(GetDlgItem(hDlg,IDF_RANGES), WM_SETFONT, (WPARAM)_Resource.GetUIFont(), 0);
m_pThis->m_lpfnOrigLBProc = (WNDPROC)SetWindowLongPtr(GetDlgItem(hDlg,IDF_RANGE), GWLP_WNDPROC, (LONG_PTR)MyFilterLBFunc);
SetWindowLongPtr(GetDlgItem(hDlg,IDF_AVAIL), GWLP_WNDPROC, (LONG_PTR)MyFilterLBFunc);
SendDlgItemMessage(hDlg, IDF_SAVE_EC, EM_LIMITTEXT, MAX_SS_NAME_LEN - 1, 0L);
SendMessage(GetDlgItem(hDlg,IDF_SAVE_EC), WM_SETFONT, (WPARAM)m_pThis->m_pCollection->m_phmData->GetContentFont(), 0);
m_pThis->InitDialog(hDlg, NULL);
m_pThis->m_bShouldSave = FALSE;
// set the Close button as the default button
m_pThis->SetDefaultButton( hDlg, IDCANCEL, FALSE );
m_pThis->m_giXpos = -1;
break;
}
case WM_CHARTOITEM: // swallow these
return( -2 );
case WM_VKEYTOITEM:
switch (CmdID)
{
case 0xBD: // '-'
case VK_SUBTRACT:
pfgt=(CFolder*)SendMessage(CmdHwnd, LB_GETITEMDATA, CmdCode, (LPARAM)0);
m_pThis->ExpandContract(CmdHwnd, pfgt, FALSE, (HWND)CmdHwnd == GetDlgItem(hDlg,IDF_AVAIL));
return(-2);
case VK_HOME:
if (CmdID == VK_HOME && !(GetKeyState(VK_CONTROL) & 0x8000 ))
return( -1 );
// otherwise fall through
case VK_LEFT:
if ( ((CmdID == VK_HOME)||(CmdID == VK_LEFT)) && (GetKeyState(VK_CONTROL) & 0x8000 ))
{
// Close everyone
pfgt= (CFolder*)SendMessage(CmdHwnd, LB_GETITEMDATA, 0, (LPARAM)0);
while (pfgt->pNext)
{
m_pThis->ExpandContract(CmdHwnd, pfgt, FALSE, (HWND)CmdHwnd == GetDlgItem(hDlg,IDF_AVAIL));
pfgt = pfgt->pNext;
}
}
else
{
pfgt= (CFolder*)SendMessage(CmdHwnd, LB_GETITEMDATA, CmdCode, (LPARAM)0);
m_pThis->ExpandContract(CmdHwnd, pfgt, FALSE, (HWND)CmdHwnd == GetDlgItem(hDlg,IDF_AVAIL));
}
return(-2);
case VK_BACK: { // go to parent
CFolder* pFgtCaret;
int caret;
if ( (caret = (int)SendMessage(CmdHwnd,LB_GETCARETINDEX,0,0L)) == -1 )
return -2;
if (! (pFgtCaret=(CFolder*)SendMessage(CmdHwnd, LB_GETITEMDATA, caret, (LPARAM)0)) )
return -2;
pFgtCaret = pFgtCaret->pParent;
if( pFgtCaret )
{
SendMessage(CmdHwnd, LB_SETSEL, FALSE, MAKELPARAM(caret,0));
if ( (caret = (int)SendMessage(CmdHwnd,LB_FINDSTRINGEXACT,0,(LPARAM)pFgtCaret)) == -1 )
caret = 0;
SendMessage(CmdHwnd, LB_SETCARETINDEX, caret, 0L);
SendMessage(CmdHwnd, LB_SETSEL, TRUE, MAKELPARAM(caret,0));
}
return(-2);
}
case 0xBB: // '+'
case VK_ADD:
pfgt=(CFolder*)SendMessage(CmdHwnd, LB_GETITEMDATA, CmdCode, (LPARAM)0);
m_pThis->ExpandContract(CmdHwnd, pfgt, TRUE, (HWND)CmdHwnd == GetDlgItem(hDlg,IDF_AVAIL) );
return(-2);
case VK_RIGHT: {
INT ci;
pfgt=(CFolder*)SendMessage(CmdHwnd, LB_GETITEMDATA, CmdCode, (LPARAM)0);
m_pThis->ExpandContract(CmdHwnd, pfgt, TRUE, (HWND)CmdHwnd == GetDlgItem(hDlg,IDF_AVAIL));
// select the first child if it has one
if ( CmdID == VK_RIGHT && pfgt->pKid && (ci = (INT)SendMessage(CmdHwnd, LB_GETCARETINDEX, 0, 0L)) != LB_ERR ) {
SendMessage(CmdHwnd, LB_SETSEL, FALSE, MAKELPARAM(ci,0));
SendMessage(CmdHwnd, LB_SETCARETINDEX, ci++, MAKELPARAM(0,0));
SendMessage(CmdHwnd, LB_SETSEL, TRUE, MAKELPARAM(ci,0));
}
return(-2);
}
case VK_RETURN:
SendMessage( CmdHwnd, WM_COMMAND, ((HWND)CmdHwnd == GetDlgItem(hDlg,IDF_AVAIL))?IDF_AVAIL:IDF_RANGE,
MAKELPARAM(CmdHwnd,LBN_DBLCLK));
return(-2);
}
return(-1); // Tell dlgmgr we didn't handle this key stroke.
case WM_NCLBUTTONDOWN:
SendDlgItemMessage(hDlg,IDF_RANGES,CB_SHOWDROPDOWN,FALSE,0L);
return(FALSE);
case WM_DRAWITEM:
// draw one of our listbox items
m_pThis->DrawFBItem(hDlg, (LPDRAWITEMSTRUCT)lParam, (UINT)wParam);
break;
case WM_MEASUREITEM:
// report how big our items are
m_pThis->MeasureFBItem((LPMEASUREITEMSTRUCT)lParam);
break;
case WM_COMMAND:
if ( m_pThis->FilterDlgCommand(hDlg, wParam, lParam) )
{
i = m_pThis->FillFilterTree(GetDlgItem(hDlg,IDF_RANGE), FALSE, FALSE);
EnableWindow(GetDlgItem(hDlg,IDF_REMOVE), (i != 0));
EnableWindow(GetDlgItem(hDlg,IDF_REMOVEALL), (i != 0));
i = m_pThis->FillFilterTree(GetDlgItem(hDlg,IDF_AVAIL), TRUE, FALSE);
EnableWindow(GetDlgItem(hDlg,IDF_ADD), (i != 0));
EnableWindow(GetDlgItem(hDlg,IDF_ADDALL), (i != 0));
m_pThis->SetSaveStatus(hDlg);
}
else
return FALSE;
break;
case WM_CLOSE:
// Closing the Dialog behaves the same as Cancel
PostMessage(hDlg, WM_COMMAND, IDCANCEL, 0L);
break;
case WM_DESTROY:
break;
default:
return FALSE; // say we didn't handle it
break;
}
return TRUE; // say we did handle it
}
/*****************************************************************************
* MeasureFBItem()
*
* Set appropiate size entries in the measure item struc according to the
* items we'll be rendering in the filter listboxes.
*
* ENTRY:
* hDlg - Handle to the filter dialog.
* lpMIS - Pointer to the LPMEASUREITEMSTRUCT
*
* EXIT:
* None.
*
*****************************************************************************/
void CDefineSS::MeasureFBItem(LPMEASUREITEMSTRUCT lpMIS)
{
POINT pt;
HDC hDC;
HFONT hOldFont;
TEXTMETRIC tm;
ImageList_GetIconSize(m_hIL, (int*)&pt.x, (int*)&pt.y);
hDC = GetDC(NULL);
hOldFont = (HFONT)SelectObject(hDC, m_pCollection->m_phmData->GetContentFont());
GetTextMetrics(hDC, &tm);
SelectObject(hDC, hOldFont);
ReleaseDC(NULL, hDC);
if ( pt.y > tm.tmHeight )
lpMIS->itemHeight = pt.y;
else
lpMIS->itemHeight = tm.tmHeight;
m_giIndentSpacing = pt.x;
m_iFontHeight = tm.tmHeight;
m_iGlyphX = pt.x;
m_iGlyphY = pt.y;
}
/*****************************************************************************
* InitDialog()
*
* Do all initialization of the range definition dialog for a particular
* situation, Add, Delete or Change.
*
* ENTRY:
* hDlg - The handle to the dialog.
* szRange - Pointer to new range or NULL if initing the range combo-box.
*
* EXIT:
* BOOL - TRUE on success, FALSE on failure.
*
****************************************************************************/
BOOL CDefineSS::InitDialog(HWND hDlg, LPSTR szRange)
{
int iSel = 0;
int i = 0;
int iFilterCnt = 0;
BOOL bDef = FALSE;
CStructuralSubset* pSS = NULL;
SendDlgItemMessage(hDlg,IDF_RANGES,CB_SETEXTENDEDUI,TRUE,0L);
if (! m_pCollection->m_pSSList )
return(FALSE);
if (! szRange )
{
SendDlgItemMessage(hDlg, IDF_RANGES, CB_RESETCONTENT, 0, 0L);
while ( (pSS = m_pCollection->m_pSSList->GetNextSubset(pSS)) )
{
i = (int) SendDlgItemMessage(hDlg, IDF_RANGES, CB_INSERTSTRING, (WPARAM) -1, (LPARAM)(LPSTR)pSS->GetName());
SendDlgItemMessage(hDlg, IDF_RANGES, CB_SETITEMDATA, i, (LPARAM)((DWORD_PTR)pSS));
}
}
else
{
if ( (iSel = (int)SendDlgItemMessage(hDlg, IDF_RANGES, CB_FINDSTRINGEXACT,0, (LPARAM)szRange)) != LB_ERR )
pSS = (CStructuralSubset*)SendDlgItemMessage(hDlg, IDF_RANGES, CB_GETITEMDATA, iSel,0L);
SendDlgItemMessage(hDlg, IDF_RANGES, CB_SETCURSEL, iSel, 0L);
bDef = TRUE;
}
//
// Select the current filter. If it's "entire CD" select "New".
//
if (! bDef || ! pSS)
{
pSS = m_pCollection->m_pSSList->GetNew();
SendDlgItemMessage(hDlg, IDF_RANGES, CB_SELECTSTRING, (WPARAM)-1, (LPARAM)pSS->GetName());
}
//
// Init the listboxes!
//
SetRangeToTree(pSS);
//
// Init filter LB and remove options.
//
i = FillFilterTree(GetDlgItem(hDlg,IDF_RANGE), FALSE, FALSE);
EnableWindow(GetDlgItem(hDlg,IDF_REMOVE), (i != 0));
EnableWindow(GetDlgItem(hDlg,IDF_REMOVEALL), (i != 0));
//
// Init available LB and add options.
//
i = FillFilterTree(GetDlgItem(hDlg,IDF_AVAIL), TRUE, FALSE);
EnableWindow(GetDlgItem(hDlg,IDF_ADD), (i != 0));
EnableWindow(GetDlgItem(hDlg,IDF_ADDALL), (i != 0));
//
// deal with buttons
//
if ( pSS->IsReadOnly() )
{
EnableWindow(GetDlgItem(hDlg, IDF_DELETE), FALSE);
SetWindowText(GetDlgItem(hDlg,IDF_SAVE_EC),GetStringResource(IDS_UNTITLED_SUBSET));
}
else
{
EnableWindow(GetDlgItem(hDlg, IDF_DELETE), TRUE);
SetWindowText(GetDlgItem(hDlg,IDF_SAVE_EC), pSS->GetName());
}
EnableWindow(GetDlgItem(hDlg,IDF_SAVE), FALSE);
return(TRUE);
}
/*****************************************************************************
* DoesNodeHaveANext()
*
* aids DrawFBItem() in painting the vertical connecting codes in the filter
* list boxes.
*
* ENTRY:
* LbId - ListBox ID.
* n - What level are we painting.
* pFgt - Pointer to the node we're painting.
*
* EXIT:
* BOOL - TRUE if a next will appear on the given level. FALSE otherwise.
*
****************************************************************************/
BOOL CDefineSS::DoesNodeHaveANext(UINT LbId, int n, CFolder* pFgt)
{
while ( pFgt->iLevel > (n + 1) )
pFgt = pFgt->pParent;
while ( pFgt->pNext )
{
pFgt = pFgt->pNext;
if ( (PRESENT((LbId == IDF_AVAIL), pFgt)) )
return(TRUE);
}
return(FALSE);
}
/*****************************************************************************
* DrawFBItem()
*
* Function is responsible for painting the items in the owner-draw list boxes
* that are used in the filter contents dialog.
*
* ENTRY:
* hDlg - Handle to the dialog.
* lpDI - Pointer to the draw item struct. Contains a pFgt to the item
* we're painting.
* Lbid - ListBox identifier.
*
* EXIT:
* None.
*
****************************************************************************/
void CDefineSS::DrawFBItem(HWND hDlg, LPDRAWITEMSTRUCT lpDI, UINT LbId)
{
RECT rc;
int n;
WORD wTopText;
HDC hDC;
CFolder* pFgt;
INT xBitmap = 0;
int iHeight;
BOOL bHasNext;
char* lpszText;
char szScratch[MAX_PATH];
static int bNoReEnter = 0;
if (lpDI->itemID == 0xFFFF)
return;
pFgt = (CFolder*)lpDI->itemData;
if (!pFgt || lpDI->itemData == -1 )
return;
bNoReEnter++;
if ( bNoReEnter > 1 )
{
bNoReEnter--;
return;
}
hDC = lpDI->hDC;
rc = lpDI->rcItem;
iHeight = rc.bottom - rc.top;
wTopText = (WORD)((rc.top + ((iHeight) / 2)) - ((m_iFontHeight - 2) / 2));
/*
* Paint the proper lines based on the level and position of the item.
*/
if ( pFgt->iLevel )
{
for ( n = 0; n < pFgt->iLevel; n++ )
{
// Draw the verticle line indicating level. Remember to not leave a
// "tail".
//
bHasNext = DoesNodeHaveANext(LbId, n, pFgt);
if ( bHasNext )
QRect(hDC, rc.left + m_iGlyphX / 2, rc.top, // Full verticle line.
1, iHeight, COLOR_WINDOWTEXT);
else if ( n == (pFgt->iLevel - 1) )
QRect(hDC, rc.left + m_iGlyphX / 2, rc.top, // Half vertical line.
1, (iHeight / 2), COLOR_WINDOWTEXT);
rc.left += m_iGlyphX;
}
// Draw the horizontal connector line.
//
QRect(hDC, (rc.left - m_iGlyphX / 2), (rc.top + (m_iGlyphY / 2)), ((m_iGlyphX / 2)), 1, COLOR_WINDOWTEXT);
}
//
// draw the little book.
//
if ( EXPANDED((LbId == IDF_AVAIL), pFgt) ) // Is the book open or closed ?
xBitmap++; // It's an open book.
ImageList_Draw(m_hIL, xBitmap, hDC, rc.left+1, rc.top, ILD_NORMAL);
rc.left += m_iGlyphX + 2;
if ( lpDI->itemState & ODS_SELECTED )
{
SetBkColor(hDC, GetSysColor(COLOR_HIGHLIGHT));
SetTextColor(hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
}
else
{
SetBkColor(hDC, GetSysColor(COLOR_WINDOW));
SetTextColor(hDC, GetSysColor(COLOR_WINDOWTEXT));
}
//
// Now paint the text.
//
if ( pFgt->f_HasHash && pFgt->pExTitle )
{
pFgt->pExTitle->GetTopicLocation(0, szScratch, sizeof(szScratch));
lpszText = szScratch;
}
else
lpszText = pFgt->Title;
//
// Set LB Horizontal extent based upon the width of the string.
//
int iWidth, len = lstrlen(lpszText);
SIZE size;
if ( lpDI->itemAction == ODA_DRAWENTIRE )
{
GetTextExtentPoint32(hDC, lpszText, len, &size);
size.cx += rc.left + 4;
iWidth = (int)SendDlgItemMessage(hDlg, LbId, LB_GETHORIZONTALEXTENT, 0, 0L);
if ( size.cx > iWidth )
SendDlgItemMessage(hDlg, LbId, LB_SETHORIZONTALEXTENT, (WPARAM)size.cx, 0L);
}
//
// Paint the string.
//
ExtTextOut(hDC, (rc.left + 2), wTopText, ETO_OPAQUE | ETO_CLIPPED, &rc, lpszText, len, NULL);
if (lpDI->itemState & ODS_FOCUS)
DrawFocusRect(hDC,&rc);
bNoReEnter--;
}
/****************************************************************************
* SetRangeToTree()
*
* Function will set the filter tree up according the the subset specified
* by the given CStructuraSubset pointer.
*
* ENTRY:
* CStructuralSubset* A NULL object is the equivelent to RF_NONE.
* Use of this feature will cause all nodes to be
* removed from the filter.
*
* EXIT:
* BOOL - TRUE for success. FALSE for failure!
*
****************************************************************************/
BOOL CDefineSS::SetRangeToTree(CStructuralSubset* pSS)
{
CFolder* pFgt; // pointer to filtered group tree.
UINT i = 0;
HASH Hash;
pFgt = m_pCollection->m_Collection.GetVisableRootFolder();
if ( pSS )
{
if ( pSS->m_dwFlags & SS_ENTIRE_CONTENTS )
{
while ( pFgt )
{
AddNode2Filter(pFgt);
pFgt = pFgt->pNext;
}
}
else
{
//
// De-select all nodes filter bits and select the proper
// tree nodes based on the hash list!
//
while ( pFgt )
{
RemoveNodeFromFilter(pFgt);
pFgt = pFgt->pNext;
}
while ( Hash = pSS->EnumHashes(i++) )
{
if ( (pFgt = m_pCollection->m_pCSlt->HashToCFolder(Hash)) )
AddNode2Filter(pFgt);
}
}
return(TRUE);
}
else
{
while ( pFgt )
{
RemoveNodeFromFilter(pFgt);
pFgt = pFgt->pNext;
}
}
return(FALSE);
}
/****************************************************************************
* GetRangeFromTree()
*
* Function will extract a range from the filter LB and return a handle to
* the range.
*
* ENTRY:
* sz - Range name.
*
* EXIT:
*
****************************************************************************/
CStructuralSubset* CDefineSS::GetRangeFromTree(LPSTR sz)
{
CFolder* pFgt;
CFolder* pFgtLast;
int i = 0;
CStructuralSubset* pSS;
CExTitle* pExTitle;
if (! (pSS = new CStructuralSubset(sz)) )
return NULL; // Young girls are chaining themselves to the axels of big mac trucks.
// Walk root level nodes and gather up the prefix hashes from each node
// and all it's kids if the filter bit is set.
//
pFgt = m_pCollection->m_Collection.GetVisableRootFolder();
while ( pFgt )
{
do
{
pFgtLast = pFgt;
if ( pFgt->f_Filter && !pFgt->f_Available && pFgt->f_HasHash )
{
pSS->AddHash(pFgt->pExTitle->m_dwHash);
//
// Any merged .CHM's ?
//
pExTitle = pFgt->pExTitle->m_pKid;
while ( pExTitle )
{
pSS->AddHash(pExTitle->m_dwHash);
pExTitle = pExTitle->m_pNextKid;
}
i++;
break;
}
pFgt = pFgt->pKid;
} while ( pFgt );
pFgt = pFgtLast;
while ( pFgt && (! (pFgt->pNext)) )
pFgt = pFgt->pParent;
if ( pFgt )
pFgt = pFgt->pNext;
}
// Lastly, setup the range entry and add it to the range list.
//
if (! i )
{
delete pSS;
return(NULL);
}
return pSS;
}
/*****************************************************************************
* SetSaveStatus()
*
* If you don't want'em saving then disable the save button!
*
* ENTRY:
* hDlg - Handle to the define contents dialog.
*
* EXIT:
* None.
*
****************************************************************************/
void CDefineSS::SetSaveStatus(HWND hDlg)
{
char sz[MAX_SS_NAME_LEN];
int i;
CStructuralSubset* pSS;
HWND hWnd = GetDlgItem(hDlg, IDF_SAVE);
GetWindowText(GetDlgItem(hDlg, IDF_SAVE_EC), sz, sizeof(sz));
i = (int)SendDlgItemMessage(hDlg, IDF_RANGES, CB_GETCURSEL, 0, 0L);
pSS = (CStructuralSubset*)SendDlgItemMessage(hDlg,IDF_RANGES,CB_GETITEMDATA,i,0L);
if ( ((pSS->m_dwFlags & SS_READ_ONLY) && (! lstrcmpi(pSS->GetName(), sz))) ||
(! SendDlgItemMessage(hDlg, IDF_RANGE, LB_GETCOUNT, 0, 0L)) ||
(! lstrlen(sz)) || !m_bShouldSave )
EnableWindow(hWnd, FALSE);
else
EnableWindow(hWnd, TRUE);
}
/*****************************************************************************
* ShouldSave()
*
* Alert the user that they may want to save the changes they've made to
* the filter.
*
* ENTRY:
* hDlg - Handle to the filter definition dialog.
*
* EXIT:
* INT - IDYES, IDNO or IDCANCEL. 0 if saving is not necessary.
*
****************************************************************************/
INT CDefineSS::ShouldSave(HWND hDlg)
{
char sz[MAX_SS_NAME_LEN];
if ( IsWindowEnabled(GetDlgItem(hDlg, IDF_SAVE)) )
{
GetWindowText(GetDlgItem(hDlg, IDF_SAVE_EC), sz, sizeof(sz));
return MsgBox(IDS_SAVE_FILTER, sz, MB_YESNOCANCEL | MB_ICONQUESTION);
}
return(0);
}
/****************************************************************************
* FilterDlgCommand()
*
* Function handles all WM_COMMAND messages from the filter dialog.
*
* ENTRY:
* hDlg - Handle to the dialog.
* wParam - Message dependent.
* lParam - Message dependent.
*
* EXIT:
* Returns TRUE is range list boxes need updating. False otherwise.
*
***************************************************************************/
BOOL CDefineSS::FilterDlgCommand(HWND hDlg, WPARAM wParam, LPARAM lParam)
{
int i, n;
CFolder* pFgt;
char sz[MAX_SS_NAME_LEN];
static il;
static HWND hWndCombo = NULL;
switch (CmdID)
{
// HACKHACK - this is an invisible button that we use to route double-clicks
// to other controls
case IDOK:
{
HWND hWndCurrent, hWndFocus;
int id = 0;
// find out which control we are on
if( (hWndFocus = GetFocus()) )
{
hWndCurrent = GetDlgItem(hDlg,IDF_AVAIL);
if( hWndFocus == hWndCurrent )
id = IDF_AVAIL;
hWndCurrent = GetDlgItem(hDlg,IDF_RANGE);
if( hWndFocus == hWndCurrent )
id = IDF_RANGE;
hWndCurrent = GetDlgItem(hDlg,IDF_RANGES);
if( hWndFocus == hWndCurrent )
id = IDF_RANGES;
SendMessage( hDlg, WM_COMMAND, MAKEWPARAM(id,LBN_DBLCLK), 0L);
}
return( TRUE );
}
case IDF_SAVE:
if ( SaveFilter(hDlg) )
{
SetDefaultButton( hDlg, IDCANCEL, TRUE );
i = (int)SendDlgItemMessage(hDlg, IDF_RANGES, CB_GETCURSEL, 0, 0L);
m_pSS = (CStructuralSubset*)SendDlgItemMessage(hDlg, IDF_RANGES, CB_GETITEMDATA, i, 0L);
EnableWindow(GetDlgItem(hDlg, IDF_DELETE), TRUE);
m_bShouldSave = FALSE;
}
else
SetFocus(GetDlgItem(hDlg, IDF_RANGES));
break;
case IDCANCEL:
// if a combo box is open then close it and don't close the dialog
if( hWndCombo )
{
SendMessage( hWndCombo, CB_SHOWDROPDOWN, FALSE, 0L );
return FALSE;
}
//
// Has the range been modified ? Might it need to be saved.
//
if ( m_bShouldSave )
{
i = ShouldSave(hDlg);
if ( i == IDYES )
{
if (! SaveFilter(hDlg) )
{
SetFocus(GetDlgItem(hDlg, IDF_RANGES));
break;
}
i = (int)SendDlgItemMessage(hDlg, IDF_RANGES, CB_GETCURSEL, 0, 0L);
m_pSS = (CStructuralSubset*)SendDlgItemMessage(hDlg, IDF_RANGES, CB_GETITEMDATA, i, 0L);
m_bShouldSave = FALSE;
}
else if ( i == IDCANCEL )
break;
}
EndDialog(hDlg, (INT_PTR)m_pSS);
break;
case IDF_DELETE:
if ( (i = (int)SendDlgItemMessage(hDlg, IDF_RANGES, CB_GETCURSEL, 0, 0L)) != CB_ERR )
{
int n;
m_pSS = (CStructuralSubset*)SendDlgItemMessage(hDlg, IDF_RANGES, CB_GETITEMDATA, i, 0L);
if ( MsgBox(IDS_CONFIRM_SSDELETE, m_pSS->GetName(), MB_YESNO | MB_ICONQUESTION) == IDYES )
{
if ( (i = (int)SendDlgItemMessage(hDlg, IDF_RANGES, CB_FINDSTRINGEXACT, 0, (LPARAM)m_pSS->GetName())) != LB_ERR)
SendDlgItemMessage(hDlg, IDF_RANGES, CB_DELETESTRING, i, 0L);
m_pCollection->m_pSSList->DeleteSubset(m_pSS, NULL, m_hWndParent);
n = (int)SendDlgItemMessage(hDlg, IDF_RANGES, CB_GETCOUNT, 0, 0L);
n--;
i = min(n,i);
SendDlgItemMessage(hDlg, IDF_RANGES, CB_SETCURSEL, i, 0L);
i = (int)SendDlgItemMessage(hDlg, IDF_RANGES, CB_GETCURSEL, 0, 0L);
m_pSS = (CStructuralSubset*)SendDlgItemMessage(hDlg, IDF_RANGES, CB_GETITEMDATA, i, 0L);
InitDialog(hDlg, m_pSS->GetName());
m_bShouldSave = FALSE;
return(FALSE);
}
}
break;
case IDF_SAVE_EC:
switch (CmdCode)
{
case EN_UPDATE:
m_bShouldSave = TRUE;
SetSaveStatus(hDlg);
SetDefaultButton( hDlg, IDF_SAVE, FALSE );
break;
case EN_CHANGE:
m_bShouldSave = TRUE;
break;
}
break;
case IDF_RANGES:
switch (CmdCode)
{
case CBN_DROPDOWN:
il = (int)SendDlgItemMessage(hDlg,IDF_RANGES,CB_GETCURSEL,0,0L);
break;
case CBN_SELCHANGE:
i = (int)SendDlgItemMessage(hDlg,IDF_RANGES,CB_GETCURSEL,0,0L);
SendDlgItemMessage(hDlg,IDF_RANGES,CB_GETLBTEXT,i,(LPARAM)sz);
if ( m_bShouldSave )
{
n = ShouldSave(hDlg);
if ( n == IDCANCEL )
goto cancel_it;
else if ( n == IDYES )
{
if (! SaveFilter(hDlg) )
goto cancel_it;
}
//SetDefaultButton( hDlg, IDCANCEL, TRUE );
}
i = (int)SendDlgItemMessage(hDlg, IDF_RANGES, CB_GETCURSEL, 0, 0L);
m_pSS = (CStructuralSubset*)SendDlgItemMessage(hDlg, IDF_RANGES, CB_GETITEMDATA, i, 0L);
m_bShouldSave = FALSE;
InitDialog(hDlg, sz);
return(FALSE);
cancel_it:
SendDlgItemMessage(hDlg,IDF_RANGES,CB_SETCURSEL,(WPARAM)il,0L);
}
break;
case IDHELP:
break;
case IDF_NEW:
m_bShouldSave = TRUE;
SetSaveStatus(hDlg);
break;
case IDF_REMOVE:
n = (int)SendDlgItemMessage(hDlg, IDF_RANGE, LB_GETCOUNT, 0, 0L);
for (i = 0; i < n; i++)
{
if (SendDlgItemMessage(hDlg, IDF_RANGE, LB_GETSEL, i, 0L))
{
pFgt=(CFolder*)SendDlgItemMessage(hDlg,IDF_RANGE,LB_GETITEMDATA,i, (LPARAM)0);
RemoveNodeFromFilter(pFgt);
SendDlgItemMessage(hDlg, IDF_RANGE, LB_SETSEL, 0, (LPARAM)i);
m_bShouldSave = TRUE;
}
}
SetFocus(GetDlgItem(hDlg, IDF_RANGE));
return(TRUE);
break;
case IDF_ADDALL:
//
// Enumerate root level nodes Adding each!
//
pFgt = m_pCollection->m_Collection.GetVisableRootFolder();
while ( pFgt )
{
AddNode2Filter(pFgt);
pFgt = pFgt->pNext;
}
m_bShouldSave = TRUE;
SetFocus(GetDlgItem(hDlg, IDF_RANGE));
return(TRUE);
break;
case IDF_ADD:
n = (int)SendDlgItemMessage(hDlg, IDF_AVAIL, LB_GETCOUNT, 0, 0L);
for (i = 0; i < n; i++)
{
if (SendDlgItemMessage(hDlg, IDF_AVAIL, LB_GETSEL, i, 0L))
{
pFgt=(CFolder*)SendDlgItemMessage(hDlg,IDF_AVAIL,LB_GETITEMDATA,i, (LPARAM)0);
AddNode2Filter(pFgt);
SendDlgItemMessage(hDlg, IDF_AVAIL, LB_SETSEL, 0, (LPARAM)i);
m_bShouldSave = TRUE;
}
}
SetFocus(GetDlgItem(hDlg, IDF_AVAIL));
return(TRUE);
break;
case IDF_REMOVEALL:
//
// Enumerate root level nodes removing each!
//
pFgt = m_pCollection->m_Collection.GetVisableRootFolder();
while ( pFgt )
{
RemoveNodeFromFilter(pFgt);
pFgt = pFgt->pNext;
}
m_bShouldSave = TRUE;
SetFocus(GetDlgItem(hDlg, IDF_AVAIL));
return(TRUE);
break;
case IDF_RANGE:
switch (CmdCode)
{
case LBN_DBLCLK:
n = 0;
goto expcont;
}
break;
case IDF_AVAIL:
switch (CmdCode)
{
case LBN_DBLCLK:
n = 1;
expcont:
i = (int)SendDlgItemMessage(hDlg,CmdID,LB_GETCARETINDEX,0,0L);
if (i == (int)LB_ERR)
break;
pFgt=(CFolder*)SendDlgItemMessage(hDlg,CmdID,LB_GETITEMDATA,i, (LPARAM)0);
if ( !pFgt || pFgt == (CFolder*)-1 )
break;
//
// giXpos is set in my LB hook proc. If it's != -1 then this
// double click is intended as a collapsing dbl click and giXpos
// will indicate the x position within the LB where the double
// click occured. Sound reasonable ?
//
if ( m_giXpos > 0 )
{
int iLevel;
iLevel = m_giXpos / m_giIndentSpacing;
while ( (iLevel != pFgt->iLevel) && pFgt->pParent )
pFgt = pFgt->pParent;
}
ExpandContract(GetDlgItem(hDlg,CmdID), pFgt, -1, n);
break;
default:
break;
}
break;
}
switch( CmdCode )
{
case CBN_DROPDOWN:
hWndCombo = (HWND) lParam;
SetDefaultButton( hDlg, IDCANCEL, FALSE );
break;
case CBN_CLOSEUP:
hWndCombo = NULL;
SetDefaultButton( hDlg, IDCANCEL, FALSE );
break;
}
return(FALSE);
}
/*****************************************************************************
* SaveFilter()
*
* Function saves a filter to the filter list, insuring a read-only filter
* is not over-written.
*
* ENTRY:
* hDlg - Handle to the filter definition dialog.
*
* EXIT:
* BOOL - TRUE Indicates the filter was saved. FALSE indicates filter
* was not saved.
*
*****************************************************************************/
BOOL CDefineSS::SaveFilter(HWND hDlg)
{
char szGivenRN[MAX_SS_NAME_LEN];
int i = 0;
CStructuralSubset* pSS = NULL;
CStructuralSubset* pSSNew;
GetDlgItemText(hDlg, IDF_SAVE_EC, szGivenRN, sizeof(szGivenRN));
//
// Extract range from the filter LB.
//
if (! (pSSNew = GetRangeFromTree(szGivenRN)) )
return(FALSE);
//
// Insure we're not trashing a read only ramge.
//
while ( (pSS = m_pCollection->m_pSSList->GetNextSubset(pSS)) )
{
if (! lstrcmpi(pSS->GetName(), pSSNew->GetName()) )
{
if ( pSS->m_dwFlags & SS_READ_ONLY )
{
MsgBox(IDS_BAD_RANGE_NAME, MB_OK | MB_ICONEXCLAMATION);
return(FALSE);
}
// Sure you want to over-write the existing rnage ?
//
if ( MsgBox(IDS_OVERWRITE, MB_YESNO | MB_ICONQUESTION) == IDNO )
return(FALSE);
if ( (i = (int)SendDlgItemMessage(hDlg, IDF_RANGES, CB_FINDSTRINGEXACT, 0, (LPARAM)pSS->GetName())) != LB_ERR)
SendDlgItemMessage(hDlg, IDF_RANGES, CB_DELETESTRING, i, 0L);
m_pCollection->m_pSSList->DeleteSubset(pSS, pSSNew, m_hWndParent);
break;
}
}
// Add new subset to the list and update UI...
//
m_pCollection->m_pSSList->AddSubset(pSSNew, m_hWndParent);
SendDlgItemMessage(hDlg, IDF_RANGES, CB_INSERTSTRING, 0, (LPARAM)pSSNew->GetName());
SendDlgItemMessage(hDlg, IDF_RANGES, CB_SETITEMDATA, 0, (LPARAM)pSSNew);
SendDlgItemMessage(hDlg, IDF_RANGES, CB_SETCURSEL, 0, 0L);
EnableWindow(GetDlgItem(hDlg,IDF_SAVE), FALSE);
return(TRUE);
}
/*****************************************************************************
* RemoveNodeFromFilter()
*
* Function removes the node and all it's kids from the filter.
*
* ENTRY:
* pFgt - Poiner to the node to be removed.
*
* EXIT:
* None.
*
*****************************************************************************/
void CDefineSS::RemoveNodeFromFilter(CFolder* pFgti)
{
CFolder* pFgt;
CFolder* pFgtLast;
// First, de-select the node and any children of the node taking care
// to set the f_Available bit from each!
//
pFgt = pFgti;
if ( pFgt->pKid )
{
while ( pFgt )
{
do
{
pFgt->f_Available = 1;
pFgt->f_Filter = 0;
pFgtLast = pFgt;
pFgt = pFgt->pKid;
} while ( pFgt );
pFgt = pFgtLast;
while ( pFgt && (! (pFgt->pNext)) )
{
if ( pFgt->pParent != pFgti )
pFgt = pFgt->pParent;
else
break;
}
if ( pFgt )
pFgt = pFgt->pNext;
}
}
// Next, assure any parents of the node are marked as available. We also
// have to take care to see that a parent who has no children who are
// part of the filter are removed from the filter!
//
pFgt = pFgti;
pFgt->f_Filter = 0;
pFgt->f_Available = 1;
while ( pFgt = pFgt->pParent )
{
pFgt->f_Available = 1;
SetFilterStatus(pFgt);
}
}
/*****************************************************************************
* SetFilterStatus()
*
* If ALL children of the given node are marked as available, that nodes
* filter bit will be set to zero.
*
* ENTRY:
* pFgt - Pointer to the node to start from.
*
* EXIT:
*
****************************************************************************/
void CDefineSS::SetFilterStatus(CFolder* pFgt)
{
CFolder* pFgtl = pFgt->pKid;
CFolder* pFgtLast;
while ( pFgtl )
{
do
{
if (! pFgtl->f_Available )
return;
pFgtLast = pFgtl;
pFgtl = pFgtl->pKid;
} while ( pFgtl );
pFgtl = pFgtLast;
while ( pFgtl && (! (pFgtl->pNext)) && (pFgtl->pParent != pFgt) )
pFgtl = pFgtl->pParent;
if ( pFgtl )
pFgtl = pFgtl->pNext;
}
pFgt->f_Filter = 0;
}
/*****************************************************************************
* AddNode2Filter()
*
* Function adds a node to the filter assuring that necessary parents are
* added, and necessary nodes are removed from the available listbox.
*
* ENTRY:
* pFgti = Node to be added.
*
* EXIT:
* None.
*
*****************************************************************************/
void CDefineSS::AddNode2Filter(CFolder* pFgti)
{
CFolder* pFgt;
CFolder* pFgtLast;
// First, select the node and any children of the node taking care
// to remove the f_Available bit from each!
//
pFgt = pFgti;
while ( pFgt )
{
do
{
pFgt->f_Available = 0;
pFgt->f_Filter = 1;
pFgtLast = pFgt;
pFgt = pFgt->pKid;
} while ( pFgt );
pFgt = pFgtLast;
if ( pFgt == pFgti )
break;
while ( pFgt && (! (pFgt->pNext)) )
{
if ( pFgt->pParent != pFgti )
pFgt = pFgt->pParent;
else
break;
}
if ( pFgt )
pFgt = pFgt->pNext;
}
// Next, assure parents are selected.
//
pFgt = pFgti;
if ( pFgt->pParent )
{
while ( pFgt = pFgt->pParent )
{
pFgt->f_Filter = 1;
pFgt->f_F_Open = 1;
SetAvailableStatus(pFgt); // Should it still be available ?
}
}
}
/*****************************************************************************
* SetAvailabilityStatus()
*
* If ALL children of the given node are selected as part of a filter, that
* nodes availability bit will be set to zero.
*
* ENTRY:
* pFgt - Pointer to the node to start from.
*
* EXIT:
*
****************************************************************************/
void CDefineSS::SetAvailableStatus(CFolder* pFgt)
{
CFolder* pFgtl = pFgt->pKid;
CFolder* pFgtLast;
while ( pFgtl )
{
do
{
if (! pFgtl->f_Filter )
return;
pFgtLast = pFgtl;
pFgtl = pFgtl->pKid;
} while ( pFgtl );
pFgtl = pFgtLast;
while ( pFgtl && (! (pFgtl->pNext)) && (pFgtl->pParent != pFgt) )
pFgtl = pFgtl->pParent;
if ( pFgtl )
pFgtl = pFgtl->pNext;
}
pFgt->f_Available = 0;
}
/******************************************************************************
* ExpandContract()
*
* Function set's appropiate bits in the appropiate nodes to cause
* a parent node to expand or contract when FillRangeTree() is called.
*
* ENTRY:
* hwndLB - Handle to the listbox that contains the node were operating on.
*
* pFgt - Pointer to the node were expanding or contracting.
*
* sel - Identifies action: TRUE for Expansion
* FALSE for Contraction
* -1 for double-click which really means that
* we toggle the current state for the appropiate
* LB identified by the "which" arg.
*
* which - Which ListBox are we working with: TRUE == Available LB.
* FALSE == Range LB.
*
* EXIT:
* WORD - Returns the AX from FillRangeTree which happens to be the number
* of items placed in the LB.
*
*****************************************************************************/
WORD CDefineSS::ExpandContract(HWND hwndLB, CFolder* pFgt, int sel, BOOL which)
{
if (sel != 0 && sel != 1)
{
if (! pFgt->pKid )
return(0);
//
// This is the double click case.
//
if ( which ) {
if( pFgt->f_A_Open )
pFgt->f_A_Open = FALSE;
else
pFgt->f_A_Open = TRUE;
}
else
pFgt->f_F_Open = !pFgt->f_F_Open;
}
else
{
// This is the +/- case
//
// Contraction works a little differently than expansion.
// For contraction, if the selected node is not expanded, we close
// it's parent. If it is expanded, we close it.
//
if ( !sel ) // if we're doing contraction...
{
if ( ! (which ? pFgt->f_A_Open : pFgt->f_F_Open) ) // if node closed...
{
if ( pFgt->pParent )
pFgt = pFgt->pParent;
}
}
if (! pFgt->pKid && pFgt->pParent)
pFgt = pFgt->pParent;
if ( which )
pFgt->f_A_Open = sel;
else
pFgt->f_F_Open = sel;
}
return (WORD)FillFilterTree(hwndLB, which, sel);
}
/*****************************************************************************
* FillFilterTree()
*
* Function actually makes the send message calls to cause a repaint of
* the listbox identified by hwndLB.
*
* ENTRY:
* hwndLB - Identifies the listbox were working with (it's handle)
* fAvailable - Which ListBox are we working with: TRUE == Available LB.
* FALSE == Range LB.
* fScrollup - If TRUE and a parents children will appear off the bottom
* of the LB we'll scroll the parent to the top of the LB.
*
* EXIT:
* UINT - Returns the number of items placed in the LB.
*
*****************************************************************************/
UINT CDefineSS::FillFilterTree(HWND hwndLB, BOOL fAvailable, BOOL fScrollup)
{
UINT uiRet = 0;
int n, nVis, top, caret;
CFolder* pFgtTop, *pFgtCaret, *pFgt, *plFgt;
RECT rc;
/*
* Compute the number of visible lines, get the top and caret indicies.
*/
GetClientRect(hwndLB,&rc);
n = (int)SendMessage(hwndLB,LB_GETITEMHEIGHT,0,0L);
nVis = rc.bottom / n;
SendMessage(hwndLB,WM_SETREDRAW,FALSE,0L); // Don't re-paint!
caret = (int)SendMessage(hwndLB,LB_GETCARETINDEX,0,0L);
top = (int)SendMessage(hwndLB,LB_GETTOPINDEX,0,0L);
/*
* Get the items living at the top and the caret position of the listbox.
*/
if (top == (int)LB_ERR)
pFgtTop = NULL;
else
{
if ( (pFgtTop=(CFolder*)SendMessage(hwndLB, LB_GETITEMDATA, top, (LPARAM)0)) == (CFolder*)LB_ERR )
pFgtTop = NULL;
}
if (caret == (int)LB_ERR)
pFgtCaret = NULL;
else
{
if ( (pFgtCaret=(CFolder*)SendMessage(hwndLB, LB_GETITEMDATA, caret, (LPARAM)0)) == (CFolder*)LB_ERR )
pFgtCaret = NULL;
}
/*
* If the top entry is a child and it's not expanded, set it's parent
* as the top. ie it's been collapsed.
*/
if ( pFgtTop && pFgtTop->pParent && !EXPANDED(fAvailable, pFgtTop->pParent) )
pFgtTop = pFgtTop->pParent;
/*
* If the caret position is on a child and it's not expanded, set it's
* parent as the caret position. ie it's been collapsed.
*/
if ( pFgtCaret && pFgtCaret->pParent && !EXPANDED(fAvailable, pFgtCaret->pParent) )
pFgtCaret = pFgtCaret->pParent;
/*
* Insure we have not set the top or caret position to a non selected
* node.
*/
if ( pFgtTop && !PRESENT(fAvailable,pFgtTop) )
{
plFgt = pFgtTop;
do
{
do
{
pFgtTop = pFgtTop->pNext;
} while ( pFgtTop && !PRESENT(fAvailable,pFgtTop) );
if (! pFgtTop )
{
pFgtTop = plFgt->pParent;
plFgt = pFgtTop;
}
else
break;
} while ( pFgtTop );
}
if ( pFgtCaret && !PRESENT(fAvailable,pFgtCaret) )
{
plFgt = pFgtCaret;
do
{
do
{
pFgtCaret = pFgtCaret->pNext;
} while ( pFgtCaret && !PRESENT(fAvailable,pFgtCaret) );
if (! pFgtCaret )
{
pFgtCaret = plFgt->pParent;
plFgt = pFgtCaret;
}
else
break;
} while ( pFgtCaret );
}
SendMessage(hwndLB,LB_RESETCONTENT,FALSE,0L);
/*
* Reset horizontal extent.
*/
SendMessage(hwndLB, LB_SETHORIZONTALEXTENT, 0, 0L);
/*
* Now, add the appropiate items to the list box.
*/
if ( fAvailable )
uiRet = AvailableWalk(hwndLB);
else
uiRet = FilteredWalk(hwndLB);
/*
* Lastly, insure a parent is scrolled to the top of the LB if it's kids
* have run off of the bottom of the LB.
*/
if (pFgtTop)
top = (int)SendMessage(hwndLB,LB_FINDSTRINGEXACT,0,(LPARAM)pFgtTop);
if (pFgtCaret)
caret = (int)SendMessage(hwndLB,LB_FINDSTRINGEXACT,0,(LPARAM)pFgtCaret);
if (!pFgtTop || top == (int)LB_ERR)
top = 0;
if (!pFgtCaret || caret == (int)LB_ERR)
caret = 0;
if ( fScrollup && pFgtCaret && pFgtCaret->pKid )
{
if (caret < top)
top = caret;
for (pFgt = pFgtCaret->pKid, n = 1; pFgt; pFgt = pFgt->pNext)
++n;
if (n >= nVis)
top = caret;
else if (caret + n > top + nVis)
top = caret - nVis + n;
}
SendMessage(hwndLB, LB_SETTOPINDEX, top, 0L);
SendMessage(hwndLB, LB_SETCARETINDEX, caret, 0L);
SendMessage(hwndLB, LB_SETSEL, TRUE, MAKELPARAM(caret,0));
SendMessage(hwndLB, WM_SETREDRAW, TRUE, 0L);
InvalidateRect(hwndLB, NULL, TRUE);
return(uiRet);
}
/*****************************************************************************
* FilteredWalk()
*
* Helper function called only from FillFilterTree(). This bit of code walks
* the filter group tree and adds the selected nodes to the listbox given.
*
* ENTRY:
* hwndLB - Handle to the list box to which items are to be added.
*
* EXIT:
* uint - Returns the number of items added to the listbox.
*
****************************************************************************/
UINT CDefineSS::FilteredWalk(HWND hwndLB)
{
CFolder* pFgt;
CFolder* pFgtLast;
UINT i = 0;
pFgt = m_pCollection->m_Collection.GetVisableRootFolder();
/*
* Ok, now we actually do all the walking of the filter linked list to
* re-generate the filter listbox contnets. This must be done in the
* order in which the items appear in the LB. ie. Depthwise.
*/
while ( pFgt )
{
do
{
if ( pFgt->f_Filter && !pFgt->f_IsOrphan )
{
SendMessage(hwndLB, LB_ADDSTRING, 0, (LPARAM)pFgt);
i++;
}
pFgtLast = pFgt;
if ( pFgt->f_F_Open )
pFgt = pFgt->pKid;
else
break;
} while ( pFgt );
pFgt = pFgtLast;
while ( pFgt && (! (pFgt->pNext)) )
pFgt = pFgt->pParent;
if ( pFgt )
pFgt = pFgt->pNext;
}
return(i);
}
/*****************************************************************************
* AvailableWalk()
*
* Helper function called only from FillFilterTree(). This bit of code walks
* the filter group tree and adds the selected nodes to the listbox given.
*
* ENTRY:
* hwndLB - Handle to the list box to which items are to be added.
*
* EXIT:
* uint - Returns the number of items added to the listbox.
*
****************************************************************************/
UINT CDefineSS::AvailableWalk(HWND hwndLB)
{
CFolder* pFgt;
CFolder* pFgtLast;
UINT i = 0;
pFgt = m_pCollection->m_Collection.GetVisableRootFolder();
/*
* Ok, now we actually do all the walking of the filter linked list to
* re-generate the filter listbox contnets. This must be done in the
* order in which the items appear in the LB. ie. Depthwise.
*/
while ( pFgt )
{
do
{
if ( pFgt->f_Available && !pFgt->f_IsOrphan )
{
SendMessage(hwndLB, LB_ADDSTRING, 0, (LPARAM)pFgt);
i++;
}
pFgtLast = pFgt;
if ( pFgt->f_A_Open )
pFgt = pFgt->pKid;
else
break;
} while ( pFgt );
pFgt = pFgtLast;
while ( pFgt && (! (pFgt->pNext)) )
pFgt = pFgt->pParent;
if ( pFgt )
pFgt = pFgt->pNext;
}
return(i);
}
//
// Change a dialog's default push button
//
BOOL CDefineSS::SetDefaultButton( HWND hDlg, int iID, BOOL fFocus )
{
BOOL bReturn = FALSE;
if( hDlg ) {
// Get the current default push button and reset it.
ResetDefaultButton( hDlg );
// Update the default push button's control ID.
SendMessage( hDlg, DM_SETDEFID, (WPARAM) iID, 0L );
// Set the new style.
bReturn = (BOOL) SendDlgItemMessage( hDlg, iID, BM_SETSTYLE, (WPARAM) BS_DEFPUSHBUTTON, (LPARAM) TRUE );
// Set the focus to the new default push button.
if( fFocus )
bReturn &= (SetFocus( GetDlgItem( hDlg, iID ) ) != NULL);
}
return( bReturn );
}
//
// Clear the current default button status from the default push button
//
void CDefineSS::ResetDefaultButton( HWND hDlg )
{
DWORD dwResult;
if( hDlg ) {
// Get the current default push button.
dwResult = (DWORD) SendMessage( hDlg, DM_GETDEFID, 0, 0L );
// Reset the current default push button to a regular button.
if( HIWORD(dwResult) == DC_HASDEFID )
SendDlgItemMessage( hDlg, LOWORD(dwResult), BM_SETSTYLE, (WPARAM) BS_PUSHBUTTON, (LPARAM) TRUE );
}
return;
}
Reference in New Issue View Git Blame Copy Permalink