//+------------------------------------------------------------------------- // // 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 OSVERSIONINFOA g_OSVersionInfo; // osVersionInfo, setup by WinMain. 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, (DLGPROC) 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(NULL != 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, ARRAY_SIZE(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 (NOERROR == 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 (NOERROR == FindProgressDialog(GUID_NULL,TRUE,SW_SHOWNORMAL,&pProgressDlg)) { if (NOERROR == 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 (NOERROR == 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, ARRAY_SIZE(wszColumnName))) { *wszColumnName = NULL; } InsertListViewColumn(m_pItemListView,CHOICELIST_NAMECOLUMN,wszColumnName,LVCFMT_LEFT,(iClientRect*2)/3); if (!LoadString(g_hInst,IDS_CHOICELASTUPDATECOLUMN, wszColumnName, ARRAY_SIZE(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 (NOERROR == 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. // // //------------------------------------------------------------------------------ BOOL 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; }