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.
1495 lines
42 KiB
1495 lines
42 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1997.
|
|
//
|
|
// File: Choice.cpp
|
|
//
|
|
// Contents: Implements the choice dialog
|
|
//
|
|
// Classes: CChoiceDlg
|
|
//
|
|
// Notes:
|
|
//
|
|
// History: 05-Nov-97 rogerg Created.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "precomp.h"
|
|
|
|
const DlgResizeList g_ChoiceResizeList[] = {
|
|
IDC_CHOICERESIZESCROLLBAR,DLGRESIZEFLAG_PINRIGHT | DLGRESIZEFLAG_PINBOTTOM,
|
|
IDC_START,DLGRESIZEFLAG_PINRIGHT | DLGRESIZEFLAG_PINBOTTOM | DLGRESIZEFLAG_NOCOPYBITS,
|
|
IDC_OPTIONS,DLGRESIZEFLAG_PINRIGHT | DLGRESIZEFLAG_PINBOTTOM | DLGRESIZEFLAG_NOCOPYBITS,
|
|
IDC_CLOSE,DLGRESIZEFLAG_PINRIGHT | DLGRESIZEFLAG_PINBOTTOM | DLGRESIZEFLAG_NOCOPYBITS,
|
|
IDC_CHOICELISTVIEW,DLGRESIZEFLAG_PINRIGHT | DLGRESIZEFLAG_PINBOTTOM | DLGRESIZEFLAG_PINTOP | DLGRESIZEFLAG_PINLEFT,
|
|
IDC_PROPERTY,DLGRESIZEFLAG_PINRIGHT | DLGRESIZEFLAG_PINBOTTOM | DLGRESIZEFLAG_NOCOPYBITS,
|
|
};
|
|
|
|
TCHAR g_szSyncMgrHelp[] = TEXT("mobsync.hlp");
|
|
ULONG g_aContextHelpIds[] =
|
|
{
|
|
IDC_STATIC1, ((DWORD) -1),
|
|
IDC_STATIC2, ((DWORD) -1),
|
|
IDC_STATIC3, ((DWORD) -1),
|
|
IDC_STATIC4, ((DWORD) -1),
|
|
IDC_STATIC5, ((DWORD) -1),
|
|
IDC_UPDATEAVI, ((DWORD) -1),
|
|
IDC_RESULTTEXT, ((DWORD) -1),
|
|
IDC_STATIC_SKIP_TEXT, ((DWORD) -1),
|
|
IDC_CHOICELISTVIEW, HIDC_CHOICELISTVIEW,
|
|
IDC_CLOSE, HIDC_CLOSE,
|
|
IDC_DETAILS, HIDC_DETAILS,
|
|
IDC_LISTBOXERROR, HIDC_LISTBOXERROR,
|
|
IDC_OPTIONS, HIDC_OPTIONS,
|
|
IDC_PROGRESSBAR, HIDC_PROGRESSBAR,
|
|
IDC_PROGRESS_OPTIONS_BUTTON_MAIN, HIDC_PROGRESS_OPTIONS_BUTTON_MAIN,
|
|
IDC_PROPERTY, HIDC_PROPERTY,
|
|
IDC_SKIP_BUTTON_MAIN, HIDC_SKIP_BUTTON_MAIN,
|
|
IDC_START, HIDC_START,
|
|
IDC_UPDATE_LIST, HIDC_UPDATE_LIST,
|
|
IDC_PROGRESS_TABS, HIDC_PROGRESS_TABS,
|
|
IDC_TOOLBAR, HIDC_PUSHPIN,
|
|
IDSTOP, HIDSTOP,
|
|
0, 0
|
|
};
|
|
|
|
extern HINSTANCE g_hInst; // current instance
|
|
extern LANGID g_LangIdSystem; // langID of system we are running on.
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CChoiceDlg::CChoiceDlg()
|
|
//
|
|
// PURPOSE: Constructor
|
|
//
|
|
// COMMENTS: Constructor for choice dialog
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
CChoiceDlg::CChoiceDlg(REFCLSID rclsid)
|
|
{
|
|
m_fDead = FALSE;
|
|
m_hwnd = NULL;
|
|
m_nCmdShow = SW_SHOWNORMAL;
|
|
m_pHndlrQueue = NULL;
|
|
m_clsid = rclsid;
|
|
m_dwThreadID = 0;
|
|
m_fInternalAddref = FALSE;
|
|
m_dwShowPropertiesCount = 0;
|
|
m_fForceClose = FALSE;
|
|
m_pItemListView = NULL;
|
|
m_ulNumDlgResizeItem = 0;
|
|
m_ptMinimizeDlgSize.x = 0;
|
|
m_ptMinimizeDlgSize.y = 0;
|
|
|
|
m_fHwndRightToLeft = FALSE;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CChoiceDlg::Initialize
|
|
//
|
|
// PURPOSE: Must be called before any other methods.
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
BOOL CChoiceDlg::Initialize(DWORD dwThreadID,int nCmdShow)
|
|
{
|
|
|
|
m_nCmdShow = nCmdShow;
|
|
|
|
Assert(NULL == m_hwnd);
|
|
|
|
if (NULL == m_hwnd)
|
|
{
|
|
m_dwThreadID = dwThreadID;
|
|
|
|
m_hwnd = CreateDialogParam(g_hInst,(LPWSTR) MAKEINTRESOURCE(IDD_CHOICE), NULL, CChoiceDlgProc,
|
|
(LPARAM) this);
|
|
}
|
|
|
|
Assert(m_hwnd);
|
|
return m_hwnd ? TRUE : FALSE;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CChoiceDlg::SetQueueData()
|
|
//
|
|
// PURPOSE: Sets the Choice dialog queue
|
|
//
|
|
// COMMENTS: Does a SendMessage to get on the same thread as the dialog
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
BOOL CChoiceDlg::SetQueueData(REFCLSID rclsid,CHndlrQueue * pHndlrQueue)
|
|
{
|
|
SetQueueDataInfo dataInfo;
|
|
BOOL fSet = FALSE;
|
|
|
|
dataInfo.rclsid = &rclsid;
|
|
dataInfo.pHndlrQueue = pHndlrQueue;
|
|
|
|
SendMessage(m_hwnd,WM_CHOICE_SETQUEUEDATA,
|
|
(WPARAM) &fSet,(LPARAM) &dataInfo);
|
|
|
|
return fSet;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CChoiceDlg::PrivSetQueueData()
|
|
//
|
|
// PURPOSE: Sets the QueueData
|
|
//
|
|
// COMMENTS: Can be called multiple times if the dialg is invoked twice.
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
BOOL CChoiceDlg::PrivSetQueueData(REFCLSID rclsid,CHndlrQueue * pHndlrQueue)
|
|
{
|
|
if (NULL == pHndlrQueue)
|
|
return FALSE;
|
|
|
|
// if already have a queue then transfer the given queue items, else just
|
|
// set the items.
|
|
|
|
// reivew, special case UpdateAll dialog to just bring it to front
|
|
// instead of adding all the items again.
|
|
|
|
// if a request comes in to add after we have removed our addref or
|
|
// haven't set it yet then stick an addref on the dialog
|
|
|
|
if (FALSE == m_fInternalAddref)
|
|
{
|
|
m_fInternalAddref = TRUE;
|
|
SetChoiceReleaseDlgCmdId(rclsid,this,RELEASEDLGCMDID_CANCEL);
|
|
AddRefChoiceDialog(rclsid,this); // first time addref to keep alive.
|
|
}
|
|
|
|
if (NULL == m_pHndlrQueue)
|
|
{
|
|
m_pHndlrQueue = pHndlrQueue;
|
|
m_pHndlrQueue->SetQueueHwnd(this);
|
|
m_clsid = rclsid;
|
|
|
|
}
|
|
else
|
|
{
|
|
Assert(m_clsid == rclsid); // better have found the same choice dialog.
|
|
Assert(m_pHndlrQueue);
|
|
|
|
|
|
// !! warninng if you return an error it is up to the caller to free the queue.
|
|
if (m_pHndlrQueue)
|
|
{
|
|
|
|
m_pHndlrQueue->TransferQueueData(pHndlrQueue); // review, what should do on error.
|
|
|
|
// ALL QUEUE DATA SHOULD BE TRANSFERED.
|
|
pHndlrQueue->FreeAllHandlers();
|
|
pHndlrQueue->Release();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
AddNewItemsToListView(); // add the items to the ListView.
|
|
|
|
// go ahead and show the choice dialog now that there are
|
|
// items to display
|
|
ShowChoiceDialog();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CChoiceDlg::SetButtonState
|
|
//
|
|
// PURPOSE:
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
BOOL CChoiceDlg::SetButtonState(int nIDDlgItem,BOOL fEnabled)
|
|
{
|
|
BOOL fResult = FALSE;
|
|
HWND hwndCtrl = GetDlgItem(m_hwnd,nIDDlgItem);
|
|
HWND hwndFocus = NULL;
|
|
|
|
if (hwndCtrl)
|
|
{
|
|
// if state is current state then don't do anything
|
|
// !! in case IsWindowEnable bool doesn't == our bool
|
|
if ( (!!IsWindowEnabled(hwndCtrl)) == (!!fEnabled) )
|
|
{
|
|
return fEnabled;
|
|
}
|
|
|
|
if (!fEnabled) // don't bother getting focus if not disabling.
|
|
{
|
|
hwndFocus = GetFocus();
|
|
}
|
|
|
|
fResult = EnableWindow(GetDlgItem(m_hwnd,nIDDlgItem),fEnabled);
|
|
|
|
// if control had the focus. and now it doesn't then tab to the
|
|
// next control
|
|
if (hwndFocus == hwndCtrl
|
|
&& !fEnabled)
|
|
{
|
|
SetFocus(GetDlgItem(m_hwnd,IDC_CLOSE)); // close is always enabled.
|
|
}
|
|
|
|
}
|
|
|
|
return fResult;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CChoiceDlg::AddQueueItemsToListView, private
|
|
//
|
|
// Synopsis: Adds the items in the Queue to the ListView.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 30-Jul-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL CChoiceDlg::AddNewItemsToListView()
|
|
{
|
|
DWORD dwExtStyle = LVS_EX_CHECKBOXES | LVS_EX_FULLROWSELECT | LVS_EX_INFOTIP;
|
|
LVHANDLERITEMBLOB lvEmptyItemBlob;
|
|
|
|
// set up the list view
|
|
if (!m_pItemListView)
|
|
{
|
|
Assert(m_pItemListView);
|
|
return FALSE;
|
|
}
|
|
|
|
// if emptyItem is in list View delete it.
|
|
lvEmptyItemBlob.cbSize = sizeof(LVHANDLERITEMBLOB);
|
|
lvEmptyItemBlob.clsidServer = GUID_NULL;
|
|
lvEmptyItemBlob.ItemID = GUID_NULL;
|
|
|
|
if (-1 != m_pItemListView->FindItemFromBlob((LPLVBLOB) &lvEmptyItemBlob))
|
|
{
|
|
int ListViewWidth = CalcListViewWidth(GetDlgItem(m_hwnd,IDC_CHOICELISTVIEW));
|
|
|
|
m_pItemListView->DeleteAllItems();
|
|
|
|
// adjust the column widths back
|
|
m_pItemListView->SetColumnWidth(0,(ListViewWidth * 2)/3);
|
|
m_pItemListView->SetColumnWidth(1,ListViewWidth/3);
|
|
}
|
|
|
|
AddItemsFromQueueToListView(m_pItemListView,m_pHndlrQueue,dwExtStyle,0,
|
|
CHOICELIST_LASTUPDATECOLUMN,/* iDateColumn */ -1 /*status column */,TRUE /* fUseHandlerAsParent */
|
|
,FALSE /* fAddOnlyCheckedItems */);
|
|
|
|
|
|
// Set StartButton State in case don't have any checks would
|
|
// m_iCheckCount set by listview notification.
|
|
SetButtonState(IDC_START,m_pItemListView->GetCheckedItemsCount());
|
|
|
|
|
|
// if no items are in the ListView then done, put in the NoItems to Sync Info.
|
|
if (0 == m_pItemListView->GetItemCount())
|
|
{
|
|
TCHAR szBuf[MAX_STRING_RES];
|
|
RECT rcClientRect;
|
|
HIMAGELIST himageSmallIcon = m_pItemListView->GetImageList(LVSIL_SMALL );
|
|
|
|
//disable the check box list view style
|
|
m_pItemListView->SetExtendedListViewStyle(LVS_EX_FULLROWSELECT | LVS_EX_INFOTIP );
|
|
|
|
// adjust the column widths
|
|
if (GetClientRect(GetDlgItem(m_hwnd,IDC_CHOICELISTVIEW),&rcClientRect))
|
|
{
|
|
m_pItemListView->SetColumnWidth(1,0);
|
|
m_pItemListView->SetColumnWidth(0,rcClientRect.right -2);
|
|
}
|
|
|
|
|
|
LoadString(g_hInst,IDS_NOITEMS, szBuf, ARRAYSIZE(szBuf));
|
|
|
|
LVITEMEX lvitem;
|
|
|
|
lvitem.mask = LVIF_TEXT | LVIF_IMAGE ;
|
|
lvitem.iItem = 0;
|
|
lvitem.iSubItem = 0;
|
|
lvitem.pszText = szBuf;
|
|
lvitem.iImage = -1;
|
|
|
|
if (himageSmallIcon)
|
|
{
|
|
lvitem.iImage = ImageList_AddIcon(himageSmallIcon,LoadIcon(NULL, IDI_INFORMATION));
|
|
}
|
|
|
|
lvitem.maskEx = LVIFEX_BLOB;
|
|
lvitem.pBlob = (LPLVBLOB) &lvEmptyItemBlob;
|
|
|
|
m_pItemListView->InsertItem(&lvitem);
|
|
|
|
m_pItemListView->SetItemState(0,
|
|
LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED );
|
|
|
|
// Reset the current default push button to a regular button.
|
|
SendDlgItemMessage(m_hwnd, IDC_START, BM_SETSTYLE, BS_PUSHBUTTON, (LPARAM)TRUE);
|
|
|
|
// Update the default push button's control ID.
|
|
SendMessage(m_hwnd, DM_SETDEFID, IDC_CLOSE, 0L);
|
|
|
|
// Set the new style.
|
|
SendDlgItemMessage(m_hwnd, IDC_CLOSE,BM_SETSTYLE, BS_DEFPUSHBUTTON, (LPARAM)TRUE);
|
|
}
|
|
|
|
m_pItemListView->SetItemState(0,
|
|
LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CChoiceDlg::ShowChoiceDialog()
|
|
//
|
|
// PURPOSE: Initialize and display the Choice Dialog
|
|
//
|
|
// COMMENTS: Implemented on main thread.
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
BOOL CChoiceDlg::ShowChoiceDialog()
|
|
{
|
|
|
|
// Review, this needs to get cleanedup
|
|
if (!m_hwnd)
|
|
{
|
|
Assert(m_hwnd);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CChoiceDlg::ShowProperties(int iItem)
|
|
//
|
|
// PURPOSE: Show the app specific properties Dialog
|
|
//
|
|
// COMMENTS: Implemented on main thread.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
HRESULT CChoiceDlg::ShowProperties(int iItem)
|
|
{
|
|
HRESULT hr = E_UNEXPECTED;
|
|
|
|
Assert(iItem >= 0);
|
|
|
|
// only call showProperties if still have our own addref.
|
|
// and not already in a ShowProperties out call.
|
|
if ( (iItem >= 0) &&
|
|
m_pItemListView &&
|
|
m_pHndlrQueue &&
|
|
m_fInternalAddref && (0 == m_dwShowPropertiesCount) )
|
|
{
|
|
LVHANDLERITEMBLOB lvHandlerItemBlob;
|
|
|
|
lvHandlerItemBlob.cbSize = sizeof(LVHANDLERITEMBLOB);
|
|
|
|
if (m_pItemListView->GetItemBlob(iItem,(LPLVBLOB) &lvHandlerItemBlob,lvHandlerItemBlob.cbSize))
|
|
{
|
|
|
|
if (S_OK == m_pHndlrQueue->ItemHasProperties(lvHandlerItemBlob.clsidServer,
|
|
lvHandlerItemBlob.ItemID))
|
|
{
|
|
|
|
// Put two refs on the Properties one
|
|
// for completion routine to reset and one for this
|
|
// call so cancel can't happen until both return from
|
|
// call and completion is called.
|
|
|
|
m_dwShowPropertiesCount += 2;
|
|
|
|
ObjMgr_AddRefHandlerPropertiesLockCount(2);
|
|
|
|
hr = m_pHndlrQueue->ShowProperties(lvHandlerItemBlob.clsidServer,lvHandlerItemBlob.ItemID,m_hwnd);
|
|
|
|
--m_dwShowPropertiesCount; // out of call
|
|
ObjMgr_ReleaseHandlerPropertiesLockCount(1);
|
|
|
|
Assert( ((LONG) m_dwShowPropertiesCount) >= 0);
|
|
|
|
if ( ((LONG) m_dwShowPropertiesCount) <0)
|
|
m_dwShowPropertiesCount = 0;
|
|
|
|
// if hr wasn't a success code then up to us to call the callback
|
|
if (FAILED(hr))
|
|
{
|
|
PostMessage(m_hwnd,WM_BASEDLG_COMPLETIONROUTINE,
|
|
ThreadMsg_ShowProperties,0);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CChoiceDlg::ReleaseDlg
|
|
//
|
|
// PURPOSE: Called by objmgr when we need to release
|
|
// post message to the dialog thread.
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
void CChoiceDlg::ReleaseDlg(WORD wCommandID)
|
|
{
|
|
PostMessage(m_hwnd,WM_CHOICE_RELEASEDLGCMD,wCommandID,0);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CChoiceDlg::PrivReleaseDlg
|
|
//
|
|
// PURPOSE: frees the dialog
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
void CChoiceDlg::PrivReleaseDlg(WORD wCommandID)
|
|
{
|
|
BOOL fCloseConnections = TRUE;
|
|
|
|
Assert(m_dwThreadID == GetCurrentThreadId());
|
|
Assert(m_fInternalAddref == FALSE);
|
|
|
|
if (m_hwnd)
|
|
{
|
|
// ShowWindow(m_hwnd,SW_HIDE);
|
|
}
|
|
|
|
// if don't have a listView then change command to a cancel
|
|
if (NULL == m_pItemListView)
|
|
{
|
|
wCommandID = RELEASEDLGCMDID_CANCEL;
|
|
}
|
|
|
|
switch(wCommandID)
|
|
{
|
|
case RELEASEDLGCMDID_CANCEL:
|
|
// done with our queue
|
|
|
|
Assert(m_pHndlrQueue);
|
|
case RELEASEDLGCMDID_DESTROY:
|
|
// this CommandID is sent if dialog was created but it couldn't be added
|
|
// to the object mgr list.
|
|
|
|
if (m_pHndlrQueue)
|
|
{
|
|
m_pHndlrQueue->FreeAllHandlers(); // done with our queue.
|
|
m_pHndlrQueue->Release();
|
|
m_pHndlrQueue = NULL;
|
|
}
|
|
|
|
break;
|
|
case RELEASEDLGCMDID_OK:
|
|
{
|
|
Assert(m_pHndlrQueue);
|
|
Assert(m_pItemListView);
|
|
|
|
if (m_pHndlrQueue && m_pItemListView)
|
|
{
|
|
CProgressDlg *pProgressDlg;
|
|
short i = 0;
|
|
int sCheckState;
|
|
LVHANDLERITEMBLOB lvHandlerItemBlob;
|
|
|
|
lvHandlerItemBlob.cbSize = sizeof(LVHANDLERITEMBLOB);
|
|
|
|
// loop through getting and setting the selected items.
|
|
|
|
// 1 checked, 0 unchecked, -1 last item
|
|
while (-1 != (sCheckState = m_pItemListView->GetCheckState(i)))
|
|
{
|
|
|
|
if (m_pItemListView->GetItemBlob(i,(LPLVBLOB) &lvHandlerItemBlob,lvHandlerItemBlob.cbSize))
|
|
{
|
|
|
|
if (GUID_NULL != lvHandlerItemBlob.ItemID)
|
|
{
|
|
m_pHndlrQueue->SetItemState(lvHandlerItemBlob.clsidServer,
|
|
lvHandlerItemBlob.ItemID,
|
|
sCheckState == LVITEMEXSTATE_CHECKED ?
|
|
SYNCMGRITEMSTATE_CHECKED : SYNCMGRITEMSTATE_UNCHECKED);
|
|
}
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
} while (-1 != sCheckState);
|
|
|
|
m_pHndlrQueue->PersistChoices();
|
|
|
|
// on a manual create the progress dialog as displayed.
|
|
if (S_OK == FindProgressDialog(GUID_NULL,TRUE,SW_SHOWNORMAL,&pProgressDlg))
|
|
{
|
|
if (S_OK == pProgressDlg->TransferQueueData(m_pHndlrQueue))
|
|
{
|
|
fCloseConnections = FALSE;
|
|
}
|
|
ReleaseProgressDialog(GUID_NULL,pProgressDlg,FALSE);
|
|
}
|
|
|
|
m_pHndlrQueue->FreeAllHandlers(); // done with our queue.
|
|
m_pHndlrQueue->Release();
|
|
m_pHndlrQueue = NULL;
|
|
}
|
|
}
|
|
break;
|
|
case RELEASEDLGCMDID_DEFAULT:
|
|
|
|
if (m_pHndlrQueue)
|
|
{
|
|
m_pHndlrQueue->FreeAllHandlers(); // done with our queue.
|
|
m_pHndlrQueue->Release();
|
|
m_pHndlrQueue = NULL;
|
|
}
|
|
|
|
break;
|
|
default:
|
|
Assert(0); // unknown command or we never set one.
|
|
break;
|
|
}
|
|
|
|
|
|
// see if there is a progress queue when we get done and we havne't
|
|
// created one ourselves. If there isn't then
|
|
// call CloseConnection to make sure any Events or open Connections
|
|
// get hungUp.
|
|
|
|
CProgressDlg *pProgressDlg = NULL;
|
|
|
|
|
|
if (fCloseConnections)
|
|
{
|
|
if (S_OK == FindProgressDialog(GUID_NULL,FALSE,SW_MINIMIZE,&pProgressDlg))
|
|
{
|
|
ReleaseProgressDialog(GUID_NULL,pProgressDlg,FALSE);
|
|
}
|
|
else
|
|
{
|
|
ConnectObj_CloseConnections();
|
|
}
|
|
}
|
|
|
|
m_fDead = TRUE;
|
|
|
|
if (m_pItemListView)
|
|
{
|
|
delete m_pItemListView;
|
|
m_pItemListView = NULL;
|
|
}
|
|
|
|
|
|
if (m_hwnd)
|
|
{
|
|
DestroyWindow(m_hwnd);
|
|
m_hwnd = NULL;
|
|
}
|
|
|
|
|
|
delete this;
|
|
|
|
return;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CChoiceDlg::UpdateWndPosition
|
|
//
|
|
// PURPOSE: updates window Z-Order and min/max state.
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
void CChoiceDlg::UpdateWndPosition(int nCmdShow,BOOL fForce)
|
|
{
|
|
// always just pull choice to the front since can't minimize;
|
|
ShowWindow(m_hwnd,nCmdShow);
|
|
SetForegroundWindow(m_hwnd);
|
|
UpdateWindow(m_hwnd);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CChoiceDlg::HandleLogError(int iItem)
|
|
//
|
|
// PURPOSE: handles virtual function for base class.
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
void CChoiceDlg::HandleLogError(HWND hwnd, HANDLERINFO *pHandlerID,MSGLogErrors *lpmsgLogErrors)
|
|
{
|
|
AssertSz(0,"Choice dialogs HandleLogError Called");
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CChoiceDlg::CallCompletionRoutine, private
|
|
//
|
|
// Synopsis: method called when a call has been completed.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 02-Jun-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CChoiceDlg::CallCompletionRoutine(DWORD dwThreadMsg,LPCALLCOMPLETIONMSGLPARAM lpCallCompletelParam)
|
|
{
|
|
|
|
// only completion routine choice
|
|
// dialog should get is for show properties
|
|
switch(dwThreadMsg)
|
|
{
|
|
case ThreadMsg_ShowProperties:
|
|
|
|
ObjMgr_ReleaseHandlerPropertiesLockCount(1);
|
|
|
|
// If have a success code we need to handle do it
|
|
// before releasing our lock.
|
|
if (lpCallCompletelParam)
|
|
{
|
|
switch(lpCallCompletelParam->hCallResult)
|
|
{
|
|
case S_SYNCMGR_ITEMDELETED:
|
|
|
|
// if item is deleted just set the itemState to unchecked and remove from the
|
|
// ui
|
|
|
|
if (m_pHndlrQueue && m_pItemListView)
|
|
{
|
|
LVHANDLERITEMBLOB lvItemBlob;
|
|
int lvItemID;
|
|
|
|
m_pHndlrQueue->SetItemState(lpCallCompletelParam->clsidHandler,
|
|
lpCallCompletelParam->itemID,SYNCMGRITEMSTATE_UNCHECKED);
|
|
|
|
lvItemBlob.cbSize = sizeof(LVHANDLERITEMBLOB);
|
|
lvItemBlob.clsidServer = lpCallCompletelParam->clsidHandler;
|
|
lvItemBlob.ItemID = lpCallCompletelParam->itemID;
|
|
|
|
if (-1 != (lvItemID = m_pItemListView->FindItemFromBlob((LPLVBLOB) &lvItemBlob)))
|
|
{
|
|
// if toplevel item, first delete the children
|
|
if (GUID_NULL == lpCallCompletelParam->itemID)
|
|
{
|
|
m_pItemListView->DeleteChildren(lvItemID);
|
|
}
|
|
|
|
m_pItemListView->DeleteItem(lvItemID);
|
|
}
|
|
|
|
Assert(-1 != lvItemID);
|
|
}
|
|
|
|
break;
|
|
case S_SYNCMGR_ENUMITEMS:
|
|
|
|
if (m_pHndlrQueue && m_pItemListView)
|
|
{
|
|
LVHANDLERITEMBLOB lvItemBlob;
|
|
int lvItemID;
|
|
|
|
// delete all items from the ListView.
|
|
lvItemBlob.cbSize = sizeof(LVHANDLERITEMBLOB);
|
|
lvItemBlob.clsidServer = lpCallCompletelParam->clsidHandler;
|
|
lvItemBlob.ItemID = GUID_NULL;
|
|
|
|
if (-1 != (lvItemID = m_pItemListView->FindItemFromBlob((LPLVBLOB) &lvItemBlob)))
|
|
{
|
|
if (m_pItemListView->DeleteChildren(lvItemID))
|
|
{
|
|
|
|
m_pHndlrQueue->ReEnumHandlerItems(lpCallCompletelParam->clsidHandler,
|
|
lpCallCompletelParam->itemID);
|
|
|
|
AddNewItemsToListView();
|
|
}
|
|
}
|
|
|
|
Assert(-1 != lvItemID);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
--m_dwShowPropertiesCount;
|
|
Assert( ((LONG) m_dwShowPropertiesCount) >= 0);
|
|
|
|
// fix up the count if gone negative.
|
|
if ( ((LONG) m_dwShowPropertiesCount) < 0)
|
|
m_dwShowPropertiesCount = 0;
|
|
|
|
break;
|
|
default:
|
|
AssertSz(0,"Uknown Completion Routine");
|
|
break;
|
|
}
|
|
|
|
|
|
// if have an lparam free it now
|
|
if (lpCallCompletelParam)
|
|
{
|
|
FREE(lpCallCompletelParam);
|
|
}
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CChoiceDlg::QueryCanSystemShutdown, private
|
|
//
|
|
// Synopsis: called by object manager to determine if can shutdown.
|
|
//
|
|
// !!!Warning - can be called on any thread. make sure this is
|
|
// readonly.
|
|
//
|
|
// !!!Warning - Do not yield in the function;
|
|
//
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: S_OK - if can shutdown
|
|
// S_FALSE - system should not shutdown, must fill in out params.
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 17-Jun-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT CChoiceDlg::QueryCanSystemShutdown(/* [out] */ HWND *phwnd, /* [out] */ UINT *puMessageId,
|
|
/* [out] */ BOOL *pfLetUserDecide)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// dialog locked open if in ShowProperties
|
|
if (m_dwShowPropertiesCount > 0)
|
|
{
|
|
*puMessageId = IDS_HANDLERPROPERTIESQUERYENDSESSION;
|
|
*phwnd = NULL; // since properties can overvlay us don't give parent
|
|
*pfLetUserDecide = FALSE; // user doesn't get a choice.
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CChoiceDlg::CalcListViewWidth, private
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 12-Aug-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
int CChoiceDlg::CalcListViewWidth(HWND hwndList)
|
|
{
|
|
NONCLIENTMETRICSA metrics;
|
|
RECT rcClientRect;
|
|
|
|
|
|
metrics.cbSize = sizeof(metrics);
|
|
|
|
// explicitly ask for ANSI version of SystemParametersInfo since we just
|
|
// care about the ScrollWidth and don't want to conver the LOGFONT info.
|
|
if (GetClientRect(hwndList,&rcClientRect)
|
|
&& SystemParametersInfoA(SPI_GETNONCLIENTMETRICS,sizeof(metrics),(PVOID) &metrics,0))
|
|
{
|
|
// subtract off scroll bar distance + 1/2 another to give a little space to
|
|
// read right justified text.
|
|
rcClientRect.right -= (metrics.iScrollWidth * 3)/2;
|
|
}
|
|
else
|
|
{
|
|
rcClientRect.right = 320; // if fail, just makeup a number
|
|
}
|
|
|
|
|
|
return rcClientRect.right;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CChoiceDlg::OnInitialize, private
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 17-Jun-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL CChoiceDlg::OnInitialize(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
|
|
{
|
|
HIMAGELIST himage;
|
|
WCHAR wszColumnName[MAX_PATH];
|
|
INT iItem = -1;
|
|
HWND hwndList = GetDlgItem(hwnd,IDC_CHOICELISTVIEW);
|
|
LPNETAPI pNetApi;
|
|
|
|
// if sens is not installed hide the settings button.
|
|
// and move the synchronize over.
|
|
if (pNetApi = gSingleNetApiObj.GetNetApiObj())
|
|
{
|
|
if (!(pNetApi->IsSensInstalled()))
|
|
{
|
|
RECT rect;
|
|
HWND hwndSettings = GetDlgItem(hwnd,IDC_OPTIONS);
|
|
|
|
if (hwndSettings)
|
|
{
|
|
BOOL fGetWindowRect;
|
|
HWND hwndStart;
|
|
RECT rectStart;
|
|
|
|
ShowWindow(hwndSettings,SW_HIDE);
|
|
EnableWindow(hwndSettings,FALSE); // disable for alt
|
|
|
|
fGetWindowRect = GetWindowRect(hwndSettings,&rect);
|
|
hwndStart = GetDlgItem(hwnd,IDC_START);
|
|
|
|
if (fGetWindowRect && hwndStart
|
|
&& GetClientRect(hwndStart,&rectStart)
|
|
&& MapWindowPoints(NULL,hwnd,(LPPOINT) &rect,2)
|
|
)
|
|
{
|
|
SetWindowPos(hwndStart, 0,
|
|
rect.right - WIDTH(rectStart),rect.top,0,0,SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE );
|
|
}
|
|
}
|
|
}
|
|
|
|
pNetApi->Release();
|
|
}
|
|
|
|
m_hwnd = hwnd; // setup the hwnd.
|
|
|
|
m_fHwndRightToLeft = IsHwndRightToLeft(m_hwnd);
|
|
|
|
// IF THE HWND IS RIGHT TO LEFT HIDE
|
|
// SIZE CONTROL UNTIL RESIZE WORKS.
|
|
|
|
if (m_fHwndRightToLeft)
|
|
{
|
|
ShowWindow(GetDlgItem(m_hwnd,IDC_CHOICERESIZESCROLLBAR),SW_HIDE);
|
|
}
|
|
|
|
if (hwndList)
|
|
{
|
|
// setup the list view
|
|
m_pItemListView = new CListView(hwndList,hwnd,IDC_CHOICELISTVIEW,WM_BASEDLG_NOTIFYLISTVIEWEX);
|
|
|
|
if (m_pItemListView)
|
|
{
|
|
int iClientRect = CalcListViewWidth(hwndList);
|
|
UINT ImageListflags;
|
|
|
|
m_pItemListView->SetExtendedListViewStyle(LVS_EX_CHECKBOXES | LVS_EX_FULLROWSELECT | LVS_EX_INFOTIP );
|
|
|
|
// create an imagelist, if fail continue, list view just won't have an
|
|
// imaglist
|
|
|
|
ImageListflags = ILC_COLOR | ILC_MASK;
|
|
if (IsHwndRightToLeft(m_hwnd))
|
|
{
|
|
ImageListflags |= ILC_MIRROR;
|
|
}
|
|
|
|
himage = ImageList_Create( GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON),ImageListflags,5,20);
|
|
if (himage)
|
|
{
|
|
m_pItemListView->SetImageList(himage,LVSIL_SMALL);
|
|
}
|
|
|
|
// Calc cx 2/3 for name 1/3 for
|
|
|
|
if (!LoadString(g_hInst,IDS_CHOICEHANDLERCOLUMN, wszColumnName, ARRAYSIZE(wszColumnName)))
|
|
{
|
|
*wszColumnName = NULL;
|
|
}
|
|
|
|
InsertListViewColumn(m_pItemListView,CHOICELIST_NAMECOLUMN,wszColumnName,LVCFMT_LEFT,(iClientRect*2)/3);
|
|
|
|
if (!LoadString(g_hInst,IDS_CHOICELASTUPDATECOLUMN, wszColumnName, ARRAYSIZE(wszColumnName)))
|
|
{
|
|
*wszColumnName = NULL;
|
|
}
|
|
|
|
InsertListViewColumn(m_pItemListView,CHOICELIST_LASTUPDATECOLUMN,wszColumnName,LVCFMT_RIGHT,(iClientRect)/3);
|
|
}
|
|
}
|
|
|
|
RECT rectParent;
|
|
|
|
m_ulNumDlgResizeItem = 0; // if fail then we don't resize anything.
|
|
|
|
if (GetClientRect(hwnd,&rectParent))
|
|
{
|
|
ULONG itemCount;
|
|
DlgResizeList *pResizeList;
|
|
|
|
// loop through resize list
|
|
Assert(NUM_DLGRESIZEINFOCHOICE == (sizeof(g_ChoiceResizeList)/sizeof(DlgResizeList)) );
|
|
|
|
pResizeList = (DlgResizeList *) &g_ChoiceResizeList;
|
|
|
|
for (itemCount = 0; itemCount < NUM_DLGRESIZEINFOCHOICE; ++itemCount)
|
|
{
|
|
if(InitResizeItem(pResizeList->iCtrlId,
|
|
pResizeList->dwDlgResizeFlags,hwnd,&rectParent,&(m_dlgResizeInfo[m_ulNumDlgResizeItem])))
|
|
{
|
|
++m_ulNumDlgResizeItem;
|
|
}
|
|
|
|
++pResizeList;
|
|
}
|
|
}
|
|
|
|
// store the current width and height as the
|
|
// the min
|
|
if (GetWindowRect(hwnd,&rectParent))
|
|
{
|
|
m_ptMinimizeDlgSize.x = rectParent.right - rectParent.left;
|
|
m_ptMinimizeDlgSize.y = rectParent.bottom - rectParent.top;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CChoiceDlg::OnClose, private
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 17-Jun-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CChoiceDlg::OnClose(UINT uMsg,WPARAM wParam,LPARAM lParam)
|
|
{
|
|
|
|
if ( (0 == m_dwShowPropertiesCount) && (m_fInternalAddref) )
|
|
{
|
|
m_fInternalAddref = FALSE; // set released member so know we have removed addref on ourself.
|
|
SetChoiceReleaseDlgCmdId(m_clsid,this,RELEASEDLGCMDID_CANCEL);
|
|
ReleaseChoiceDialog(m_clsid,this);
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CChoiceDlg::OnSetQueueData, private
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 17-Jun-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CChoiceDlg::OnSetQueueData(UINT uMsg,WPARAM wParam,LPARAM lParam)
|
|
{
|
|
SetQueueDataInfo *pdataInfo;
|
|
BOOL fSet;
|
|
BOOL *pfSet = (BOOL *) wParam;
|
|
|
|
pdataInfo = (SetQueueDataInfo *) lParam;
|
|
fSet = PrivSetQueueData(*pdataInfo->rclsid, pdataInfo->pHndlrQueue );
|
|
|
|
if (pfSet)
|
|
{
|
|
*pfSet = fSet;
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CChoiceDlg::OnContextMenu, private
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 17-Jun-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CChoiceDlg::OnContextMenu(UINT uMsg,WPARAM wParam,LPARAM lParam)
|
|
{
|
|
WinHelp ((HWND)wParam,g_szSyncMgrHelp,HELP_CONTEXTMENU,
|
|
(ULONG_PTR) g_aContextHelpIds);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CChoiceDlg::OnHelp, private
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 17-Jun-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CChoiceDlg::OnHelp(UINT uMsg,WPARAM wParam,LPARAM lParam)
|
|
{
|
|
LPHELPINFO lphi = (LPHELPINFO)lParam;
|
|
|
|
if (lphi->iContextType == HELPINFO_WINDOW)
|
|
{
|
|
WinHelp ( (HWND) lphi->hItemHandle,
|
|
g_szSyncMgrHelp,HELP_WM_HELP,
|
|
(ULONG_PTR) g_aContextHelpIds);
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CChoiceDlg::OnStartCommand, private
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 17-Jun-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CChoiceDlg::OnStartCommand(UINT uMsg,WPARAM wParam,LPARAM lParam)
|
|
{
|
|
if ((0 == m_dwShowPropertiesCount) && (m_fInternalAddref))
|
|
{
|
|
m_fInternalAddref = FALSE;
|
|
SetChoiceReleaseDlgCmdId(m_clsid,this,RELEASEDLGCMDID_OK);
|
|
ReleaseChoiceDialog(m_clsid,this);
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CChoiceDlg::OnPropertyCommand, private
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 17-Jun-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CChoiceDlg::OnPropertyCommand(UINT uMsg,WPARAM wParam,LPARAM lParam)
|
|
{
|
|
// only bring up properties if still have addref on self.
|
|
if (m_fInternalAddref && m_pItemListView)
|
|
{
|
|
int i = m_pItemListView->GetSelectionMark();
|
|
|
|
if (i >= 0)
|
|
{
|
|
ShowProperties(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CChoiceDlg::OnCommand, private
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 17-Jun-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CChoiceDlg::OnCommand(UINT uMsg,WPARAM wParam,LPARAM lParam)
|
|
{
|
|
WORD wID = LOWORD(wParam);
|
|
WORD wNotifyCode = HIWORD(wParam);
|
|
|
|
switch (wID)
|
|
{
|
|
case IDC_START:
|
|
if (BN_CLICKED == wNotifyCode)
|
|
{
|
|
OnStartCommand(uMsg,wParam,lParam);
|
|
}
|
|
break;
|
|
case IDCANCEL:
|
|
case IDC_CLOSE:
|
|
OnClose(uMsg,wParam,lParam);
|
|
break;
|
|
case IDC_PROPERTY:
|
|
OnPropertyCommand(uMsg,wParam,lParam);
|
|
break;
|
|
case IDC_OPTIONS:
|
|
ShowOptionsDialog(m_hwnd);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CChoiceDlg::OnGetMinMaxInfo, private
|
|
//
|
|
// Synopsis: Called by WM_GETMINMAXINFO
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 17-Jun-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CChoiceDlg::OnGetMinMaxInfo(UINT uMsg,WPARAM wParam,LPARAM lParam)
|
|
{
|
|
MINMAXINFO *pMinMax = (MINMAXINFO *) lParam ;
|
|
|
|
pMinMax->ptMinTrackSize.x = m_ptMinimizeDlgSize.x;
|
|
pMinMax->ptMinTrackSize.y = m_ptMinimizeDlgSize.y ;
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CChoiceDlg::OnSize, private
|
|
//
|
|
// Synopsis: Called by WM_SIZE
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 17-Jun-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
|
|
void CChoiceDlg::OnSize(UINT uMsg,WPARAM wParam,LPARAM lParam)
|
|
{
|
|
ResizeItems(m_ulNumDlgResizeItem,m_dlgResizeInfo);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CChoiceDlg::OnNotify, private
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 17-Jun-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
LRESULT CChoiceDlg::OnNotify(UINT uMsg,WPARAM wParam,LPARAM lParam)
|
|
{
|
|
int idCtrl = (int) wParam;
|
|
LPNMHDR pnmh = (LPNMHDR) lParam;
|
|
|
|
if ((IDC_CHOICELISTVIEW == idCtrl) && m_pItemListView)
|
|
{
|
|
return m_pItemListView->OnNotify(pnmh);
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CChoiceDlg::OnNotifyListViewEx, private
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 17-Jun-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
LRESULT CChoiceDlg::OnNotifyListViewEx(UINT uMsg,WPARAM wParam,LPARAM lParam)
|
|
{
|
|
int idCtrl = (int) wParam;
|
|
LPNMHDR pnmh = (LPNMHDR) lParam;
|
|
LVHANDLERITEMBLOB lvHandlerItemBlob;
|
|
|
|
if ( (IDC_CHOICELISTVIEW != idCtrl) || (NULL == m_pItemListView))
|
|
{
|
|
Assert(IDC_CHOICELISTVIEW == idCtrl);
|
|
Assert(m_pItemListView);
|
|
return 0;
|
|
}
|
|
|
|
lvHandlerItemBlob.cbSize = sizeof(LVHANDLERITEMBLOB);
|
|
|
|
switch (pnmh->code)
|
|
{
|
|
case LVNEX_ITEMCHECKCOUNT:
|
|
{
|
|
LPNMLISTVIEWEXITEMCHECKCOUNT plviCheckCount = (LPNMLISTVIEWEXITEMCHECKCOUNT) lParam;
|
|
|
|
// update start button based on how many items are selected.
|
|
SetButtonState(IDC_START,plviCheckCount->iCheckCount);
|
|
break;
|
|
}
|
|
case LVNEX_ITEMCHANGED:
|
|
{
|
|
LPNMLISTVIEWEX pnmvEx = (LPNMLISTVIEWEX) lParam;
|
|
LPNMLISTVIEW pnmv= &(pnmvEx->nmListView);
|
|
|
|
if (pnmv->uChanged == LVIF_STATE)
|
|
{
|
|
int iItem = pnmv->iItem;
|
|
BOOL fItemHasProperties = FALSE;;
|
|
|
|
if (pnmv->uNewState & LVIS_SELECTED)
|
|
{
|
|
Assert(iItem >= 0);
|
|
|
|
if ((iItem >= 0) &&
|
|
m_pItemListView->GetItemBlob(iItem,(LPLVBLOB) &lvHandlerItemBlob,lvHandlerItemBlob.cbSize))
|
|
{
|
|
|
|
if (S_OK == m_pHndlrQueue->ItemHasProperties(lvHandlerItemBlob.clsidServer,
|
|
lvHandlerItemBlob.ItemID))
|
|
{
|
|
fItemHasProperties = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
SetButtonState(IDC_PROPERTY,fItemHasProperties);
|
|
}
|
|
break;
|
|
}
|
|
case LVNEX_DBLCLK:
|
|
{
|
|
LPNMLISTVIEW lpnmlv = (LPNMLISTVIEW) lParam;
|
|
|
|
ShowProperties(lpnmlv->iItem);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CChoiceDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
//
|
|
// PURPOSE: Callback for Choice Dialog
|
|
//
|
|
// COMMENTS: Implemented on main thread.
|
|
//
|
|
//
|
|
//------------------------------------------------------------------------------
|
|
INT_PTR CALLBACK CChoiceDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
CChoiceDlg *pThis = (CChoiceDlg *) GetWindowLongPtr(hwnd, DWLP_USER);
|
|
|
|
// spcial case destroy and init.
|
|
switch (uMsg)
|
|
{
|
|
case WM_DESTROY:
|
|
PostQuitMessage(0); // done with this thread.
|
|
break;
|
|
case WM_INITDIALOG:
|
|
{
|
|
// Stash the this pointer so we can use it later
|
|
SetWindowLongPtr(hwnd, DWLP_USER, (LONG_PTR)lParam);
|
|
pThis = (CChoiceDlg *) lParam;
|
|
|
|
if (pThis)
|
|
{
|
|
return pThis->OnInitialize(hwnd,uMsg,wParam,lParam);
|
|
}
|
|
|
|
return FALSE;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
if (pThis)
|
|
{
|
|
switch (uMsg)
|
|
{
|
|
case WM_CLOSE:
|
|
pThis->OnClose(uMsg,wParam,lParam);
|
|
break;
|
|
case WM_BASEDLG_HANDLESYSSHUTDOWN:
|
|
PostMessage(hwnd,WM_CLOSE,0,0); // post a close message to get on our thread.
|
|
break;
|
|
case WM_GETMINMAXINFO:
|
|
pThis->OnGetMinMaxInfo(uMsg,wParam,lParam);
|
|
break;
|
|
case WM_SIZE:
|
|
pThis->OnSize(uMsg,wParam,lParam);
|
|
break;
|
|
case WM_COMMAND:
|
|
pThis->OnCommand(uMsg,wParam,lParam);
|
|
break;
|
|
case WM_NOTIFY:
|
|
{
|
|
LRESULT lretOnNotify;
|
|
|
|
lretOnNotify = pThis->OnNotify(uMsg,wParam,lParam);
|
|
|
|
SetWindowLongPtr(hwnd,DWLP_MSGRESULT,lretOnNotify);
|
|
return TRUE;
|
|
}
|
|
break;
|
|
case WM_HELP:
|
|
pThis->OnHelp(uMsg,wParam,lParam);
|
|
return TRUE;
|
|
break;
|
|
case WM_CONTEXTMENU:
|
|
pThis->OnContextMenu(uMsg,wParam,lParam);
|
|
break;
|
|
case WM_BASEDLG_SHOWWINDOW:
|
|
pThis->UpdateWndPosition((int)wParam /*nCmd */,FALSE /* force */);
|
|
break;
|
|
case WM_BASEDLG_COMPLETIONROUTINE:
|
|
pThis->CallCompletionRoutine((DWORD)wParam /* dwThreadMsg*/,(LPCALLCOMPLETIONMSGLPARAM) lParam);
|
|
break;
|
|
case WM_BASEDLG_NOTIFYLISTVIEWEX:
|
|
pThis->OnNotifyListViewEx(uMsg,wParam,lParam);
|
|
break;
|
|
case WM_CHOICE_SETQUEUEDATA:
|
|
pThis->OnSetQueueData(uMsg,wParam,lParam);
|
|
return TRUE;
|
|
break;
|
|
case WM_CHOICE_RELEASEDLGCMD:
|
|
pThis->PrivReleaseDlg((WORD)wParam /* wCommandID */);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|