//--------------------------------------------------------------------------- // // Copyright (c) Microsoft Corporation 1993-1994 // // File: sett.c // // This files contains the dialog code for the Modem Settings property page. // // History: // 1-14-94 ScottH Created // //--------------------------------------------------------------------------- ///////////////////////////////////////////////////// INCLUDES #include "proj.h" // common headers #ifdef WIN95 #include "..\..\..\..\win\core\inc\help.h" #endif ///////////////////////////////////////////////////// CONTROLLING DEFINES ///////////////////////////////////////////////////// TYPEDEFS // Command IDs for the parity listbox #define CMD_PARITY_EVEN 1 #define CMD_PARITY_ODD 2 #define CMD_PARITY_NONE 3 #define CMD_PARITY_MARK 4 #define CMD_PARITY_SPACE 5 typedef UINT (WINAPI *FEFIFOFUMPROC)(HWND, LPCTSTR); typedef struct tagSETT { HWND hdlg; // dialog handle HWND hwndDataBits; HWND hwndParity; HWND hwndStopBits; HWND hwndWait; HWND hwndDialTimerCH; HWND hwndDialTimerED; HWND hwndIdleTimerCH; HWND hwndIdleTimerED; HWND hwndConfigPB; LPMODEMINFO pmi; // modeminfo struct passed into dialog FEFIFOFUMPROC pfnFifoDlg; HINSTANCE hinstSerialUI; } SETT, FAR * PSETT; // This table is the generic port settings table // that is used to fill the various listboxes typedef struct _PortValues { union { BYTE bytesize; BYTE cmd; BYTE stopbits; }; int ids; } PortValues, FAR * LPPORTVALUES; #pragma data_seg(DATASEG_READONLY) // This is the structure that is used to fill the data bits listbox static PortValues s_rgbytesize[] = { { 4, IDS_BYTESIZE_4 }, { 5, IDS_BYTESIZE_5 }, { 6, IDS_BYTESIZE_6 }, { 7, IDS_BYTESIZE_7 }, { 8, IDS_BYTESIZE_8 }, }; // This is the structure that is used to fill the parity listbox static PortValues s_rgparity[] = { { CMD_PARITY_EVEN, IDS_PARITY_EVEN }, { CMD_PARITY_ODD, IDS_PARITY_ODD }, { CMD_PARITY_NONE, IDS_PARITY_NONE }, { CMD_PARITY_MARK, IDS_PARITY_MARK }, { CMD_PARITY_SPACE, IDS_PARITY_SPACE }, }; // This is the structure that is used to fill the stopbits listbox static PortValues s_rgstopbits[] = { { ONESTOPBIT, IDS_STOPBITS_1 }, { ONE5STOPBITS, IDS_STOPBITS_1_5 }, { TWOSTOPBITS, IDS_STOPBITS_2 }, }; // This string must always be ANSI CHAR const FAR c_szFeFiFoFum[] = "FeFiFoFum"; #pragma data_seg() #define Sett_GetPtr(hwnd) (PSETT)GetWindowLong(hwnd, DWL_USER) #define Sett_SetPtr(hwnd, lp) (PSETT)SetWindowLong(hwnd, DWL_USER, (LONG)(lp)) // These are default settings #define DEFAULT_BYTESIZE 8 #define DEFAULT_PARITY CMD_PARITY_NONE #define DEFAULT_STOPBITS ONESTOPBIT #define DEF_TIMEOUT 60 // 60 seconds #define DEF_INACTIVITY_TIMEOUT 30 // 30 minutes #define SECONDS_PER_MINUTE 60 // 60 seconds in a minute //----------------------------------------------------------------------------------- // Number edit box proc //----------------------------------------------------------------------------------- /*---------------------------------------------------------- Purpose: Handle WM_CHAR Returns: TRUE to let the characters by FALSE to prohibit Cond: -- */ BOOL PRIVATE NumProc_OnChar( HWND hwnd, UINT ch, int cRepeat) { BOOL bRet; // Is this a number or a backspace? if (IsCharAlphaNumeric((TCHAR)ch) && !IsCharAlpha((TCHAR)ch) || VK_BACK == LOBYTE(VkKeyScan((TCHAR)ch))) { // Yes bRet = TRUE; } else { // No MessageBeep(MB_OK); bRet = FALSE; } return bRet; } /*---------------------------------------------------------- Purpose: Number proc. Only allow numbers to be entered into this edit box. Returns: varies Cond: -- */ LRESULT CALLBACK NumberProc( HWND hwnd, // std params UINT message, WPARAM wParam, LPARAM lParam) { WNDPROC pfn = (WNDPROC)GetWindowLong(hwnd, GWL_USERDATA); // BUGBUG: doesn't handle paste correctly! switch (message) { case WM_CHAR: if (!NumProc_OnChar(hwnd, (UINT)wParam, LOWORD(lParam))) return 1; // Don't process this character break; } return CallWindowProc(pfn, hwnd, message, wParam, lParam); } /*---------------------------------------------------------- Purpose: Sets an edit control to contain a string representing the given numeric value. Returns: -- Cond: -- */ void PRIVATE Edit_SetValue( HWND hwnd, int nValue) { TCHAR sz[MAXSHORTLEN]; wsprintf(sz, TEXT("%d"), nValue); Edit_SetText(hwnd, sz); } /*---------------------------------------------------------- Purpose: Gets a numeric value from an edit control. Supports hexadecimal. Returns: int Cond: -- */ int PRIVATE Edit_GetValue( HWND hwnd) { TCHAR sz[MAXSHORTLEN]; int cch; int nVal; cch = Edit_GetTextLength(hwnd); ASSERT(ARRAYSIZE(sz) >= cch); Edit_GetText(hwnd, sz, ARRAYSIZE(sz)); AnsiToInt(sz, &nVal); return nVal; } //----------------------------------------------------------------------------------- // Settings dialog code //----------------------------------------------------------------------------------- /*---------------------------------------------------------- Purpose: Sets the flow control related fields of one structure given the other structure. The conversion direction is dictated by the uFlags parameter. Returns: -- Cond: -- */ void PUBLIC ConvertFlowCtl( WIN32DCB FAR * pdcb, MODEMSETTINGS FAR * pms, UINT uFlags) // One of CFC_ flags { LPDWORD pdw = &pms->dwPreferredModemOptions; if (IsFlagSet(uFlags, CFC_DCBTOMS)) { // Convert from DCB values to MODEMSETTINGS values // Is this hardware flow control? if (FALSE == pdcb->fOutX && FALSE == pdcb->fInX && TRUE == pdcb->fOutxCtsFlow) { // Yes ClearFlag(*pdw, MDM_FLOWCONTROL_SOFT); if (IsFlagSet(uFlags, CFC_HW_CAPABLE)) SetFlag(*pdw, MDM_FLOWCONTROL_HARD); else ClearFlag(*pdw, MDM_FLOWCONTROL_HARD); } // Is this software flow control? else if (TRUE == pdcb->fOutX && TRUE == pdcb->fInX && FALSE == pdcb->fOutxCtsFlow) { // Yes ClearFlag(*pdw, MDM_FLOWCONTROL_HARD); if (IsFlagSet(uFlags, CFC_SW_CAPABLE)) SetFlag(*pdw, MDM_FLOWCONTROL_SOFT); else ClearFlag(*pdw, MDM_FLOWCONTROL_SOFT); } // Is the flow control disabled? else if (FALSE == pdcb->fOutX && FALSE == pdcb->fInX && FALSE == pdcb->fOutxCtsFlow) { // Yes ClearFlag(*pdw, MDM_FLOWCONTROL_HARD); ClearFlag(*pdw, MDM_FLOWCONTROL_SOFT); } else { ASSERT(0); // Should never get here } } else if (IsFlagSet(uFlags, CFC_MSTODCB)) { DWORD dw = *pdw; // Convert from MODEMSETTINGS values to DCB values // Is this hardware flow control? if (IsFlagSet(dw, MDM_FLOWCONTROL_HARD) && IsFlagClear(dw, MDM_FLOWCONTROL_SOFT)) { // Yes pdcb->fOutX = FALSE; pdcb->fInX = FALSE; pdcb->fOutxCtsFlow = TRUE; pdcb->fRtsControl = RTS_CONTROL_HANDSHAKE; } // Is this software flow control? else if (IsFlagClear(dw, MDM_FLOWCONTROL_HARD) && IsFlagSet(dw, MDM_FLOWCONTROL_SOFT)) { // Yes pdcb->fOutX = TRUE; pdcb->fInX = TRUE; pdcb->fOutxCtsFlow = FALSE; pdcb->fRtsControl = RTS_CONTROL_DISABLE; } // Is the flow control disabled? else if (IsFlagClear(dw, MDM_FLOWCONTROL_HARD) && IsFlagClear(dw, MDM_FLOWCONTROL_SOFT)) { // Yes pdcb->fOutX = FALSE; pdcb->fInX = FALSE; pdcb->fOutxCtsFlow = FALSE; pdcb->fRtsControl = RTS_CONTROL_DISABLE; } else { ASSERT(0); // Should never get here } } } /*---------------------------------------------------------- Purpose: Fills the bytesize combobox with the possible byte sizes. Returns: -- Cond: -- */ void PRIVATE Sett_FillDataBits( PSETT this) { HWND hwndCB = this->hwndDataBits; WIN32DCB FAR * pdcb = &this->pmi->dcb; int i; int iSel; int n; int iMatch = -1; int iDef = -1; TCHAR sz[MAXMEDLEN]; // Fill the listbox for (i = 0; i < ARRAY_ELEMENTS(s_rgbytesize); i++) { n = ComboBox_AddString(hwndCB, SzFromIDS(g_hinst, s_rgbytesize[i].ids, sz, ARRAYSIZE(sz))); ComboBox_SetItemData(hwndCB, n, s_rgbytesize[i].bytesize); // Keep our eyes peeled for important values if (DEFAULT_BYTESIZE == s_rgbytesize[i].bytesize) { iDef = n; } if (pdcb->ByteSize == s_rgbytesize[i].bytesize) { iMatch = n; } } ASSERT(-1 != iDef); // Does the DCB value exist in our list? if (-1 == iMatch) { // No; choose the default iSel = iDef; } else { // Yes; choose the matched value ASSERT(-1 != iMatch); iSel = iMatch; } ComboBox_SetCurSel(hwndCB, iSel); } /*---------------------------------------------------------- Purpose: Fills the parity combobox with the possible settings. Returns: -- Cond: -- */ void PRIVATE Sett_FillParity( PSETT this) { HWND hwndCB = this->hwndParity; WIN32DCB FAR * pdcb = &this->pmi->dcb; int i; int iSel; int n; int iMatch = -1; int iDef = -1; TCHAR sz[MAXMEDLEN]; // Fill the listbox for (i = 0; i < ARRAY_ELEMENTS(s_rgparity); i++) { n = ComboBox_AddString(hwndCB, SzFromIDS(g_hinst, s_rgparity[i].ids, sz, ARRAYSIZE(sz))); ComboBox_SetItemData(hwndCB, n, s_rgparity[i].cmd); // Keep our eyes peeled for important values if (DEFAULT_PARITY == s_rgparity[i].cmd) { iDef = n; } switch (s_rgparity[i].cmd) { case CMD_PARITY_EVEN: if (EVENPARITY == pdcb->Parity) iMatch = n; break; case CMD_PARITY_ODD: if (ODDPARITY == pdcb->Parity) iMatch = n; break; case CMD_PARITY_NONE: if (NOPARITY == pdcb->Parity) iMatch = n; break; case CMD_PARITY_MARK: if (MARKPARITY == pdcb->Parity) iMatch = n; break; case CMD_PARITY_SPACE: if (SPACEPARITY == pdcb->Parity) iMatch = n; break; default: ASSERT(0); break; } } ASSERT(-1 != iDef); // Does the DCB value exist in our list? if (-1 == iMatch) { // No; choose the default iSel = iDef; } else { // Yes; choose the matched value ASSERT(-1 != iMatch); iSel = iMatch; } ComboBox_SetCurSel(hwndCB, iSel); } /*---------------------------------------------------------- Purpose: Fills the stopbits combobox with the possible settings. Returns: -- Cond: -- */ void PRIVATE Sett_FillStopBits( PSETT this) { HWND hwndCB = this->hwndStopBits; WIN32DCB FAR * pdcb = &this->pmi->dcb; int i; int iSel; int n; int iMatch = -1; int iDef = -1; TCHAR sz[MAXMEDLEN]; // Fill the listbox for (i = 0; i < ARRAY_ELEMENTS(s_rgstopbits); i++) { n = ComboBox_AddString(hwndCB, SzFromIDS(g_hinst, s_rgstopbits[i].ids, sz, ARRAYSIZE(sz))); ComboBox_SetItemData(hwndCB, n, s_rgstopbits[i].stopbits); // Keep our eyes peeled for important values if (DEFAULT_STOPBITS == s_rgstopbits[i].stopbits) { iDef = n; } if (pdcb->StopBits == s_rgstopbits[i].stopbits) { iMatch = n; } } ASSERT(-1 != iDef); // Does the DCB value exist in our list? if (-1 == iMatch) { // No; choose the default iSel = iDef; } else { // Yes; choose the matched value ASSERT(-1 != iMatch); iSel = iMatch; } ComboBox_SetCurSel(hwndCB, iSel); } /*---------------------------------------------------------- Purpose: Set the timeout controls Returns: -- Cond: -- */ void PRIVATE Sett_SetTimeouts( PSETT this) { int nVal; // A note on the timeouts: // // For the dial timeout, the valid range is [1-255]. If the dial // timeout checkbox is unchecked, we set the timeout value to 255. // // For the disconnect timeout, the valid range is [0-255]. If the // dial timeout checkbox is unchecked, we set the timeout value // to 0. // Is the dial timeout properties disabled? if (0 == this->pmi->devcaps.dwCallSetupFailTimer) { // Yes; disable the box and edit Button_Enable(this->hwndDialTimerCH, FALSE); Edit_Enable(this->hwndDialTimerED, FALSE); } // No; Is the dial timeout set to the maximum? else if (this->pmi->ms.dwCallSetupFailTimer == this->pmi->devcaps.dwCallSetupFailTimer) { // Yes; leave box unchecked and disable edit Button_SetCheck(this->hwndDialTimerCH, FALSE); nVal = min(DEF_TIMEOUT, LOWORD(this->pmi->devcaps.dwCallSetupFailTimer)); Edit_SetValue(this->hwndDialTimerED, nVal); Edit_Enable(this->hwndDialTimerED, FALSE); } else { // No; check the box and set the time value Button_SetCheck(this->hwndDialTimerCH, TRUE); nVal = min(LOWORD(this->pmi->ms.dwCallSetupFailTimer), LOWORD(this->pmi->devcaps.dwCallSetupFailTimer)); Edit_SetValue(this->hwndDialTimerED, nVal); } // Is the disconnect timeout properties disabled? if (0 == this->pmi->devcaps.dwInactivityTimeout) { // Yes; disable the box and edit Button_Enable(this->hwndIdleTimerCH, FALSE); Edit_Enable(this->hwndIdleTimerED, FALSE); } // No; Is the disconnect timeout set to 0? else if (0 == this->pmi->ms.dwInactivityTimeout) { // Yes; leave box unchecked and disable edit Button_SetCheck(this->hwndIdleTimerCH, FALSE); Edit_SetValue(this->hwndIdleTimerED, DEF_INACTIVITY_TIMEOUT); Edit_Enable(this->hwndIdleTimerED, FALSE); } else { // No; check the box and set the time value Button_SetCheck(this->hwndIdleTimerCH, TRUE); Edit_SetValue(this->hwndIdleTimerED, LOWORD(this->pmi->ms.dwInactivityTimeout)/SECONDS_PER_MINUTE); } } /*---------------------------------------------------------- Purpose: WM_INITDIALOG Handler Returns: FALSE when we assign the control focus Cond: -- */ BOOL PRIVATE Sett_OnInitDialog( PSETT this, HWND hwndFocus, LPARAM lParam) // expected to be PROPSHEETINFO { LPPROPSHEETPAGE lppsp = (LPPROPSHEETPAGE)lParam; HWND hwnd = this->hdlg; DWORD dwOptions; DWORD dwCapOptions; WNDPROC pfn; ASSERT((LPTSTR)lppsp->lParam); this->pmi = (LPMODEMINFO)lppsp->lParam; // Save away the window handles this->hwndDataBits = GetDlgItem(hwnd, IDC_DATABITS); this->hwndParity = GetDlgItem(hwnd, IDC_PARITY); this->hwndStopBits = GetDlgItem(hwnd, IDC_STOPBITS); this->hwndWait = GetDlgItem(hwnd, IDC_WAITFORDIALTONE); this->hwndDialTimerCH = GetDlgItem(hwnd, IDC_CH_DIALTIMER); this->hwndDialTimerED = GetDlgItem(hwnd, IDC_ED_DIALTIMER); this->hwndIdleTimerCH = GetDlgItem(hwnd, IDC_CH_IDLETIMER); this->hwndIdleTimerED = GetDlgItem(hwnd, IDC_ED_IDLETIMER); this->hwndConfigPB = GetDlgItem(hwnd, IDC_PB_CONFIGURE); // Subclass the edit boxes that only handle numbers pfn = SubclassWindow(this->hwndDialTimerED, NumberProc); SetWindowLong(this->hwndDialTimerED, GWL_USERDATA, (LONG)pfn); pfn = SubclassWindow(this->hwndIdleTimerED, NumberProc); SetWindowLong(this->hwndIdleTimerED, GWL_USERDATA, (LONG)pfn); Edit_LimitText(this->hwndDialTimerED, 3); Edit_LimitText(this->hwndIdleTimerED, 3); // Set the call preferences dwCapOptions = this->pmi->devcaps.dwModemOptions; dwOptions = this->pmi->ms.dwPreferredModemOptions; Button_Enable(this->hwndWait, IsFlagSet(dwCapOptions, MDM_BLIND_DIAL)); Button_SetCheck(this->hwndWait, IsFlagSet(dwCapOptions, MDM_BLIND_DIAL) && IsFlagClear(dwOptions, MDM_BLIND_DIAL)); Sett_SetTimeouts(this); // Is this a parallel port? if (DT_PARALLEL_PORT == this->pmi->nDeviceType) { // Yes; hide the DCB controls ShowWindow(GetDlgItem(hwnd, IDC_CONN_PREF), SW_HIDE); EnableWindow(GetDlgItem(hwnd, IDC_CONN_PREF), FALSE); ShowWindow(GetDlgItem(hwnd, IDC_LBL_DATABITS), SW_HIDE); EnableWindow(GetDlgItem(hwnd, IDC_LBL_DATABITS), FALSE); ShowWindow(GetDlgItem(hwnd, IDC_DATABITS), SW_HIDE); EnableWindow(GetDlgItem(hwnd, IDC_DATABITS), FALSE); ShowWindow(GetDlgItem(hwnd, IDC_LBL_PARITY), SW_HIDE); EnableWindow(GetDlgItem(hwnd, IDC_LBL_PARITY), FALSE); ShowWindow(GetDlgItem(hwnd, IDC_PARITY), SW_HIDE); EnableWindow(GetDlgItem(hwnd, IDC_PARITY), FALSE); ShowWindow(GetDlgItem(hwnd, IDC_LBL_STOPBITS), SW_HIDE); EnableWindow(GetDlgItem(hwnd, IDC_LBL_STOPBITS), FALSE); ShowWindow(GetDlgItem(hwnd, IDC_STOPBITS), SW_HIDE); EnableWindow(GetDlgItem(hwnd, IDC_STOPBITS), FALSE); } else { // No; initialize the DCB controls Sett_FillDataBits(this); Sett_FillParity(this); Sett_FillStopBits(this); } // Is the modem using a custom port? if (IsFlagSet(this->pmi->uFlags, MIF_PORT_IS_CUSTOM)) { // Yes this->pfnFifoDlg = NULL; this->hinstSerialUI = NULL; } // Is the modem using a parallel port? else if (DT_PARALLEL_PORT == this->pmi->nDeviceType || DT_PARALLEL_MODEM == this->pmi->nDeviceType) { // Yes; don't show the FIFO settings button HWND hwndBtn = GetDlgItem(hwnd, IDC_PB_CONFIGURE); Button_Enable(hwndBtn, FALSE); ShowWindow(hwndBtn, SW_HIDE); this->pfnFifoDlg = NULL; this->hinstSerialUI = NULL; } else { // Try to setup the FIFO settings button this->hinstSerialUI = LoadLibrary(c_szSerialUI); if (ISVALIDHINSTANCE(this->hinstSerialUI)) { this->pfnFifoDlg = (FEFIFOFUMPROC)GetProcAddress(this->hinstSerialUI, c_szFeFiFoFum); } else { this->pfnFifoDlg = NULL; this->hinstSerialUI = NULL; } // Did getting the private entry point fail? if (!this->pfnFifoDlg) { // Yes; hide the Port Settings button HWND hwndBtn = GetDlgItem(hwnd, IDC_PB_CONFIGURE); Button_Enable(hwndBtn, FALSE); ShowWindow(hwndBtn, SW_HIDE); } } return TRUE; // default initial focus } /*---------------------------------------------------------- Purpose: Saves the connection preferences to the modeminfo struct. Returns: -- Cond: -- */ void PRIVATE Sett_SaveConnPrefs( PSETT this) { int iSel; BYTE cmd; WIN32DCB FAR * pdcb = &this->pmi->dcb; // Determine new byte size iSel = ComboBox_GetCurSel(this->hwndDataBits); pdcb->ByteSize = (BYTE)ComboBox_GetItemData(this->hwndDataBits, iSel); // Determine new parity settings iSel = ComboBox_GetCurSel(this->hwndParity); cmd = (BYTE)ComboBox_GetItemData(this->hwndParity, iSel); switch (cmd) { case CMD_PARITY_EVEN: pdcb->fParity = TRUE; pdcb->Parity = EVENPARITY; break; case CMD_PARITY_ODD: pdcb->fParity = TRUE; pdcb->Parity = ODDPARITY; break; case CMD_PARITY_NONE: pdcb->fParity = FALSE; pdcb->Parity = NOPARITY; break; case CMD_PARITY_MARK: pdcb->fParity = TRUE; pdcb->Parity = MARKPARITY; break; case CMD_PARITY_SPACE: pdcb->fParity = TRUE; pdcb->Parity = SPACEPARITY; break; default: ASSERT(0); break; } // Determine new stopbits setting iSel = ComboBox_GetCurSel(this->hwndStopBits); pdcb->StopBits = (BYTE)ComboBox_GetItemData(this->hwndStopBits, iSel); } /*---------------------------------------------------------- Purpose: Invokes the settings property sheet for the port that this modem is connected to. Returns: -- Cond: -- */ void PRIVATE Sett_ConfigPort( PSETT this) { COMMCONFIG ccDummy; DWORD dwSize; DWORD dwSubType; if (DT_PARALLEL_MODEM == this->pmi->nDeviceType || DT_PARALLEL_PORT == this->pmi->nDeviceType) { dwSubType = PST_PARALLELPORT; } else { dwSubType = PST_RS232; // Make sure the modeminfo DCB has the most current control settings Sett_SaveConnPrefs(this); } // Bring up the config dialog for the port that is currently selected dwSize = 0; ccDummy.dwProviderSubType = dwSubType; GetDefaultCommConfig(this->pmi->szPortName, &ccDummy, &dwSize); ASSERT(0 < dwSize); // Make this check to protect us from bozo ConfigDialog providers if (0 < dwSize) { LPCOMMCONFIG pcc = (LPCOMMCONFIG)LocalAlloc(LPTR, (UINT)dwSize); if (pcc) { pcc->dwProviderSubType = dwSubType; if (GetDefaultCommConfig(this->pmi->szPortName, pcc, &dwSize)) { // Use the modem's DCB values BltByte(&pcc->dcb, &this->pmi->dcb, sizeof(WIN32DCB)); // Invoke config dialog for port if (CommConfigDialog(this->pmi->szPortName, this->hdlg, pcc)) { UINT uFlags = CFC_DCBTOMS; // Set the global default settings of this port SetDefaultCommConfig(this->pmi->szPortName, pcc, dwSize); // Copy possibly-altered DCB back to the modem's DCB BltByte(&this->pmi->dcb, &pcc->dcb, sizeof(WIN32DCB)); // Make sure related fields in the modemsettings struct // are in-sync with the DCB values if (IsFlagSet(this->pmi->devcaps.dwModemOptions, MDM_FLOWCONTROL_HARD)) { SetFlag(uFlags, CFC_HW_CAPABLE); } if (IsFlagSet(this->pmi->devcaps.dwModemOptions, MDM_FLOWCONTROL_SOFT)) { SetFlag(uFlags, CFC_SW_CAPABLE); } ConvertFlowCtl(&this->pmi->dcb, &this->pmi->ms, uFlags); // Reset the connection preference controls ComboBox_ResetContent(this->hwndDataBits); ComboBox_ResetContent(this->hwndParity); ComboBox_ResetContent(this->hwndStopBits); Sett_FillDataBits(this); Sett_FillParity(this); Sett_FillStopBits(this); } } LocalFree(LOCALOF(pcc)); } } } /*---------------------------------------------------------- Purpose: WM_COMMAND Handler Returns: -- Cond: -- */ void PRIVATE Sett_OnCommand( PSETT this, int id, HWND hwndCtl, UINT uNotifyCode) { HWND hwnd = this->hdlg; BOOL bCheck; switch (id) { case IDC_CH_DIALTIMER: bCheck = Button_GetCheck(hwndCtl); Edit_Enable(this->hwndDialTimerED, bCheck); break; case IDC_CH_IDLETIMER: bCheck = Button_GetCheck(hwndCtl); Edit_Enable(this->hwndIdleTimerED, bCheck); break; case IDC_PB_CONFIGURE: if (IsFlagSet(this->pmi->uFlags, MIF_PORT_IS_CUSTOM)) Sett_ConfigPort(this); else if (this->pfnFifoDlg) this->pfnFifoDlg(hwnd, this->pmi->szPortName); else ASSERT(0); break; case IDC_PB_ADVANCED: // Invoke the advanced dialog DoModal(g_hinst, MAKEINTRESOURCE(IDD_ADV_MODEM), this->hdlg, AdvSett_WrapperProc, (LPARAM)this->pmi); break; default: break; } } /*---------------------------------------------------------- Purpose: PSN_APPLY handler Returns: -- Cond: -- */ void PRIVATE Sett_OnApply( PSETT this) { BOOL bCheck; LPMODEMSETTINGS pms = &this->pmi->ms; if (DT_PARALLEL_PORT != this->pmi->nDeviceType) { Sett_SaveConnPrefs(this); } // Set the blind dialing if (Button_GetCheck(this->hwndWait)) ClearFlag(pms->dwPreferredModemOptions, MDM_BLIND_DIAL); else SetFlag(pms->dwPreferredModemOptions, MDM_BLIND_DIAL); // Set the dial timeout bCheck = Button_GetCheck(this->hwndDialTimerCH); if (bCheck) { int nVal = Edit_GetValue(this->hwndDialTimerED); pms->dwCallSetupFailTimer = MAKELONG(nVal, 0); } else { pms->dwCallSetupFailTimer = this->pmi->devcaps.dwCallSetupFailTimer; } // Set the idle timeout bCheck = Button_GetCheck(this->hwndIdleTimerCH); if (bCheck) { int nVal = Edit_GetValue(this->hwndIdleTimerED); pms->dwInactivityTimeout = MAKELONG(nVal*SECONDS_PER_MINUTE, 0); } else { pms->dwInactivityTimeout = 0; } } /*---------------------------------------------------------- Purpose: WM_NOTIFY handler Returns: varies Cond: -- */ LRESULT PRIVATE Sett_OnNotify( PSETT this, int idFrom, NMHDR FAR * lpnmhdr) { LRESULT lRet = 0; switch (lpnmhdr->code) { case PSN_SETACTIVE: break; case PSN_KILLACTIVE: // N.b. This message is not sent if user clicks Cancel! // N.b. This message is sent prior to PSN_APPLY // break; case PSN_APPLY: Sett_OnApply(this); break; default: break; } return lRet; } /*---------------------------------------------------------- Purpose: WM_DESTROY handler Returns: -- Cond: -- */ void PRIVATE Sett_OnDestroy( PSETT this) { if (this->hinstSerialUI) FreeLibrary(this->hinstSerialUI); } ///////////////////////////////////////////////////// EXPORTED FUNCTIONS static BOOL s_bSettRecurse = FALSE; LRESULT INLINE Sett_DefProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam) { ENTER_X() { s_bSettRecurse = TRUE; } LEAVE_X() return DefDlgProc(hDlg, msg, wParam, lParam); } /*---------------------------------------------------------- Purpose: Real dialog proc Returns: varies Cond: -- */ LRESULT Sett_DlgProc( PSETT this, UINT message, WPARAM wParam, LPARAM lParam) { #pragma data_seg(DATASEG_READONLY) const static DWORD rgHelpIDs[] = { IDC_CONN_PREF, IDH_UNI_CON_PREFS, IDC_LBL_DATABITS, IDH_UNI_CON_PREFS, IDC_DATABITS, IDH_UNI_CON_PREFS, IDC_LBL_PARITY, IDH_UNI_CON_PREFS, IDC_PARITY, IDH_UNI_CON_PREFS, IDC_LBL_STOPBITS, IDH_UNI_CON_PREFS, IDC_STOPBITS, IDH_UNI_CON_PREFS, IDC_CALL_PREF, IDH_UNI_CON_CALL_PREFS, IDC_WAITFORDIALTONE,IDH_UNI_CON_DIALTONE, IDC_CH_DIALTIMER, IDH_UNI_CON_CANCEL, IDC_ED_DIALTIMER, IDH_UNI_CON_CANCEL, IDC_SECONDS, IDH_UNI_CON_CANCEL, IDC_CH_IDLETIMER, IDH_UNI_CON_DISCONNECT, IDC_ED_IDLETIMER, IDH_UNI_CON_DISCONNECT, IDC_MINUTES, IDH_UNI_CON_DISCONNECT, // IDC_PB_CONFIGURE, IDH_UNI_CON_PORT, IDC_PB_ADVANCED, IDH_UNI_CON_ADVANCED, 0, 0 }; #pragma data_seg() switch (message) { HANDLE_MSG(this, WM_INITDIALOG, Sett_OnInitDialog); HANDLE_MSG(this, WM_COMMAND, Sett_OnCommand); HANDLE_MSG(this, WM_NOTIFY, Sett_OnNotify); HANDLE_MSG(this, WM_DESTROY, Sett_OnDestroy); case WM_HELP: WinHelp(((LPHELPINFO)lParam)->hItemHandle, c_szWinHelpFile, HELP_WM_HELP, (DWORD)(LPVOID)rgHelpIDs); return 0; case WM_CONTEXTMENU: WinHelp((HWND)wParam, c_szWinHelpFile, HELP_CONTEXTMENU, (DWORD)(LPVOID)rgHelpIDs); return 0; default: return Sett_DefProc(this->hdlg, message, wParam, lParam); } } /*---------------------------------------------------------- Purpose: Dialog Wrapper Returns: varies Cond: -- */ BOOL CALLBACK Sett_WrapperProc( HWND hDlg, // std params UINT message, WPARAM wParam, LPARAM lParam) { PSETT this; // Cool windowsx.h dialog technique. For full explanation, see // WINDOWSX.TXT. This supports multiple-instancing of dialogs. // ENTER_X() { if (s_bSettRecurse) { s_bSettRecurse = FALSE; LEAVE_X() return FALSE; } } LEAVE_X() this = Sett_GetPtr(hDlg); if (this == NULL) { if (message == WM_INITDIALOG) { this = (PSETT)LocalAlloc(LPTR, sizeof(SETT)); if (!this) { MsgBox(g_hinst, hDlg, MAKEINTRESOURCE(IDS_OOM_SETTINGS), MAKEINTRESOURCE(IDS_CAP_SETTINGS), NULL, MB_ERROR); EndDialog(hDlg, IDCANCEL); return (BOOL)Sett_DefProc(hDlg, message, wParam, lParam); } this->hdlg = hDlg; Sett_SetPtr(hDlg, this); } else { return (BOOL)Sett_DefProc(hDlg, message, wParam, lParam); } } if (message == WM_DESTROY) { Sett_DlgProc(this, message, wParam, lParam); LocalFree((HLOCAL)OFFSETOF(this)); Sett_SetPtr(hDlg, NULL); return 0; } return SetDlgMsgResult(hDlg, message, Sett_DlgProc(this, message, wParam, lParam)); }