#include "Quickres.h" #include "tchar.h" extern HINSTANCE hInstApp; extern LPQRMONITORINFO pMonitors; extern INT iMonitors; extern WORD QuickResFlags; extern WORD FreqMenuLocation; #ifdef SAVEFLAGS // //**************************************************************************** // // CreateQuickResKey( ) // // Create 'Quickres' key in the registry if it doesnt exist // //**************************************************************************** // BOOL CreateQuickResKey( ) { HKEY hKeyOpen; // key we try to open HKEY hKeyCreate; // key to create: Quickres DWORD RegReturn; // for reg APIs DWORD Disposition; INT i; // counter BOOL bRet = FALSE; // return value // // Get the key which the QuickRes key will go under // if( (RegReturn = RegOpenKeyEx(HKEY_CURRENT_USER, REGSTR_SOFTWARE, 0, KEY_CREATE_SUB_KEY, &hKeyOpen)) == ERROR_SUCCESS ) { // // Create my quickres key // if (RegReturn=RegCreateKeyEx(hKeyOpen, QUICKRES_KEY, 0, 0, REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, NULL, &hKeyCreate, &Disposition) == ERROR_SUCCESS) { bRet = TRUE; } RegCloseKey(hKeyOpen); } return bRet; } // //**************************************************************************** // // ReadRegistryValue( LPTSTR, PDWORD, PVOID, PDWORD) // // Read a quickres value from the registry (either modes, flags or BPP) // //**************************************************************************** // BOOL ReadRegistryValue( LPTSTR ValueName, PDWORD KeyType, PVOID Value, PDWORD RegKeySize ) { HKEY hKeyOpen; // Reg Key with mode flags LONG RegReturn; // ret value for reg APIs BOOL ret=FALSE; // return value // // Try to open the quickres key // if( (RegReturn=RegOpenKeyEx(HKEY_CURRENT_USER, REGSTR_QUICKRES, 0, KEY_QUERY_VALUE, &hKeyOpen)) == ERROR_SUCCESS ) { // // Try to get the value // if ( (RegReturn=RegQueryValueEx(hKeyOpen, ValueName, NULL, KeyType, (LPBYTE)Value, RegKeySize)) == ERROR_SUCCESS ) { ret = TRUE; } RegCloseKey(hKeyOpen); } else { CreateQuickResKey(); } return ret; } // //**************************************************************************** // // SetRegistryValue( UINT, UINT, PVOID, UINT ) // // Set requested value (modes, flags, or BPP) in the registry // //**************************************************************************** // VOID SetRegistryValue(LPTSTR ValueName, UINT ValueType, PVOID Value, UINT size) { HKEY hKeyOpen; // Quickres key LONG RegReturn; // reg APIs return value // // try to open QuickRes key // if( (RegReturn=RegOpenKeyEx(HKEY_CURRENT_USER, REGSTR_QUICKRES, 0, KEY_WRITE, &hKeyOpen)) == ERROR_SUCCESS ) { // // Set the value under that key // RegSetValueEx( hKeyOpen, ValueName, 0, ValueType, (LPBYTE)Value, size ); RegCloseKey(hKeyOpen); } } #endif // SAVEFLAGS // //**************************************************************************** // // SetDevmodeFlags( INT, BOOL ) // // Upload value in ModeFlags, and current BPP to registry // //**************************************************************************** // VOID SetDevmodeFlags( INT iDisplay, BOOL ClearAll ) { #ifdef SAVEFLAGS PBYTE ModeFlags; INT i; TCHAR RegModes[16] = REGDEVMODES; // // Alloc Modes/4 bytes so each mode has 2 bits // ModeFlags = LocalAlloc ( LPTR, (pMonitors[iDisplay].iModes+3) >> 2 ); if (ModeFlags) { if (ClearAll) { // // Clear out all Mode flags if requested // need to set current mode as the only valid one // for ( i=0; i < pMonitors[iDisplay].iModes; i++) { VALIDMODE(&pMonitors[iDisplay].pModes[i]) = MODE_UNTESTED; } } // // Pack valid mode flags into ModeFlags[] // for ( i=0; i < pMonitors[iDisplay].iModes; i++) { ModeFlags[i>>2] |= (VALIDMODE(&pMonitors[iDisplay].pModes[i]) << ((i%4)<<1) ); } // // Store modeflags in the registry // if (iDisplay) { TCHAR buff[4]; _itot(iDisplay, buff, 4); lstrcat(RegModes, buff); } SetRegistryValue(RegModes, REG_BINARY, ModeFlags, (pMonitors[iDisplay].iModes+3) >> 2 ); LocalFree ( ModeFlags ); } #endif } // //**************************************************************************** // // GetDevmodeFlags( ) // // Read value from registry into global variable ModeFlags // //**************************************************************************** // VOID GetDevmodeFlags( INT iDisplay ) { INT i; #ifdef SAVEFLAGS PBYTE ModeFlags; DWORD KeyType; DWORD SavedBPP; DWORD RegKeySize = (pMonitors[iDisplay].iModes+3) >> 2 ; BOOL bClear=FALSE; TCHAR RegModes[16] = REGDEVMODES; ModeFlags = LocalAlloc ( LPTR, RegKeySize ); // // Try to read value // if (iDisplay) { TCHAR buff[4]; _itot(iDisplay, buff, 4); lstrcat(RegModes, buff); } if ( ReadRegistryValue(RegModes, &KeyType, ModeFlags, &RegKeySize) ) { // // Changing BPP on the fly IS allowed on NT 4.0 - NOT on Win95 // NT ONLY : 'Good' modes are still good even if they are different BPP // fShowFreqs is essentially the NT vs Win95 flag. // if (!fShowFreqs) { // // Make sure user hasnt changed BPP via the desktop applet // RegKeySize = sizeof( DWORD ); if (ReadRegistryValue(REGBPP, &KeyType, &SavedBPP, &RegKeySize)) { // // If BPP HAS changed, modeflags is now bogus. // clear the flags. Tell the user. // DEVMODE dm; GetCurrentDevMode(iDisplay, &dm); if ( SavedBPP != BPP(&dm) ) { bClear=TRUE; MsgBox(IDS_CHANGEDBPP, SavedBPP, MB_OK|MB_ICONEXCLAMATION); } } } } else { // // Couldnt read value from registry. // Assume no modes work; clear the flags // bClear = TRUE; } if (bClear) { SetDevmodeFlags( iDisplay, TRUE ); } else { // // Unpack ModeFlags into a field in each devmode // 2 bits per devmode - shift right, and with %11 // for (i=0; i < pMonitors[iDisplay].iModes; i++ ) { VALIDMODE(&pMonitors[iDisplay].pModes[i]) = ((ModeFlags[i>>2]) >> ((i%4)<<1)) & 0x03; } } LocalFree ( ModeFlags ); #else // // Not reading from the registry - assign all as untested // for (i=0; i < pMonitors[iDisplay].iModes; i++ ) { VALIDMODE(&pMonitors[iDisplay].pModes[i]) = MODE_UNTESTED; } #endif } // //**************************************************************************** // // SetQuickResFlags( ) // // Upload QuickResFlags value to registry // //**************************************************************************** // VOID SetQuickResFlags( ) { #ifdef SAVEFLAGS DWORD BothFlags = (FreqMenuLocation << (8*sizeof(WORD))) | QuickResFlags; SetRegistryValue(REGFLAGS, REG_DWORD, &BothFlags, sizeof(DWORD)); #endif } // //**************************************************************************** // // GetQuickResFlags( ) // // Read value from registry into global QuickResFlags // //**************************************************************************** // VOID GetQuickResFlags( ) { #ifdef SAVEFLAGS DWORD KeyType; DWORD RegKeySize=sizeof(DWORD); DWORD BothFlags; // // Try to read value // if (!ReadRegistryValue(REGFLAGS, &KeyType, &BothFlags, &RegKeySize) ) { // // assume a flag value, and create it. // QuickResFlags = QF_SHOWRESTART | QF_REMMODES; FreqMenuLocation= IDD_SUBMENUS; SetQuickResFlags(); #ifdef DONTPANIC MsgBox(IDS_DONTPANIC, KEEP_RES_TIMEOUT, MB_OK | MB_ICONEXCLAMATION ); #endif } else { if ( !( FreqMenuLocation = (WORD)(BothFlags >> (8*sizeof(WORD))) ) ) FreqMenuLocation = IDD_SUBMENUS; QuickResFlags = (WORD)(0xFFFF & BothFlags); } // // Do this always! // QuickResFlags |= QF_HIDE_4BPP; #else #ifdef DONTPANIC MsgBox(IDS_DONTPANIC, KEEP_RES_TIMEOUT, MB_OK | MB_ICONEXCLAMATION ); #endif QuickResFlags = QF_SHOWRESTART | QF_REMMODES | QF_HIDE_4BPP; #endif } // //**************************************************************************** // // SaveAllSettings( ) // // Write QuickResFlags, devmode flags, and BPP to the registry // //**************************************************************************** // VOID SaveAllSettings() { SetQuickResFlags( ); if (fRememberModes) { INT iDisplay; for (iDisplay = 0; iDisplay < iMonitors; iDisplay++) { SetDevmodeFlags( iDisplay, FALSE ); } } SetRegistryValue(REGBPP, REG_DWORD, &( BPP(&pMonitors[0].pCurrentdm->dm) ), sizeof(DWORD) ); // FEATURE only pays attention to monitor 0 (is this still necessary?) }