/*++ Copyright (c) 1994-1998, Microsoft Corporation All rights reserved. Module Name: mouseptr.c Abstract: This module contains the routines for the Mouse Pointer Property Sheet page. Revision History: --*/ // // Include Files. // #include "main.h" #include "rc.h" #include "mousehlp.h" #include // // From shell\inc\shsemip.h // #define ARRAYSIZE(a) (sizeof(a)/sizeof(a[0])) #ifdef DEBUG void * __cdecl memset(void *pmem, int v, size_t s) { char *p = (char *)pmem; while (s--) { *p++ = (char)v; } return (pmem); } #endif // // Constant Declarations. // #define gcxAvgChar 8 #define MAX_SCHEME_NAME_LEN 32 #define MAX_SCHEME_SUFFIX 32 // length of " (system scheme)" - update if more space is needed #define OVERWRITE_TITLE 32 // length of title for the confirm overwrite dialog #define OVERWRITE_MSG 200 // length of the message for the overwrite dialog #define PM_NEWCURSOR (WM_USER + 1) #define PM_PAUSEANIMATION (WM_USER + 2) #define PM_UNPAUSEANIMATION (WM_USER + 3) #define ID_PREVIEWTIMER 1 #define CCH_ANISTRING 80 #define CIF_FILE 0x0001 #define CIF_MODIFIED 0x0002 #define CIF_SHARED 0x0004 #define IDT_BROWSE 1 // // Typedef Declarations. // typedef struct _CURSOR_INFO { DWORD fl; HCURSOR hcur; int ccur; int icur; TCHAR szFile[MAX_PATH]; } CURSOR_INFO, *PCURSOR_INFO; #pragma pack(2) typedef struct tagNEWHEADER { WORD reserved; WORD rt; WORD cResources; } NEWHEADER, *LPNEWHEADER; #pragma pack() typedef struct { UINT idVisName; int idResource; int idDefResource; LPTSTR pszIniName; TCHAR szVisName[MAX_PATH]; } CURSORDESC, *PCURSORDESC; // // Structure that contains data used within a preview window. This // data is unique for each preview window, and is used to optimize // the painting. // typedef struct { HDC hdcMem; HBITMAP hbmMem; HBITMAP hbmOld; PCURSOR_INFO pcuri; } PREVIEWDATA, *PPREVIEWDATA; typedef struct _MOUSEPTRBR { HWND hDlg; CURSOR_INFO curi; } MOUSEPTRBR, *PMOUSEPTRBR; // // Global Variables. // extern HINSTANCE g_hInst; // from main.c int gcxCursor, gcyCursor; HWND ghwndDlg, ghwndFile, ghwndFileH, ghwndTitle, ghwndTitleH; HWND ghwndCreator, ghwndCreatorH, ghwndCursors, ghwndPreview, ghwndSchemeCB; HBRUSH ghbrHighlight, ghbrHighlightText, ghbrWindow, ghbrButton; UINT guTextHeight = 0; UINT guTextGap = 0; COLORREF gcrHighlightText; TCHAR gszFileName2[MAX_PATH]; UINT wBrowseHelpMessage; LPTSTR gszFileNotFound = NULL; LPTSTR gszBrowse = NULL; LPTSTR gszFilter = NULL; TCHAR gszNoMem[256] = TEXT("No Memory"); HHOOK ghhkMsgFilter; // hook handle for message filter function static const TCHAR szRegStr_Setup[] = REGSTR_PATH_SETUP TEXT("\\Setup"); static const TCHAR szSharedDir[] = TEXT("SharedDir"); BOOL gfCursorShadow = FALSE; // // Make sure you add new cursors to the end of this array. // Otherwise the cursor schemes will not work // CURSORDESC gacd[] = { { IDS_ARROW, OCR_NORMAL, OCR_ARROW_DEFAULT, TEXT("Arrow"), TEXT("") }, { IDS_HELPCUR, OCR_HELP, OCR_HELP_DEFAULT, TEXT("Help"), TEXT("") }, { IDS_APPSTARTING, OCR_APPSTARTING, OCR_APPSTARTING_DEFAULT, TEXT("AppStarting"), TEXT("") }, { IDS_WAIT, OCR_WAIT, OCR_WAIT_DEFAULT, TEXT("Wait"), TEXT("") }, { IDS_CROSS, OCR_CROSS, OCR_CROSS_DEFAULT, TEXT("Crosshair"), TEXT("") }, { IDS_IBEAM, OCR_IBEAM, OCR_IBEAM_DEFAULT, TEXT("IBeam"), TEXT("") }, { IDS_NWPEN, OCR_NWPEN, OCR_NWPEN_DEFAULT, TEXT("NWPen"), TEXT("") }, { IDS_NO, OCR_NO, OCR_NO_DEFAULT, TEXT("No"), TEXT("") }, { IDS_SIZENS, OCR_SIZENS, OCR_SIZENS_DEFAULT, TEXT("SizeNS"), TEXT("") }, { IDS_SIZEWE, OCR_SIZEWE, OCR_SIZEWE_DEFAULT, TEXT("SizeWE"), TEXT("") }, { IDS_SIZENWSE, OCR_SIZENWSE, OCR_SIZENWSE_DEFAULT, TEXT("SizeNWSE"), TEXT("") }, { IDS_SIZENESW, OCR_SIZENESW, OCR_SIZENESW_DEFAULT, TEXT("SizeNESW"), TEXT("") }, { IDS_SIZEALL, OCR_SIZEALL, OCR_SIZEALL_DEFAULT, TEXT("SizeAll"), TEXT("") }, { IDS_UPARROW, OCR_UP, OCR_UPARROW_DEFAULT, TEXT("UpArrow"), TEXT("") }, { IDS_HANDCUR, OCR_HAND, OCR_HAND_DEFAULT, TEXT("Hand"), TEXT("") }, }; #define CCURSORS (sizeof(gacd) / sizeof(gacd[0])) CURSOR_INFO acuri[CCURSORS]; // // Registry Keys. // const TCHAR szCursorSubdir[] = TEXT("Cursors"); const TCHAR szCursorRegPath[] = REGSTR_PATH_CURSORS; static const TCHAR c_szRegPathCursors[] = REGSTR_PATH_CURSORS; static const TCHAR c_szSchemes[] = TEXT("Schemes"); static const TCHAR c_szRegPathCursorSchemes[] = REGSTR_PATH_CURSORS TEXT( "\\Schemes" ); // // Strings used to read from the combo box must be larger than max length. // TCHAR gszSchemeName[MAX_SCHEME_SUFFIX + MAX_SCHEME_NAME_LEN + 1]; // used to store selected scheme name for saving int iSchemeLocation; // used to store scheme location (HKCU vs HKLM) static const TCHAR c_szRegPathSystemSchemes[] = REGSTR_PATH_SETUP TEXT("\\Control Panel\\Cursors\\Schemes"); TCHAR szSystemScheme[MAX_SCHEME_SUFFIX]; TCHAR szNone[MAX_SCHEME_NAME_LEN + 1]; const TCHAR szSchemeSource[] = TEXT("Scheme Source"); TCHAR gszPreviousScheme[MAX_SCHEME_SUFFIX + MAX_SCHEME_NAME_LEN + 1]; // used to tell if a different scheme is selected #define ID_NONE_SCHEME 0 #define ID_USER_SCHEME 1 #define ID_OS_SCHEME 2 // // Context Help Ids. // const static DWORD aMousePtrHelpIDs[] = { IDC_GROUPBOX_1, IDH_COMM_GROUPBOX, ID_SCHEMECOMBO, IDH_MOUSE_POINT_SCHEME, ID_SAVESCHEME, IDH_MOUSE_POINT_SAVEAS, ID_REMOVESCHEME, IDH_MOUSE_POINT_DEL, ID_PREVIEW, IDH_MOUSE_POINT_PREVIEW, ID_CURSORLIST, IDH_MOUSE_POINT_LIST, ID_DEFAULT, IDH_MOUSE_POINT_DEFAULT, ID_BROWSE, IDH_MOUSE_POINT_BROWSE, ID_CURSORSHADOW, IDH_MOUSE_CURSORSHADOW, 0, 0 }; const static DWORD aMousePtrBrowseHelpIDs[] = { IDC_GROUPBOX_1, IDH_MOUSE_POINT_PREVIEW, ID_CURSORPREVIEW, IDH_MOUSE_POINT_PREVIEW, 0, 0 }; const static DWORD aHelpIDs[] = { ID_SCHEMEFILENAME, IDH_MOUSE_NEW_SCHEME_NAME, 0, 0 }; // // Forward Declarations. // void LoadCursorSet(HWND hwnd); void CreateBrushes(void); LPTSTR GetResourceString(HINSTANCE hmod,int id); void DrawCursorListItem(DRAWITEMSTRUCT *pdis); BOOL GetCursorFromFile(CURSOR_INFO *pcuri); BOOL Browse(HWND hwndOwner); void CleanUpEverything(void); VOID UpdateCursorList(void); VOID NextFrame(HWND hwnd); void HourGlass(BOOL fOn); BOOL TryToLoadCursor( HWND hwnd, int i, CURSOR_INFO *pcuri); BOOL LoadScheme(void); BOOL SaveScheme(void); BOOL SaveSchemeAs(void); void SaveCurSchemeName(void); BOOL RemoveScheme(void); BOOL InitSchemeComboBox(void); BOOL SchemeUpdate(int i); LPTSTR MakeFilename(LPTSTR sz); INT_PTR CALLBACK SaveSchemeDlgProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam); void CurStripBlanks(LPTSTR pszString); int SystemOrUser(TCHAR *pszSchemeName); BOOL UnExpandPath( LPTSTR pszPath ); //////////////////////////////////////////////////////////////////////////// // // RegisterPointerStuff // //////////////////////////////////////////////////////////////////////////// BOOL RegisterPointerStuff( HINSTANCE hi) { gcxCursor = GetSystemMetrics(SM_CXCURSOR); gcyCursor = GetSystemMetrics(SM_CYCURSOR); return (TRUE); } //////////////////////////////////////////////////////////////////////////// // // InitCursorsShadow // //////////////////////////////////////////////////////////////////////////// void InitCursorShadow(HWND hwnd) { BOOL fPalette; HDC hdc; int nCommand; hdc = GetDC(NULL); fPalette = (GetDeviceCaps(hdc, NUMCOLORS) != -1); ReleaseDC(NULL, hdc); if (!fPalette) { nCommand = SW_SHOW; } else { nCommand = SW_HIDE; } ShowWindow(GetDlgItem(hwnd, ID_CURSORSHADOW), nCommand); if (nCommand = SW_SHOW) { SystemParametersInfo(SPI_GETCURSORSHADOW, 0, (PVOID)&gfCursorShadow, 0); CheckDlgButton(hwnd, ID_CURSORSHADOW, gfCursorShadow); } } //////////////////////////////////////////////////////////////////////////// // // InitCursorsDlg // //////////////////////////////////////////////////////////////////////////// BOOL InitCursorsDlg( HWND hwnd) { int i; ghwndDlg = hwnd; gszPreviousScheme[0] = TEXT('\0'); // // Register the help message from the File Open (Browse) dialog. // wBrowseHelpMessage = RegisterWindowMessage(HELPMSGSTRING); // // Load Strings. // if (gszFileNotFound == NULL) { gszFileNotFound = GetResourceString(g_hInst, IDS_CUR_BADFILE); if (gszFileNotFound == NULL) { return (FALSE); } } if (gszBrowse == NULL) { gszBrowse = GetResourceString(g_hInst, IDS_CUR_BROWSE); if (gszBrowse == NULL) { return (FALSE); } } #ifdef WINNT if (gszFilter == NULL) { gszFilter = GetResourceString(g_hInst, IDS_ANICUR_FILTER); if (!gszFilter) { return (FALSE); } } #else if (gszFilter == NULL) { HDC dc = GetDC(NULL); BOOL fAni = (GetDeviceCaps(dc, CAPS1) & C1_COLORCURSOR) != 0; ReleaseDC(NULL, dc); gszFilter = GetResourceString( g_hInst, fAni ? IDS_ANICUR_FILTER : IDS_CUR_FILTER ); if (!gszFilter) { return (FALSE); } } #endif // // Load description strings from the resource file. // for (i = 0; i < CCURSORS; i++) { if ((!gacd[i].idVisName) || (LoadString( g_hInst, gacd[i].idVisName, gacd[i].szVisName, ARRAYSIZE(gacd[i].szVisName) ) <= 0)) { // // Show something. // lstrcpy(gacd[i].szVisName, gacd[i].pszIniName); } } // // As an optimization, remember the window handles of the cursor // information fields. // ghwndPreview = GetDlgItem(hwnd, ID_PREVIEW); ghwndFile = GetDlgItem(hwnd, ID_FILE); ghwndFileH = GetDlgItem(hwnd, ID_FILEH); ghwndTitle = GetDlgItem(hwnd, ID_TITLE); ghwndTitleH = GetDlgItem(hwnd, ID_TITLEH); ghwndCreator = GetDlgItem(hwnd, ID_CREATOR); ghwndCreatorH = GetDlgItem(hwnd, ID_CREATORH); ghwndCursors = GetDlgItem(hwnd, ID_CURSORLIST); ghwndSchemeCB = GetDlgItem(hwnd, ID_SCHEMECOMBO); // // Create some brushes we'll be using. // CreateBrushes(); // // Initialize the scheme combo box. // InitSchemeComboBox(); // // Pre-clear the cursor info array. // memset(acuri, 0, sizeof(acuri)); // // Load the cursors. // LoadCursorSet(hwnd); // // Force an update of the preview window and the cursor details. // UpdateCursorList(); InitCursorShadow(hwnd); return (TRUE); } //////////////////////////////////////////////////////////////////////////// // // LoadCursorSet // //////////////////////////////////////////////////////////////////////////// void LoadCursorSet( HWND hwnd) { CURSOR_INFO *pcuri; HKEY hkCursors; int i; if (RegOpenKey( HKEY_CURRENT_USER, szCursorRegPath, &hkCursors ) != ERROR_SUCCESS) { hkCursors = NULL; } for (pcuri = &acuri[0], i = 0; i < CCURSORS; i++, pcuri++) { if ( hkCursors ) { DWORD dwType; DWORD dwCount = sizeof(pcuri->szFile); DWORD dwErr = RegQueryValueEx( hkCursors, gacd[i].pszIniName, NULL, &dwType, (LPBYTE)pcuri->szFile, &dwCount ); if (dwErr == ERROR_SUCCESS) { if (TryToLoadCursor(hwnd, i, pcuri)) { goto EverythingWorked; } } } // This is actually the failure case. We load the default cursor. pcuri->hcur = (HCURSOR)LoadImage( NULL, MAKEINTRESOURCE(gacd[i].idResource), IMAGE_CURSOR, 0, 0, LR_SHARED | LR_DEFAULTSIZE | LR_ENVSUBST ); pcuri->fl |= CIF_SHARED; EverythingWorked: SendMessage(ghwndCursors, LB_ADDSTRING, 0, i); } if (hkCursors) { RegCloseKey(hkCursors); } SendMessage(ghwndCursors, LB_SETCURSEL, 0, 0); } //////////////////////////////////////////////////////////////////////////// // // CreateBrushes // // Creates the brushes that are used to paint within the Cursors applet. // //////////////////////////////////////////////////////////////////////////// VOID CreateBrushes() { ghbrHighlight = GetSysColorBrush(COLOR_HIGHLIGHT); gcrHighlightText = GetSysColor(COLOR_HIGHLIGHTTEXT); ghbrHighlightText = GetSysColorBrush(COLOR_HIGHLIGHTTEXT); ghbrWindow = GetSysColorBrush(COLOR_WINDOW); ghbrButton = GetSysColorBrush(COLOR_BTNFACE); } //////////////////////////////////////////////////////////////////////////// // // GetResourceString // // Gets a string out of the resource file. // //////////////////////////////////////////////////////////////////////////// LPTSTR GetResourceString( HINSTANCE hmod, int id) { TCHAR szBuffer[256]; LPTSTR psz; int cch; if ((cch = LoadString(hmod, id, szBuffer, ARRAYSIZE(szBuffer))) == 0) { return (NULL); } psz = LocalAlloc(LPTR, (cch + 1) * sizeof(TCHAR)); if (psz != NULL) { int i; for (i = 0; i <= cch; i++) { psz[i] = (szBuffer[i] == TEXT('\1')) ? TEXT('\0') : szBuffer[i]; } } return (psz); } //////////////////////////////////////////////////////////////////////////// // // FreeItemCursor // //////////////////////////////////////////////////////////////////////////// void FreeItemCursor( CURSOR_INFO *pcuri) { if (pcuri->hcur) { if (!(pcuri->fl & CIF_SHARED)) { DestroyCursor(pcuri->hcur); } pcuri->hcur = NULL; } } //////////////////////////////////////////////////////////////////////////// // // MousePtrDlg // //////////////////////////////////////////////////////////////////////////// INT_PTR CALLBACK MousePtrDlg( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { CURSOR_INFO *pcuri; HKEY hkCursors; int i; switch (msg) { case ( WM_INITDIALOG ) : { return InitCursorsDlg(hwnd); } case ( WM_DISPLAYCHANGE ) : { InitCursorShadow(hwnd); SHPropagateMessage(hwnd, msg, wParam, lParam, TRUE); break; } case ( WM_MEASUREITEM ) : { ((MEASUREITEMSTRUCT *)lParam)->itemHeight = gcyCursor + 2; break; } case ( WM_DRAWITEM ) : { DrawCursorListItem((DRAWITEMSTRUCT *)lParam); break; } case ( WM_COMMAND ) : { switch (LOWORD(wParam)) { case ( ID_SCHEMECOMBO ) : { switch (HIWORD(wParam)) { case ( CBN_SELCHANGE ) : { LoadScheme(); break; } } break; } case ( ID_DEFAULT ) : { // // Throw away any fancy new cursor and replace it with // the system's original. // i = (int)SendMessage(ghwndCursors, LB_GETCURSEL, 0, 0); pcuri = &acuri[i]; if (!(pcuri->fl & CIF_FILE)) { break; } pcuri->fl = CIF_MODIFIED; SendMessage(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0L); FreeItemCursor(pcuri); pcuri->hcur = (HCURSOR)LoadImage( NULL, MAKEINTRESOURCE(gacd[i].idDefResource), IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_ENVSUBST ); *pcuri->szFile = TEXT('\0'); EnableWindow(GetDlgItem(hwnd, ID_SAVESCHEME), TRUE); UpdateCursorList(); break; } case ( ID_CURSORLIST ) : { switch (HIWORD(wParam)) { case ( LBN_SELCHANGE ) : { i = (int)SendMessage((HWND)lParam, LB_GETCURSEL, 0, 0); pcuri = &acuri[i]; // // Show a preview (including animation) in the // preview window. // SendMessage( ghwndPreview, STM_SETICON, (WPARAM)pcuri->hcur, 0L ); // // Enable the "Set Default" button if the cursor // is from a file. // EnableWindow( GetDlgItem(hwnd, ID_DEFAULT), (pcuri->fl & CIF_FILE ) ? TRUE : FALSE ); break; } case ( LBN_DBLCLK ) : { Browse(hwnd); break; } } break; } case ( ID_BROWSE ) : { Browse(hwnd); break; } case ( ID_SAVESCHEME ) : { SaveSchemeAs(); break; } case ( ID_REMOVESCHEME ) : { RemoveScheme(); break; } case ( ID_CURSORSHADOW ) : { gfCursorShadow = IsDlgButtonChecked(hwnd, ID_CURSORSHADOW); SendMessage(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0L); break; } } break; } case ( WM_NOTIFY ) : { switch(((NMHDR *)lParam)->code) { case ( PSN_APPLY ) : { // // Change cursor to hour glass. // HourGlass(TRUE); // Set cursor shadow SystemParametersInfo( SPI_SETCURSORSHADOW, 0, (PVOID)gfCursorShadow, SPIF_UPDATEINIFILE); // // Save the modified scheme, order of calls important. // SaveCurSchemeName(); // // Set the system cursors. // if (RegCreateKey( HKEY_CURRENT_USER, szCursorRegPath, &hkCursors ) == ERROR_SUCCESS) { for (pcuri = &acuri[0], i = 0; i < CCURSORS; i++, pcuri++) { if (pcuri->fl & CIF_MODIFIED) { LPCTSTR data; UINT count; // Always unexpand before we save a filename UnExpandPath(pcuri->szFile); data = (pcuri->fl & CIF_FILE) ? pcuri->szFile : TEXT(""); count = (pcuri->fl & CIF_FILE) ? (lstrlen(pcuri->szFile) + 1) * sizeof(TCHAR) : sizeof(TCHAR); RegSetValueEx( hkCursors, gacd[i].pszIniName, 0L, REG_EXPAND_SZ, (CONST LPBYTE)data, count ); } } RegCloseKey(hkCursors); SystemParametersInfo( SPI_SETCURSORS, 0, 0, SPIF_SENDCHANGE ); } HourGlass(FALSE); break; } default : { return (FALSE); } } break; } case ( WM_SYSCOLORCHANGE ) : { gcrHighlightText = GetSysColor(COLOR_HIGHLIGHTTEXT); SHPropagateMessage(hwnd, msg, wParam, lParam, TRUE); break; } case ( WM_WININICHANGE ) : { SHPropagateMessage(hwnd, msg, wParam, lParam, TRUE); break; } case ( WM_DESTROY ) : { // // Clean up global allocs. // CleanUpEverything(); if (gszFileNotFound != NULL) { LocalFree(gszFileNotFound); gszFileNotFound = NULL; } if (gszBrowse != NULL) { LocalFree(gszBrowse); gszBrowse = NULL; } if (gszFilter != NULL) { LocalFree(gszFilter); gszFilter = NULL; } break; } case ( WM_HELP ) : { WinHelp( ((LPHELPINFO)lParam)->hItemHandle, HELP_FILE, HELP_WM_HELP, (DWORD_PTR)(LPTSTR)aMousePtrHelpIDs ); break; } case ( WM_CONTEXTMENU ) : { WinHelp( (HWND)wParam, HELP_FILE, HELP_CONTEXTMENU, (DWORD_PTR)(LPVOID)aMousePtrHelpIDs ); break; } default : { return (FALSE); } } return (TRUE); } //////////////////////////////////////////////////////////////////////////// // // DrawCursorListItem // //////////////////////////////////////////////////////////////////////////// void DrawCursorListItem( DRAWITEMSTRUCT *pdis) { CURSOR_INFO *pcuri; COLORREF clrOldText, clrOldBk; RECT rc; if (!guTextHeight || !guTextGap) { TEXTMETRIC tm; tm.tmHeight = 0; GetTextMetrics(pdis->hDC, &tm); if (tm.tmHeight < 0) { tm.tmHeight *= -1; } guTextHeight = (UINT)tm.tmHeight; guTextGap = (UINT)tm.tmAveCharWidth; } pcuri = &acuri[pdis->itemData]; if (pdis->itemState & ODS_SELECTED) { clrOldText = SetTextColor(pdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT)); clrOldBk = SetBkColor(pdis->hDC, GetSysColor(COLOR_HIGHLIGHT)); } else { clrOldText = SetTextColor(pdis->hDC, GetSysColor(COLOR_WINDOWTEXT)); clrOldBk = SetBkColor(pdis->hDC, GetSysColor(COLOR_WINDOW)); } ExtTextOut( pdis->hDC, pdis->rcItem.left + guTextGap, // fudge factor (pdis->rcItem.top + pdis->rcItem.bottom - guTextHeight) / 2, ETO_OPAQUE, &pdis->rcItem, gacd[pdis->itemData].szVisName, lstrlen(gacd[pdis->itemData].szVisName), NULL ); if (pcuri->hcur != NULL) { DrawIcon( pdis->hDC, pdis->rcItem.right - (gcxCursor + guTextGap), pdis->rcItem.top + 1, pcuri->hcur ); } if (pdis->itemState & ODS_FOCUS) { CopyRect(&rc, &pdis->rcItem); InflateRect(&rc, -1, -1); DrawFocusRect(pdis->hDC, &rc); } SetTextColor(pdis->hDC, clrOldText); SetBkColor(pdis->hDC, clrOldBk); } //////////////////////////////////////////////////////////////////////////// // // TryToLoadCursor // //////////////////////////////////////////////////////////////////////////// BOOL TryToLoadCursor( HWND hwnd, int i, CURSOR_INFO *pcuri) { BOOL fRet = TRUE; BOOL bCustom = (*pcuri->szFile != 0); if (bCustom && !GetCursorFromFile(pcuri)) { HWND hwndControl = GetParent(hwnd); LPTSTR pszText; LPTSTR pszFilename; // // MakeFilename returns the address of a global, so we don't // need to free pszFilename. // pszFilename = MakeFilename(pcuri->szFile); pszText = LocalAlloc( LPTR, (lstrlen(gszFileNotFound) + lstrlen(gacd[i].szVisName) + lstrlen(pszFilename) + 1) * sizeof(TCHAR) ); if (pszText == NULL) { return (FALSE); } wsprintf(pszText, gszFileNotFound, pszFilename, gacd[i].szVisName); MessageBeep(MB_ICONEXCLAMATION); MessageBox(hwndControl, pszText, NULL, MB_ICONEXCLAMATION | MB_OK); pcuri->fl = CIF_MODIFIED; SendMessage(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0L); bCustom = FALSE; LocalFree(pszText); } if (!bCustom) { FreeItemCursor(pcuri); pcuri->hcur = (HCURSOR)LoadImage( NULL, MAKEINTRESOURCE(gacd[i].idDefResource), IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_ENVSUBST ); *pcuri->szFile = TEXT('\0'); EnableWindow(GetDlgItem(hwnd, ID_SAVESCHEME), TRUE); UpdateCursorList(); } return (pcuri->hcur != NULL); } //////////////////////////////////////////////////////////////////////////// // // GetCursorFromFile // //////////////////////////////////////////////////////////////////////////// BOOL GetCursorFromFile( CURSOR_INFO *pcuri) { pcuri->fl = 0; pcuri->hcur = (HCURSOR)LoadImage( NULL, MakeFilename(pcuri->szFile), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_DEFAULTSIZE | LR_ENVSUBST ); if (pcuri->hcur) { pcuri->fl |= CIF_FILE; } return (pcuri->hcur != NULL); } //////////////////////////////////////////////////////////////////////////// // // MousePtrBrowsePreview // //////////////////////////////////////////////////////////////////////////// void MousePtrBrowsePreview( HWND hDlg) { PMOUSEPTRBR pPtrBr; HCURSOR hcurOld; pPtrBr = (PMOUSEPTRBR)GetWindowLongPtr(hDlg, DWLP_USER); hcurOld = pPtrBr->curi.hcur; CommDlg_OpenSave_GetFilePath( GetParent(hDlg), pPtrBr->curi.szFile, ARRAYSIZE(pPtrBr->curi.szFile) ); if (!GetCursorFromFile(&pPtrBr->curi)) { pPtrBr->curi.hcur = NULL; } SendDlgItemMessage( hDlg, ID_CURSORPREVIEW, STM_SETICON, (WPARAM)pPtrBr->curi.hcur, 0L ); if (hcurOld) { DestroyCursor(hcurOld); } } //////////////////////////////////////////////////////////////////////////// // // MousePtrBrowseNotify // //////////////////////////////////////////////////////////////////////////// BOOL MousePtrBrowseNotify( HWND hDlg, LPOFNOTIFY pofn) { switch (pofn->hdr.code) { case ( CDN_SELCHANGE ) : { // // Don't show the cursor until the user stops moving around. // if (SetTimer(hDlg, IDT_BROWSE, 250, NULL)) { // // Don't destroy the old cursor. // SendDlgItemMessage( hDlg, ID_CURSORPREVIEW, STM_SETICON, 0, 0L ); } else { MousePtrBrowsePreview(hDlg); } break; } } return (TRUE); } //////////////////////////////////////////////////////////////////////////// // // MousePtrBrowseDlgProc // //////////////////////////////////////////////////////////////////////////// INT_PTR CALLBACK MousePtrBrowseDlgProc( HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch (uMsg) { case ( WM_INITDIALOG ) : { PMOUSEPTRBR pPtrBr = (PMOUSEPTRBR)((LPOPENFILENAME)lParam)->lCustData; if (pPtrBr) { pPtrBr->hDlg = hDlg; } SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR) pPtrBr); break; } case ( WM_DESTROY ) : { KillTimer(hDlg, IDT_BROWSE); // // Don't destroy the old cursor. // SendDlgItemMessage(hDlg, ID_CURSORPREVIEW, STM_SETICON, 0, 0L); break; } case ( WM_TIMER ) : { KillTimer(hDlg, IDT_BROWSE); MousePtrBrowsePreview(hDlg); break; } case ( WM_NOTIFY ) : { return (MousePtrBrowseNotify(hDlg, (LPOFNOTIFY) lParam)); } case ( WM_HELP ) : { WinHelp( (HWND)((LPHELPINFO)lParam)->hItemHandle, HELP_FILE, HELP_WM_HELP, (DWORD_PTR)(LPTSTR)aMousePtrBrowseHelpIDs ); break; } case ( WM_CONTEXTMENU ) : { WinHelp( (HWND)wParam, HELP_FILE, HELP_CONTEXTMENU, (DWORD_PTR)(LPVOID)aMousePtrBrowseHelpIDs ); break; } default : { return (FALSE); } } return (TRUE); } //////////////////////////////////////////////////////////////////////////// // // Browse // // Browse the file system for a new cursor for the selected item. // //////////////////////////////////////////////////////////////////////////// BOOL Browse(HWND hwndOwner) { static TCHAR szCustomFilter[80] = TEXT(""); static TCHAR szStartDir[MAX_PATH] = TEXT(""); OPENFILENAME ofn; CURSOR_INFO curi; int i; BOOL fRet = FALSE; MOUSEPTRBR sPtrBr; if (!*szStartDir) { HKEY key = NULL; if (RegOpenKey(HKEY_LOCAL_MACHINE, szRegStr_Setup, &key) == ERROR_SUCCESS) { LONG len = sizeof(szStartDir) / sizeof(szStartDir[0]); if (RegQueryValueEx( key, szSharedDir, NULL, NULL, (LPBYTE)szStartDir, &len ) != ERROR_SUCCESS) { *szStartDir = TEXT('\0'); } RegCloseKey(key); } if (!*szStartDir) { GetWindowsDirectory(szStartDir, MAX_PATH); } PathAppend(szStartDir, szCursorSubdir); } curi.szFile[0] = TEXT('\0'); sPtrBr.curi.szFile[0] = TEXT('\0'); sPtrBr.curi.hcur = NULL; ofn.lStructSize = sizeof(ofn); ofn.hwndOwner = hwndOwner; ofn.hInstance = g_hInst; ofn.lpstrFilter = gszFilter; ofn.lpstrCustomFilter = szCustomFilter; ofn.nMaxCustFilter = ARRAYSIZE(szCustomFilter); ofn.nFilterIndex = 1; ofn.lpstrFile = curi.szFile; ofn.nMaxFile = ARRAYSIZE(curi.szFile); ofn.lpstrFileTitle = NULL; ofn.nMaxFileTitle = 0; ofn.lpstrInitialDir = szStartDir; ofn.lpstrTitle = gszBrowse; ofn.Flags = OFN_EXPLORER | OFN_ENABLETEMPLATE | OFN_ENABLEHOOK | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY; ofn.lpstrDefExt = NULL; ofn.lpfnHook = MousePtrBrowseDlgProc; ofn.lpTemplateName = MAKEINTRESOURCE(DLG_MOUSE_POINTER_BROWSE); ofn.lCustData = (LPARAM)(PMOUSEPTRBR)&sPtrBr; fRet = GetOpenFileName(&ofn); GetCurrentDirectory(ARRAYSIZE(szStartDir), szStartDir); if (!fRet) { goto brErrExit; } fRet = FALSE; // // We have probably already gotten this cursor. // if (lstrcmpi(curi.szFile, sPtrBr.curi.szFile) == 0) { if (!sPtrBr.curi.hcur) { goto brErrExit; } curi = sPtrBr.curi; // // Clear this so it will not get destroyed in the cleanup code. // sPtrBr.curi.hcur = NULL; } else { // // The user must have typed in a name. // if (!GetCursorFromFile(&curi)) { goto brErrExit; } } // // Convert mapped drive letters to UNC. // #ifdef UNICODE if (curi.szFile[1] == TEXT(':')) #else if (!IsDBCSLeadByte(curi.szFile[0]) && (curi.szFile[1] == TEXT(':'))) #endif { TCHAR szDrive[3]; TCHAR szNet[MAX_PATH]; int lenNet = ARRAYSIZE(szNet); lstrcpyn(szDrive, curi.szFile, ARRAYSIZE(szDrive)); if ((WNetGetConnection(szDrive, szNet, &lenNet) == NO_ERROR) && (szNet[0] == TEXT('\\')) && (szNet[1] == TEXT('\\'))) { lstrcat(szNet, curi.szFile + 2); lstrcpy(curi.szFile, szNet); } } i = (int)SendMessage(ghwndCursors, LB_GETCURSEL, 0, 0); curi.fl |= CIF_MODIFIED; SendMessage(GetParent(ghwndDlg), PSM_CHANGED, (WPARAM)ghwndDlg, 0L); EnableWindow(GetDlgItem(ghwndDlg, ID_SAVESCHEME), TRUE); // // Destroy the old cursor before we retain the new one. // FreeItemCursor(acuri + i); acuri[i] = curi; UpdateCursorList(); fRet = TRUE; brErrExit: if (sPtrBr.curi.hcur) { DestroyCursor(sPtrBr.curi.hcur); } return (fRet); } //////////////////////////////////////////////////////////////////////////// // // CleanUpEverything // // Destroy all the outstanding cursors. // //////////////////////////////////////////////////////////////////////////// void CleanUpEverything() { CURSOR_INFO *pcuri; int i; for (pcuri = &acuri[0], i = 0; i < CCURSORS; i++, pcuri++) { FreeItemCursor(pcuri); } } //////////////////////////////////////////////////////////////////////////// // // UpdateCursorList // // Force the Cursor ListBox to repaint and the cursor information below the // listbox to be refreshed as well. // //////////////////////////////////////////////////////////////////////////// VOID UpdateCursorList() { int i = (int)SendMessage(ghwndCursors, LB_GETCURSEL, 0, 0); PCURSOR_INFO pcuri = ((i >= 0) ? &acuri[i] : NULL); HCURSOR hcur = pcuri ? pcuri->hcur : NULL; HWND hDefaultButton = GetDlgItem(ghwndDlg, ID_DEFAULT); BOOL fEnableDefaultButton = (pcuri && (pcuri->fl & CIF_FILE)); InvalidateRect(ghwndCursors, NULL, FALSE); SendMessage(ghwndPreview, STM_SETICON, (WPARAM)hcur, 0L); if (!fEnableDefaultButton && (GetFocus() == hDefaultButton)) { SendMessage(ghwndDlg, WM_NEXTDLGCTL, (WPARAM)ghwndCursors, TRUE); } EnableWindow(hDefaultButton, fEnableDefaultButton); } //////////////////////////////////////////////////////////////////////////// // // SaveSchemeAs // //////////////////////////////////////////////////////////////////////////// BOOL SaveSchemeAs() { BOOL fSuccess = TRUE; // // Dialog proc returns TRUE & sets gszSchemeName to filename entered // on OK. // if (DialogBox( g_hInst, MAKEINTRESOURCE(DLG_MOUSE_POINTER_SCHEMESAVE), ghwndDlg, SaveSchemeDlgProc )) { fSuccess = SaveScheme(); if (fSuccess) { int index = (int)SendMessage( ghwndSchemeCB, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)gszSchemeName ); // // If not found, add it. // if (index < 0) { index = (int)SendMessage( ghwndSchemeCB, CB_ADDSTRING, 0, (LPARAM)gszSchemeName ); } // // Select the name. // SendMessage(ghwndSchemeCB, CB_SETCURSEL, (WPARAM) index, 0); // // Since this is now a user saved scheme, activate the delete // button. // EnableWindow(GetDlgItem(ghwndDlg, ID_REMOVESCHEME), TRUE); } } return (fSuccess); } //////////////////////////////////////////////////////////////////////////// // // SubstituteString // // Replaces the string pszRemove with the string pszReplace in the // string pszInput and places the output in pszResult. Only looks // at the begining of the input string. // //////////////////////////////////////////////////////////////////////////// BOOL SubstituteString(LPCTSTR pszInput, LPCTSTR pszRemove, LPCTSTR pszReplace, LPTSTR pszResult, UINT cchResult) { DWORD cchRemove = lstrlen(pszRemove); if (CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, pszRemove, cchRemove, pszInput, cchRemove) == 2) { if (lstrlen(pszInput) + cchRemove < cchResult) { lstrcpy(pszResult, pszReplace); lstrcat(pszResult, pszInput + cchRemove); return TRUE; } } return FALSE; } BOOL UnExpandPath( LPTSTR pszPath ) { static TCHAR szUserProfile[MAX_PATH]; static TCHAR szSystemRoot[MAX_PATH]; static TCHAR szProgramFiles[MAX_PATH]; static BOOL bInit = FALSE; TCHAR szUnexpandedFilename[MAX_PATH]; if ( !bInit ) { ExpandEnvironmentStrings( TEXT("%USERPROFILE%"), szUserProfile, ARRAYSIZE(szUserProfile) ); ExpandEnvironmentStrings( TEXT("%SYSTEMROOT%"), szSystemRoot, ARRAYSIZE(szSystemRoot) ); ExpandEnvironmentStrings( TEXT("%ProgramFiles%"), szProgramFiles, ARRAYSIZE(szProgramFiles) ); bInit = TRUE; } if (!SubstituteString(pszPath, szUserProfile, TEXT("%USERPROFILE%"), szUnexpandedFilename, ARRAYSIZE(szUnexpandedFilename))) { if (!SubstituteString(pszPath, szSystemRoot, TEXT("%SYSTEMROOT%"), szUnexpandedFilename, ARRAYSIZE(szUnexpandedFilename))) { if (!SubstituteString(pszPath, szProgramFiles, TEXT("%ProgramFiles%"), szUnexpandedFilename, ARRAYSIZE(szUnexpandedFilename))) { return FALSE; } } } lstrcpy(pszPath, szUnexpandedFilename); return TRUE; } //////////////////////////////////////////////////////////////////////////// // // SaveScheme // //////////////////////////////////////////////////////////////////////////// BOOL SaveScheme() { BOOL fSuccess = FALSE; if (*gszSchemeName) { const BUFFER_SIZE = CCURSORS * (MAX_PATH + 1) + 1; LPTSTR pszBuffer = (LPTSTR)LocalAlloc( LMEM_FIXED, BUFFER_SIZE * sizeof(TCHAR) ); HKEY hk; int i; if (!pszBuffer) { return (FALSE); } pszBuffer[0] = TEXT('\0'); for (i = 0; i < CCURSORS; i++) { if (i) { lstrcat(pszBuffer, TEXT(",")); } // Replace path with evnironment variables. UnExpandPath(acuri[i].szFile); lstrcat(pszBuffer, acuri[i].szFile); } if (RegCreateKey( HKEY_CURRENT_USER, c_szRegPathCursors, &hk ) == ERROR_SUCCESS) { HKEY hks; if (RegCreateKey(hk, c_szSchemes, &hks) == ERROR_SUCCESS) { LPTSTR pszOldValue = (LPTSTR)LocalAlloc( LMEM_FIXED, BUFFER_SIZE * sizeof(TCHAR) ); DWORD dwType; DWORD dwSize = BUFFER_SIZE*sizeof(TCHAR); BOOL bSave = FALSE; int ret = RegQueryValueEx(hks, gszSchemeName, NULL, &dwType, (LPBYTE)pszOldValue, &dwSize); // // If the key already exists, ask to confirm the overwrite. // if (ret == ERROR_SUCCESS && (dwType==REG_SZ || dwType==REG_EXPAND_SZ)) { // only need to save if value is different from old value if (lstrcmp(pszOldValue,pszBuffer)!=0) { TCHAR szTitle[OVERWRITE_TITLE]; TCHAR szMsg[OVERWRITE_MSG]; LoadString(g_hInst, IDS_OVERWRITE_TITLE, szTitle, OVERWRITE_TITLE); LoadString(g_hInst, IDS_OVERWRITE_MSG, szMsg, OVERWRITE_MSG); if (MessageBox( ghwndDlg, szMsg, szTitle, MB_ICONQUESTION | MB_YESNO ) == IDYES) { // // Overwrite confirmed. Safe to save. // bSave = TRUE; } } else { // no need to save since the new value is the same as the old value. fSuccess = TRUE; } } else { // // The key doesn't exist, so it's safe to create it. // bSave = TRUE; } if (bSave) { if (RegSetValueEx( hks, gszSchemeName, 0, REG_EXPAND_SZ, (LPBYTE)pszBuffer, (lstrlen(pszBuffer) + 1) * sizeof(TCHAR) ) == ERROR_SUCCESS) { fSuccess = TRUE; } } RegCloseKey(hks); LocalFree( pszOldValue ); } RegCloseKey(hk); } LocalFree(pszBuffer); } return (fSuccess); } //////////////////////////////////////////////////////////////////////////// // // SaveCurSchemeName // //////////////////////////////////////////////////////////////////////////// void SaveCurSchemeName() { HKEY hk; if (RegCreateKey( HKEY_CURRENT_USER, c_szRegPathCursors, &hk ) == ERROR_SUCCESS) { int index = (int)SendMessage(ghwndSchemeCB, CB_GETCURSEL, 0, 0L); SendMessage( ghwndSchemeCB, CB_GETLBTEXT, (WPARAM)index, (LPARAM)gszSchemeName ); // // Exclude the "none" pattern. // if (lstrcmpi(gszSchemeName, szNone) == 0) { *gszSchemeName = 0; iSchemeLocation = ID_NONE_SCHEME; } else { iSchemeLocation = SystemOrUser(gszSchemeName); } RegSetValue( hk, NULL, REG_SZ, gszSchemeName, (lstrlen(gszSchemeName) + 1) * sizeof(TCHAR) ); RegSetValueEx( hk, szSchemeSource, 0, REG_DWORD, (unsigned char *)&iSchemeLocation, sizeof(iSchemeLocation) ); RegCloseKey(hk); if (iSchemeLocation == ID_USER_SCHEME) { SaveScheme(); } } } //////////////////////////////////////////////////////////////////////////// // // LoadScheme // // This is called whenever a selection is made from the schemes combo box. // //////////////////////////////////////////////////////////////////////////// BOOL LoadScheme() { const BUFFER_SIZE = CCURSORS * (MAX_PATH + 1) + 1; TCHAR pszSchemeName[MAX_SCHEME_SUFFIX + MAX_SCHEME_NAME_LEN + 1]; LPTSTR pszBuffer; BOOL fSuccess = FALSE; int index, ret; HKEY hk; // // Allocate buffer for cursor paths. // pszBuffer = (LPTSTR)LocalAlloc(LMEM_FIXED, BUFFER_SIZE * sizeof(TCHAR)); if (pszBuffer == NULL) { return (FALSE); } HourGlass(TRUE); *pszBuffer = *pszSchemeName = 0; index = (int)SendMessage(ghwndSchemeCB, CB_GETCURSEL, 0, 0L); // // Get current scheme name. // SendMessage( ghwndSchemeCB, CB_GETLBTEXT, (WPARAM)index, (LPARAM)pszSchemeName ); // Get the text for the item at index, compare to the previous value to see // if it changed. We can't simply compare the previous index because new items // get inserted into the list so the index can change and still be the same or // can be different when nothing has changed. if ( 0 == lstrcmp(gszPreviousScheme, pszSchemeName) ) { // nothing to do, we're loading the already selected scheme return FALSE; } // We're loading a different scheme, enable the apply button. SendMessage(GetParent(ghwndDlg), PSM_CHANGED, (WPARAM)ghwndDlg, 0L); lstrcpy(gszPreviousScheme, pszSchemeName); // // Exclude the "none" pattern. // if (lstrcmpi(pszSchemeName, szNone) != 0) { // // If we have an os scheme, then search for the scheme in HKLM, // otherwise look in HKCU. // if ((((ret = SystemOrUser(pszSchemeName)) == ID_OS_SCHEME) ? (RegOpenKey(HKEY_LOCAL_MACHINE, c_szRegPathSystemSchemes, &hk)) : (RegOpenKey(HKEY_CURRENT_USER, c_szRegPathCursorSchemes, &hk))) == ERROR_SUCCESS) { DWORD len = BUFFER_SIZE * sizeof(TCHAR); if (RegQueryValueEx( hk, pszSchemeName, 0, NULL, (LPBYTE)pszBuffer, &len ) == ERROR_SUCCESS) { fSuccess = TRUE; // can be reset to FALSE below } RegCloseKey(hk); } } else { // // "none" pattern is a valid choice. // ret = ID_NONE_SCHEME; fSuccess = TRUE; } if (fSuccess) { LPTSTR pszNextFile, pszFile = pszBuffer; BOOL fEOL = FALSE; int i = 0; // // Parse string of format TEXT("filename1, filename2, filename3...") // into cursor info array. // do { while (*pszFile && (*pszFile == TEXT(' ') || *pszFile == TEXT('\t') || *pszFile == TEXT('\n'))) { pszFile++; } pszNextFile = pszFile; while (*pszNextFile != TEXT('\0')) { if (*pszNextFile == TEXT(',')) { break; } pszNextFile = CharNext(pszNextFile); } if (*pszNextFile == TEXT('\0')) { fEOL = TRUE; } else { *pszNextFile = TEXT('\0'); } if (lstrcmp(pszFile, acuri[i].szFile)) { // // It's different than current, update. // lstrcpy(acuri[i].szFile, pszFile); fSuccess &= SchemeUpdate(i); } pszFile = pszNextFile; if (!fEOL) { pszFile++; // skip TEXT('\0') and move to next path } i++; } while (i < CCURSORS); } LocalFree(pszBuffer); UpdateCursorList(); EnableWindow(GetDlgItem(ghwndDlg, ID_REMOVESCHEME), (ret == ID_USER_SCHEME)); HourGlass(FALSE); return (fSuccess); } //////////////////////////////////////////////////////////////////////////// // // SchemeUpdate // // Updates the cursor at index i in acuri. // //////////////////////////////////////////////////////////////////////////// BOOL SchemeUpdate(int i) { BOOL fSuccess = TRUE; if (acuri[i].hcur) { FreeItemCursor(acuri + i); } // // If TEXT("Set Default"). // if (*(acuri[i].szFile) == TEXT('\0')) { acuri[i].hcur = (HCURSOR)LoadImage( NULL, MAKEINTRESOURCE(gacd[i].idDefResource), IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_ENVSUBST ); acuri[i].fl = 0; } else { fSuccess = TryToLoadCursor(ghwndDlg, i, &acuri[i]); } acuri[i].fl |= CIF_MODIFIED; return (fSuccess); } //////////////////////////////////////////////////////////////////////////// // // RemoveScheme // //////////////////////////////////////////////////////////////////////////// BOOL RemoveScheme() { // // Only user schemes can be removed, so this only needs to // be MAX_SCHEME_NAME_LEN + 1 long. // TCHAR szSchemeName[MAX_SCHEME_NAME_LEN + 1]; int index; HKEY hk; index = (int)SendMessage(ghwndSchemeCB, CB_GETCURSEL, 0, 0L); // // Get current scheme name. // SendMessage( ghwndSchemeCB, CB_GETLBTEXT, (WPARAM)index, (LPARAM)szSchemeName ); // // Exclude the "none" pattern from removal. // if (lstrcmpi(szSchemeName, szNone) == 0) { return (FALSE); } // // HACK: assume deleting noname needs no confirmation - // this is because the scheme won't save properly anyway. // if (*szSchemeName) { TCHAR RemoveMsg[MAX_PATH]; TCHAR DialogMsg[MAX_PATH]; LoadString(g_hInst, IDS_REMOVESCHEME, RemoveMsg, MAX_PATH); wsprintf(DialogMsg, RemoveMsg, (LPTSTR)szSchemeName); LoadString(g_hInst, IDS_NAME, RemoveMsg, MAX_PATH); if (MessageBox( ghwndDlg, DialogMsg, RemoveMsg, MB_ICONQUESTION | MB_YESNO ) != IDYES) { return (TRUE); } } if (RegOpenKey( HKEY_CURRENT_USER, c_szRegPathCursors, &hk ) == ERROR_SUCCESS) { HKEY hks; if (RegOpenKey(hk, c_szSchemes, &hks) == ERROR_SUCCESS) { RegDeleteValue(hks, szSchemeName); RegCloseKey(hks); } RegCloseKey(hk); } // // Delete from list box. // index = (int)SendMessage( ghwndSchemeCB, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)szSchemeName ); SendMessage(ghwndSchemeCB, CB_DELETESTRING, (WPARAM)index, 0); SendMessage(ghwndSchemeCB, CB_SETCURSEL, 0, 0); SendMessage(ghwndDlg, WM_NEXTDLGCTL, 1, 0L); EnableWindow(GetDlgItem(ghwndDlg, ID_REMOVESCHEME), FALSE); return TRUE; } //////////////////////////////////////////////////////////////////////////// // // InitSchemeComboBox // //////////////////////////////////////////////////////////////////////////// BOOL InitSchemeComboBox() { TCHAR pszSchemeName[MAX_SCHEME_NAME_LEN + 1]; TCHAR pszDefaultSchemeName[MAX_SCHEME_NAME_LEN + 1]; TCHAR pszLongName[MAX_SCHEME_SUFFIX + MAX_SCHEME_NAME_LEN + 1]; int index; HKEY hk; DWORD len; LoadString(g_hInst, IDS_NONE, szNone, ARRAYSIZE(szNone)); LoadString(g_hInst, IDS_SUFFIX, szSystemScheme, ARRAYSIZE(szSystemScheme)); if (RegOpenKey(HKEY_CURRENT_USER, c_szRegPathCursors, &hk) == ERROR_SUCCESS) { HKEY hks; // // Enumerate the schemes. // if (RegOpenKey(hk, c_szSchemes, &hks) == ERROR_SUCCESS) { DWORD i; for (i = 0; ;i++) { LONG ret; // // Reset each pass. // len = ARRAYSIZE(pszSchemeName); ret = RegEnumValue( hks, i, pszSchemeName, &len, NULL, NULL, NULL, NULL ); if (ret == ERROR_MORE_DATA) { continue; } if (ret != ERROR_SUCCESS) { break; } // // HACK to keep "NONE" pure. // if (lstrcmpi(pszSchemeName, szNone) != 0) { SendMessage( ghwndSchemeCB, CB_ADDSTRING, 0, (LPARAM)pszSchemeName ); } } // // At this point, all of the user defined scheme names have been // added to the combo box. // RegCloseKey(hks); } // // Get name of current one. // // Reset again. // len = sizeof(pszDefaultSchemeName); RegQueryValue(hk, NULL, pszDefaultSchemeName, &len); // // Try to read the value of Scheme Source. If this value doesn't // exist, then we have a pre NT 5.0 implementation, so all schemes // will be user schemes. // len = sizeof(iSchemeLocation); if (RegQueryValueEx( hk, szSchemeSource, NULL, NULL, (unsigned char *)&iSchemeLocation, &len ) != ERROR_SUCCESS) { iSchemeLocation = ID_USER_SCHEME; } RegCloseKey(hk); } // // Now add the system defined pointer schemes. // if (RegOpenKey(HKEY_LOCAL_MACHINE, c_szRegPathSystemSchemes, &hk) == ERROR_SUCCESS) { DWORD i; for (i = 0; ;i++) { LONG ret; // // Reset each pass. // len = ARRAYSIZE(pszSchemeName); ret = RegEnumValue( hk, i, pszSchemeName, &len, NULL, NULL, NULL, NULL ); // // If the Scheme name is longer than the allowed length, skip it. // if (ret == ERROR_MORE_DATA) { continue; } // // If there's an error, then we're done. // if (ret != ERROR_SUCCESS) { break; } // // When we add the system identifier to the string, it could be // longer than MAX_SCHEME_NAME, however we only want to read // max length from the registry. // lstrcpy(pszLongName, pszSchemeName); lstrcat(pszLongName, szSystemScheme); SendMessage(ghwndSchemeCB, CB_ADDSTRING, 0, (LPARAM)pszLongName); } RegCloseKey(hk); } // // Add the "none" scheme. // SendMessage(ghwndSchemeCB, CB_INSERTSTRING, 0, (LPARAM)szNone); // // Try to find current one in the combobox. // lstrcpy(pszLongName, pszDefaultSchemeName); if (iSchemeLocation == ID_OS_SCHEME) { lstrcat(pszLongName, szSystemScheme); } index = (int)SendMessage( ghwndSchemeCB, CB_FINDSTRINGEXACT, 0xFFFF, (LPARAM)pszLongName ); // // If found, select it. // if (index < 0) // if we are on the None scheme { iSchemeLocation = ID_NONE_SCHEME; index = 0; } // We keep around a selection indicator so we know when selection has changed. // Initialize that value here. lstrcpy(gszPreviousScheme, pszLongName); SendMessage(ghwndSchemeCB, CB_SETCURSEL, (WPARAM)index, 0); EnableWindow( GetDlgItem(ghwndDlg, ID_REMOVESCHEME), (iSchemeLocation == ID_USER_SCHEME) ); return (TRUE); } //////////////////////////////////////////////////////////////////////////// // // SaveSchemeDlgProc // //////////////////////////////////////////////////////////////////////////// INT_PTR CALLBACK SaveSchemeDlgProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { TCHAR szSchemeName[MAX_SCHEME_SUFFIX + MAX_SCHEME_NAME_LEN + 1]; switch (message) { case ( WM_INITDIALOG ) : { HourGlass(TRUE); GetWindowText(ghwndSchemeCB, szSchemeName, ARRAYSIZE(szSchemeName)); // // CANNOT SAVE "NONE" SCHEME. // if (lstrcmpi(szSchemeName, szNone) == 0) { *szSchemeName = 0; } iSchemeLocation = SystemOrUser(szSchemeName); SetDlgItemText(hWnd, ID_SCHEMEFILENAME, szSchemeName); SendDlgItemMessage(hWnd, ID_SCHEMEFILENAME, EM_SETSEL, 0, 32767); SendDlgItemMessage( hWnd, ID_SCHEMEFILENAME, EM_LIMITTEXT, MAX_SCHEME_NAME_LEN, 0L ); EnableWindow(GetDlgItem(hWnd, IDOK), szSchemeName[0] != TEXT('\0')); HourGlass(FALSE); return (TRUE); } case ( WM_HELP ) : { WinHelp( (HWND)((LPHELPINFO)lParam)->hItemHandle, HELP_FILE, HELP_WM_HELP, (DWORD_PTR)(LPTSTR)aHelpIDs ); return (TRUE); } case ( WM_CONTEXTMENU ) : { WinHelp( (HWND)wParam, HELP_FILE, HELP_CONTEXTMENU, (DWORD_PTR)(LPVOID)aHelpIDs ); return (TRUE); } case ( WM_COMMAND ) : { switch (LOWORD(wParam)) { case ( ID_SCHEMEFILENAME ) : { if (HIWORD(wParam) == EN_CHANGE) { // // CANNOT SAVE "NONE" SCHEME // cannot save a scheme ending with szSystemScheme // EnableWindow( GetDlgItem(hWnd, IDOK), ((GetDlgItemText( hWnd, ID_SCHEMEFILENAME, szSchemeName, ARRAYSIZE(szSchemeName) ) > 0) && (lstrcmpi(szSchemeName, szNone) != 0) && (SystemOrUser(szSchemeName) != ID_OS_SCHEME)) ); } break; } case ( IDOK ) : { GetDlgItemText( hWnd, ID_SCHEMEFILENAME, szSchemeName, MAX_SCHEME_NAME_LEN + 1 ); CurStripBlanks(szSchemeName); if (*szSchemeName == TEXT('\0')) { MessageBeep(0); break; } lstrcpy(gszSchemeName, szSchemeName); // fall through... } case ( IDCANCEL ) : { EndDialog(hWnd, LOWORD(wParam) == IDOK); return (TRUE); } } } } // // Didn't process a message. // return (FALSE); } //////////////////////////////////////////////////////////////////////////// // // MakeFilename // // Returns Filename with a default path in system directory if no path // is already specified. // //////////////////////////////////////////////////////////////////////////// LPTSTR MakeFilename( LPTSTR sz) { TCHAR szTemp[MAX_PATH]; ExpandEnvironmentStrings(sz, szTemp, MAX_PATH); if (szTemp[0] == TEXT('\\') || szTemp[1] == TEXT(':')) { lstrcpy(gszFileName2, szTemp); return (gszFileName2); } else { GetSystemDirectory(gszFileName2, ARRAYSIZE(gszFileName2)); lstrcat(gszFileName2, TEXT("\\")); lstrcat(gszFileName2, szTemp); return (gszFileName2); } } //////////////////////////////////////////////////////////////////////////// // // CurStripBlanks // // Strips leading and trailing blanks from a string. // Alters the memory where the string sits. // //////////////////////////////////////////////////////////////////////////// void CurStripBlanks(LPTSTR pszString) { LPTSTR pszPosn; // // Strip leading blanks. // pszPosn = pszString; while (*pszPosn == TEXT(' ')) { pszPosn++; } if (pszPosn != pszString) { lstrcpy(pszString, pszPosn); } // // Strip trailing blanks. // if ((pszPosn = pszString + lstrlen(pszString)) != pszString) { pszPosn = CharPrev(pszString, pszPosn); while (*pszPosn == TEXT(' ')) { pszPosn = CharPrev(pszString, pszPosn); } pszPosn = CharNext(pszPosn); *pszPosn = TEXT('\0'); } } //////////////////////////////////////////////////////////////////////////// // // SystemOrUser // // Attempts to determine if the scheme name selected from the combo // box ends with the string szSystemScheme and retuns ID_OS_SCHEME // if it does, ID_USER_SCHEME if it doesn't. // //////////////////////////////////////////////////////////////////////////// int SystemOrUser(TCHAR *pszSchemeName) { TCHAR *pszSN; int lenSS, lenSN; int i; lenSS = lstrlen(szSystemScheme); lenSN = lstrlen(pszSchemeName); if (lenSN <= lenSS) { return (ID_USER_SCHEME); } pszSN = pszSchemeName + (lenSN - lenSS); // // If these strings are different, it's a user scheme. // if (lstrcmpi(pszSN, szSystemScheme)) { return (ID_USER_SCHEME); } // // For system schemes, this function also removes the // szSystemScheme string from the end. // *pszSN = TEXT('\0'); return (ID_OS_SCHEME); }