//////////////////////////////////////////////////////////////////////////////// // // propdlg.c // // The Properties dialog for MS Office. // // Change history: // // Date Who What // -------------------------------------------------------------------------- // 06/09/94 B. Wentz Created file // 01/16/95 martinth Finished sticky dlg stuff. // We have to call ApplyStickyDlgCoor // in the first WM_INITDIALOG, don't ask me why, // but otherwise we have redraw problems. Likewise, // we have to call SetStickyDlgCoor in the first // PSN_RESET/PSN_APPLY, I have no idea why, since // the main dialog shouldn't have been deleted but // it is. Thus we have to add calls everywhere. // Could it be that the tabs are getting deleted // one by one and the dialog changes size? Dunno. // But this works, so change at your own risk!;-) // 07/08/96 MikeHill Ignore unsupported (non-UDTYPE) properties. //////////////////////////////////////////////////////////////////////////////// #include "priv.h" #pragma hdrstop #include #include #include #include #include #include "propdlg.h" #include "strings.h" #include "msohelp.h" // Max size of time/date string #define TIMEDATEMAX 256 // Check button actions #define CLEAR 0 #define CHECKED 1 #define GREYED 2 // Number of property sheet pages #define PAGESMAX 5 // Max size for "short" temp buffers #define SHORTBUFMAX 128 // The pages #ifdef _ABBREVIATED_DOCPROP_ #define itabCUSTOM 0 #define itabFIRST itabCUSTOM #else //_ABBREVIATED_DOCPROP_ #define itabGENERAL 0 #define itabSUMMARY 1 #define itabSTATISTICS 2 #define itabCONTENTS 3 #define itabCUSTOM 4 #define itabFIRST itabSUMMARY #endif //_ABBREVIATED_DOCPROP_ // Defines for printing file sizes #define DELIMITER TEXT(',') #define iszBYTES 0 #define iszORDERKB 1 #define iszORDERMB 2 #define iszORDERGB 3 #define iszORDERTB 4 static TCHAR rgszOrders[iszORDERTB+1][SHORTBUFMAX]; // "bytes", // iszBYTES // "KB", // iszORDERKB // "MB", // iszORDERMB // "GB", // iszORDERGB // "TB" // iszORDERTB // note that szBYTES is defined above... #define iszPAGES 1 #define iszPARA 2 #define iszLINES 3 #define iszWORDS 4 #define iszCHARS 5 #define iszSLIDES 6 #define iszNOTES 7 #define iszHIDDENSLIDES 8 #define iszMMCLIPS 9 #define iszFORMAT 10 // Strings for the statistics listbox static TCHAR rgszStats[iszFORMAT+1][SHORTBUFMAX]; // "Bytes:", // iszBYTES // "Pages:", // iszPAGES // "Paragraphs:", // iszPARA // "Lines:", // iszLINES // "Words:", // iszWORDS // "Characters:", // iszCHARS // "Slides:", // iszSLIDES // "Notes:", // iszNOTES // "Hidden Slides:", // iszHIDDENSLIDES // "Multimedia Clips:", // iszMMCLIPS // "Presentation Format:"// iszFORMAT #define BASE10 10 // Number of pre-defined custom names #define NUM_BUILTIN_CUSTOM_NAMES 27 #define iszTEXT 0 #define iszDATE 1 #define iszNUM 2 #define iszBOOL 3 #define iszUNKNOWN 4 // Strings for the types of user-defined properties static TCHAR rgszTypes[iszUNKNOWN+1][SHORTBUFMAX]; // "Text", // iszTEXT // "Date", // iszDATE // "Number", // iszNUM // "Yes or No", // iszBOOL // "Unknown" // iszUNKNOWN #define iszNAME 0 #define iszVAL 1 #define iszTYPE 2 // Strings for the column headings for the statistics tab static TCHAR rgszStatHeadings[iszVAL+1][SHORTBUFMAX]; // "Statistic Name", // iszNAME // "Value" // iszVAL // Strings for the column headings for custom tab static TCHAR rgszHeadings[iszTYPE+1][SHORTBUFMAX]; // "Property Name", // iszNAME // "Value", // iszVAL // "Type" // iszTYPE #define iszTRUE 0 #define iszFALSE 1 // Strings for Booleans static TCHAR rgszBOOL[iszFALSE+1][SHORTBUFMAX]; // "Yes", // iszTRUE // "No" // iszFALSE #define iszADD 0 #define iszMODIFY 1 // Strings for the Add button static TCHAR rgszAdd[iszMODIFY+1][SHORTBUFMAX]; // "Add", // iszADD // "Modify" // iszMODIFY #define iszVALUE 0 #define iszSOURCE 1 // Strings for the source/value caption static TCHAR rgszValue[iszSOURCE+1][SHORTBUFMAX]; // "Value:", // iszVALUE // "Source:" // iszSOURCE // Date formatting codes #define MMDDYY TEXT('0') #define DDMMYY TEXT('1') #define YYMMDD TEXT('2') #define OLEEPOCH 1900 #define SYSEPOCH 1601 #define ONECENTURY 100 #define YEARINCENTURY(year) ((year) % ONECENTURY) #define CENTURYFROMYEAR(year) ((year) - YEARINCENTURY(year)) // // Global data, to be deleted when FShowOfficePropDlg exits // static LPTSTR glpstzName; static LPTSTR glpstzValue; static int giLinkIcon; static int giInvLinkIcon; static int giBlankIcon; static HBRUSH hBrushPropDlg = NULL; const TCHAR g_szHelpFile[] = TEXT("windows.hlp"); // // Internal prototypes // INT_PTR CALLBACK FGeneralDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam); INT_PTR CALLBACK FSummaryDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam); INT_PTR CALLBACK FStatisticsDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam); INT_PTR CALLBACK FCustomDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam); INT_PTR CALLBACK FContentsDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam); INT_PTR CALLBACK FPropHeaderDlgProc (HWND hwnd, UINT message, LONG lParam); //static int CALLBACK ListViewCompareFunc(LPARAM, LPARAM, LPARAM); void PASCAL SetEditValLpsz (LPPROPVARIANT lppropvar, HWND hdlg, DWORD dwID ); BOOL PASCAL GetEditValLpsz (LPPROPVARIANT lppropvar, HWND hDlg, DWORD dwId); BOOL PASCAL FAllocAndGetValLpstz (HWND hDlg, DWORD dwId, LPTSTR *lplpstz); BOOL PASCAL FAllocString (LPTSTR *lplpstz, DWORD cb); void PASCAL ClearEditControl (HWND hDlg, DWORD dwId); UDTYPES PASCAL UdtypesGetNumberType (LPTSTR lpstz, NUM *lpnumval, BOOL (*lpfnFSzToNum)(NUM *, LPTSTR)); void PASCAL PrintTimeInDlg (HWND hDlg, DWORD dwId, FILETIME *pft); void PASCAL PrintEditTimeInDlg (HWND hDlg, FILETIME *pft); void PASCAL AddItemToListView (HWND hWnd, DWORD_PTR dw, const TCHAR *lpsz, BOOL fString); void PASCAL PopulateUDListView (HWND hWnd, LPUDOBJ lpUDObj); void PASCAL AddUDPropToListView (LPUDOBJ lpUDObj, HWND hWnd, LPTSTR lpszName, LPPROPVARIANT lppropvar, int iItem, BOOL fLink, BOOL fLinkInvalid, BOOL fMakeVisible); VOID PASCAL InitListView (HWND hDlg, int irgLast, TCHAR rgsz[][SHORTBUFMAX], BOOL fImageList); WORD PASCAL WUdtypeToSz (LPPROPVARIANT lppropvar, LPTSTR sz, DWORD cchMax, BOOL (*lpfnFNumToSz)(NUM *, LPTSTR, DWORD)); BOOL PASCAL FSwapControls (HWND hWndVal, HWND hWndLinkVal, HWND hWndBoolTrue, HWND hWndBoolFalse, HWND hWndGroup, HWND hWndType, HWND hWndValText, BOOL fLink, BOOL fBool); VOID PASCAL PopulateControls (LPUDOBJ lpUDObj, LPTSTR szName, DWORD cLinks, DWQUERYLD lpfnDwQueryLinkData, HWND hDlg, HWND hWndName, HWND hWndVal, HWND hWndValText, HWND hWndLink, HWND hWndLinkVal, HWND hWndType, HWND hWndBoolTrue, HWND hWndBoolFalse, HWND hWndGroup, HWND hWndAdd, HWND hWndDelete, BOOL *pfLink, BOOL *pfAdd); BOOL PASCAL FSetupAddButton (DWORD iszType, BOOL fLink, BOOL *pfAdd, HWND hWndAdd, HWND hWndVal, HWND hWndName, HWND hDlg); BOOL PASCAL FCreateListOfLinks (DWORD cLinks, DWQUERYLD lpfnDwQueryLinkData, HWND hWndLinkVal); BOOL PASCAL FSetTypeControl (UDTYPES udtype, HWND hWndType); void PASCAL DeleteItem (LPUDOBJ lpUDObj, HWND hWndLV, int iItem, TCHAR sz[]); void PASCAL ResetTypeControl (HWND hDlg, DWORD dwId, DWORD *piszType); BOOL PASCAL FDisplayConversionWarning (HWND hDlg); BOOL PASCAL FLoadTextStrings (void); BOOL FGetCustomPropFromDlg(LPALLOBJS lpallobjs, HWND hDlg); VOID SetCustomDlgDefButton(HWND hDlg, int IDNew); INT PASCAL ISavePropDlgChanges(LPALLOBJS, HWND, HWND); /* WinHelp stuff. */ static const DWORD rgIdhGeneral[] = { IDD_ITEMICON, IDH_GENERAL_ICON, IDD_NAME, IDH_GENERAL_NAME_BY_ICON, IDD_FILETYPE, IDH_GENERAL_FILETYPE, IDD_FILETYPE_LABEL, IDH_GENERAL_FILETYPE, IDD_LOCATION, IDH_GENERAL_LOCATION, IDD_LOCATION_LABEL, IDH_GENERAL_LOCATION, IDD_FILESIZE, IDH_GENERAL_FILESIZE, IDD_FILESIZE_LABEL, IDH_GENERAL_FILESIZE, IDD_FILENAME, IDH_GENERAL_MSDOSNAME, IDD_FILENAME_LABEL, IDH_GENERAL_MSDOSNAME, IDD_CREATED, IDH_GENERAL_CREATED, IDD_CREATED_LABEL, IDH_GENERAL_CREATED, IDD_LASTMODIFIED, IDH_GENERAL_MODIFIED, IDD_LASTMODIFIED_LABEL, IDH_GENERAL_MODIFIED, IDD_LASTACCESSED, IDH_GENERAL_ACCESSED, IDD_LASTACCESSED_LABEL, IDH_GENERAL_ACCESSED, IDD_ATTRIBUTES_LABEL, IDH_GENERAL_ATTRIBUTES, IDD_READONLY, IDH_GENERAL_READONLY, IDD_HIDDEN, IDH_GENERAL_HIDDEN, IDD_ARCHIVE, IDH_GENERAL_ARCHIVE, IDD_SYSTEM, IDH_GENERAL_SYSTEM }; static const DWORD rgIdhSummary[] = { IDD_SUMMARY_TITLE, IDH_SUMMARY_TITLE, IDD_SUMMARY_TITLE_LABEL, IDH_SUMMARY_TITLE, IDD_SUMMARY_SUBJECT, IDH_SUMMARY_SUBJECT, IDD_SUMMARY_SUBJECT_LABEL, IDH_SUMMARY_SUBJECT, IDD_SUMMARY_AUTHOR, IDH_SUMMARY_AUTHOR, IDD_SUMMARY_AUTHOR_LABEL, IDH_SUMMARY_AUTHOR, IDD_SUMMARY_MANAGER, IDH_SUMMARY_MANAGER, IDD_SUMMARY_MANAGER_LABEL, IDH_SUMMARY_MANAGER, IDD_SUMMARY_COMPANY, IDH_SUMMARY_COMPANY, IDD_SUMMARY_COMPANY_LABEL, IDH_SUMMARY_COMPANY, IDD_SUMMARY_CATEGORY, IDH_SUMMARY_CATEGORY, IDD_SUMMARY_CATEGORY_LABEL, IDH_SUMMARY_CATEGORY, IDD_SUMMARY_KEYWORDS, IDH_SUMMARY_KEYWORDS, IDD_SUMMARY_KEYWORDS_LABEL, IDH_SUMMARY_KEYWORDS, IDD_SUMMARY_COMMENTS, IDH_SUMMARY_COMMENTS, IDD_SUMMARY_COMMENTS_LABEL, IDH_SUMMARY_COMMENTS, IDD_SUMMARY_TEMPLATE, IDH_SUMMARY_TEMPLATE, IDD_SUMMARY_TEMPLATETEXT, IDH_SUMMARY_TEMPLATE, IDD_SUMMARY_SAVEPREVIEW, IDH_SUMMARY_SAVEPREVIEW }; static const DWORD rgIdhStatistics[] = { IDD_STATISTICS_CREATED, IDH_STATISTICS_CREATED, IDD_STATISTICS_CREATED_LABEL, IDH_STATISTICS_CREATED, IDD_STATISTICS_CHANGED, IDH_STATISTICS_MODIFIED, IDD_STATISTICS_CHANGED_LABEL, IDH_STATISTICS_MODIFIED, IDD_STATISTICS_ACCESSED, IDH_STATISTICS_ACCESSED, IDD_STATISTICS_ACCESSED_LABEL, IDH_STATISTICS_ACCESSED, IDD_STATISTICS_LASTPRINT, IDH_STATISTICS_LASTPRINT, IDD_STATISTICS_LASTPRINT_LABEL, IDH_STATISTICS_LASTPRINT, IDD_STATISTICS_LASTSAVEBY, IDH_STATISTICS_LASTSAVEBY, IDD_STATISTICS_LASTSAVEBY_LABEL, IDH_STATISTICS_LASTSAVEBY, IDD_STATISTICS_REVISION, IDH_STATISTICS_REVISION, IDD_STATISTICS_REVISION_LABEL, IDH_STATISTICS_REVISION, IDD_STATISTICS_TOTALEDIT, IDH_STATISTICS_TOTALEDIT, IDD_STATISTICS_TOTALEDIT_LABEL, IDH_STATISTICS_TOTALEDIT, IDD_STATISTICS_LVLABEL, IDH_STATISTICS_LISTVIEW, IDD_STATISTICS_LISTVIEW, IDH_STATISTICS_LISTVIEW }; static const DWORD rgIdhContents[] = { IDD_CONTENTS_LISTBOX_LABEL, IDH_CONTENTS_LISTBOX, IDD_CONTENTS_LISTBOX, IDH_CONTENTS_LISTBOX }; static const DWORD rgIdhCustom[] = { IDD_CUSTOM_NAME, IDH_CUSTOM_NAME, IDD_CUSTOM_NAME_LABEL, IDH_CUSTOM_NAME, IDD_CUSTOM_TYPE, IDH_CUSTOM_TYPE, IDD_CUSTOM_TYPE_LABEL, IDH_CUSTOM_TYPE, IDD_CUSTOM_VALUE, IDH_CUSTOM_VALUE, IDD_CUSTOM_VALUETEXT, IDH_CUSTOM_VALUE, IDD_CUSTOM_LINKVALUE, IDH_CUSTOM_LINKVALUE, IDD_CUSTOM_BOOLTRUE, IDH_CUSTOM_BOOLYES, IDD_CUSTOM_BOOLFALSE, IDH_CUSTOM_BOOLYES, IDD_CUSTOM_ADD, IDH_CUSTOM_ADDBUTTON, IDD_CUSTOM_DELETE, IDH_CUSTOM_DELETEBUTTON, IDD_CUSTOM_LINK, IDH_CUSTOM_LINKCHECK, IDD_CUSTOM_LISTVIEW, IDH_CUSTOM_LISTVIEW, IDD_CUSTOM_LISTVIEW_LABEL, IDH_CUSTOM_LISTVIEW }; void FOfficeInitPropInfo(PROPSHEETPAGE * lpPsp, DWORD dwFlags, LPARAM lParam, LPFNPSPCALLBACK pfnCallback) { #ifndef _ABBREVIATED_DOCPROP_ lpPsp[itabSUMMARY-itabFIRST].dwSize = sizeof(PROPSHEETPAGE); lpPsp[itabSUMMARY-itabFIRST].dwFlags = dwFlags; lpPsp[itabSUMMARY-itabFIRST].hInstance = g_hmodThisDll; lpPsp[itabSUMMARY-itabFIRST].pszTemplate = MAKEINTRESOURCE (IDD_SUMMARY); lpPsp[itabSUMMARY-itabFIRST].pszIcon = NULL; lpPsp[itabSUMMARY-itabFIRST].pszTitle = NULL; lpPsp[itabSUMMARY-itabFIRST].pfnDlgProc = FSummaryDlgProc; lpPsp[itabSUMMARY-itabFIRST].pfnCallback = pfnCallback; lpPsp[itabSUMMARY-itabFIRST].pcRefParent = NULL; lpPsp[itabSUMMARY-itabFIRST].lParam = lParam; lpPsp[itabSTATISTICS-itabFIRST].dwSize = sizeof(PROPSHEETPAGE); lpPsp[itabSTATISTICS-itabFIRST].dwFlags = dwFlags; lpPsp[itabSTATISTICS-itabFIRST].hInstance = g_hmodThisDll; lpPsp[itabSTATISTICS-itabFIRST].pszTemplate = MAKEINTRESOURCE (IDD_STATISTICS); lpPsp[itabSTATISTICS-itabFIRST].pszIcon = NULL; lpPsp[itabSTATISTICS-itabFIRST].pszTitle = NULL; lpPsp[itabSTATISTICS-itabFIRST].pfnDlgProc = FStatisticsDlgProc; lpPsp[itabSTATISTICS-itabFIRST].pfnCallback = pfnCallback; lpPsp[itabSTATISTICS-itabFIRST].pcRefParent = NULL; lpPsp[itabSTATISTICS-itabFIRST].lParam = lParam; lpPsp[itabCONTENTS-itabFIRST].dwSize = sizeof(PROPSHEETPAGE); lpPsp[itabCONTENTS-itabFIRST].dwFlags = dwFlags; lpPsp[itabCONTENTS-itabFIRST].hInstance = g_hmodThisDll; lpPsp[itabCONTENTS-itabFIRST].pszTemplate = MAKEINTRESOURCE (IDD_CONTENTS); lpPsp[itabCONTENTS-itabFIRST].pszIcon = NULL; lpPsp[itabCONTENTS-itabFIRST].pszTitle = NULL; lpPsp[itabCONTENTS-itabFIRST].pfnDlgProc = FContentsDlgProc; lpPsp[itabCONTENTS-itabFIRST].pfnCallback = pfnCallback; lpPsp[itabCONTENTS-itabFIRST].pcRefParent = NULL; lpPsp[itabCONTENTS-itabFIRST].lParam = lParam; #endif // _ABBREVIATED_DOCPROP_ lpPsp[itabCUSTOM-itabFIRST].dwSize = sizeof(PROPSHEETPAGE); lpPsp[itabCUSTOM-itabFIRST].dwFlags = dwFlags; lpPsp[itabCUSTOM-itabFIRST].hInstance = g_hmodThisDll; lpPsp[itabCUSTOM-itabFIRST].pszTemplate = MAKEINTRESOURCE (IDD_CUSTOM); lpPsp[itabCUSTOM-itabFIRST].pszIcon = NULL; lpPsp[itabCUSTOM-itabFIRST].pszTitle = NULL; lpPsp[itabCUSTOM-itabFIRST].pfnDlgProc = FCustomDlgProc; lpPsp[itabCUSTOM-itabFIRST].pfnCallback = pfnCallback; lpPsp[itabCUSTOM-itabFIRST].pcRefParent = NULL; lpPsp[itabCUSTOM-itabFIRST].lParam = lParam; } //////////////////////////////////////////////////////////////////////////////// // // Attach // // Purpose: // Assigns HPROPSHEETPAGE to appropriate data block member. // //////////////////////////////////////////////////////////////////////////////// BOOL FAttach( LPALLOBJS lpallobjs, PROPSHEETPAGE* ppsp, HPROPSHEETPAGE hPage ) { #define ASSIGN_PAGE_HANDLE( pfn, phpage ) \ if( ppsp->pfnDlgProc == pfn ) { *(phpage) = hPage ; return TRUE ; } #if _ABBREVIATED_DOCPROP_ ASSIGN_PAGE_HANDLE( FCustomDlgProc, &lpallobjs->lpUDObj->m_hPage ); #else // _ABBREVIATED_DOCPROP_ ASSIGN_PAGE_HANDLE( FSummaryDlgProc, &lpallobjs->lpSIObj->m_hPage ); ASSIGN_PAGE_HANDLE( FStatisticsDlgProc, &lpallobjs->lpDSIObj->m_hPage ); ASSIGN_PAGE_HANDLE( FCustomDlgProc, &lpallobjs->lpUDObj->m_hPage ); #endif // _ABBREVIATED_DOCPROP_ return FALSE; } //////////////////////////////////////////////////////////////////////////////// // // PropPageInit // // Purpose: // Keep track which pages have been init, such that we can know when we // can do the apply. // //////////////////////////////////////////////////////////////////////////////// void PropPageInit(LPALLOBJS lpallobjs, int iPage) { if (iPage > lpallobjs->iMaxPageInit) lpallobjs->iMaxPageInit = iPage; } //////////////////////////////////////////////////////////////////////////////// // // ApplyChangesBackToFile // // Purpose: // See if this is now the time to apply the changes back to the file // //////////////////////////////////////////////////////////////////////////////// BOOL ApplyChangesBackToFile( HWND hDlg, BOOL bFinalEdit /* user clicked OK rather than Apply*/, LPALLOBJS lpallobjs, int iPage) { HRESULT hres; BOOL fOK = FALSE; LPSTORAGE lpStg; WCHAR wszPath[ MAX_PATH ]; if (iPage != lpallobjs->iMaxPageInit) return TRUE; // no errors #ifdef UNICODE lstrcpyn(wszPath, lpallobjs->szPath, ARRAYSIZE(wszPath)); #else MultiByteToWideChar(CP_ACP, 0, lpallobjs->szPath, -1, wszPath, ARRAYSIZE(wszPath)); #endif #ifdef WINNT hres = StgOpenStorageEx(wszPath,STGM_READWRITE|STGM_SHARE_EXCLUSIVE,STGFMT_ANY,0,NULL,NULL, &IID_IStorage, (void**)&lpStg ); #else hres = StgOpenStorage(wszPath, NULL, STGM_READWRITE|STGM_SHARE_EXCLUSIVE, NULL, 0L, &lpStg ); #endif if (SUCCEEDED(hres) && lpStg) { MESSAGE(TEXT("Now trying to save out properties")); fOK = (BOOL)DwOfficeSaveProperties( lpStg, lpallobjs->lpSIObj, lpallobjs->lpDSIObj, lpallobjs->lpUDObj, 0, // Flags STGM_READWRITE | STGM_SHARE_EXCLUSIVE ); // Release the Storage (we don't need to commit it; // it's in dicrect-mode). lpStg->lpVtbl->Release (lpStg); lpStg= NULL; // // if we did properly save out the properties, than we should // clear the we have changed things flag... // if (fOK) { lpallobjs->fPropDlgChanged = FALSE; lpallobjs->fPropDlgPrompted = FALSE; } } // if (SUCCEEDED(hres) && lpStorage) if (!fOK) { UINT nMsgFlags = bFinalEdit ? MB_OKCANCEL /* give option to not dismiss page*/ : MB_OK; if (ShellMessageBox(g_hmodThisDll, GetParent(hDlg), MAKEINTRESOURCE(idsErrorOnSave), NULL, nMsgFlags | MB_ICONHAND, PathFindFileName(lpallobjs->szPath)) == IDOK) { fOK = TRUE; } PropSheet_UnChanged(GetParent(hDlg), hDlg); } return fOK; } // ApplyChangesBackToFile //////////////////////////////////////////////////////////////////////////////// // // FSummaryDlgProc // // Purpose: // Summary window dialog handler. // //////////////////////////////////////////////////////////////////////////////// #ifndef _ABBREVIATED_DOCPROP_ INT_PTR CALLBACK FSummaryDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) { DWORD dwMask; DWORD dwT; LPALLOBJS lpallobjs = (LPALLOBJS)GetWindowLongPtr(hDlg, DWLP_USER); switch (message) { case WM_INITDIALOG : { PROPSHEETPAGE *ppspDlg = (PROPSHEETPAGE *) lParam; LPSIOBJ lpSIObj; // All SumInfo data LPDSIOBJ lpDSIObj; // All DocSumInfo (first section) LPPROPVARIANT rgpropvarSumInfo, rgpropvarDocSumInfo; lpallobjs = (LPALLOBJS)ppspDlg->lParam; PropPageInit(lpallobjs, itabSUMMARY); SetWindowLongPtr(hDlg, DWLP_USER, ppspDlg->lParam); lpSIObj = lpallobjs->lpSIObj; lpDSIObj = lpallobjs->lpDSIObj; dwMask = lpallobjs->dwMask; // // Validate our data. // if ((lpSIObj == NULL) || (lpSIObj->m_lpData == NULL) || (lpDSIObj == NULL) || (lpDSIObj->m_lpData == NULL)) { AssertSz (0, TEXT("Bad object data in Summary dlg")); return FALSE; } // // Since we'll be referencing the PropVariants a lot, get // a pointer directly to them. // rgpropvarSumInfo = GETSINFO(lpSIObj)->rgpropvar; rgpropvarDocSumInfo = GETSINFO(lpDSIObj)->rgpropvar; // // Copy the properties from the PropVariants to the Edit controls. // SetEditValLpsz (&rgpropvarSumInfo[ PVSI_TITLE ], hDlg, IDD_SUMMARY_TITLE); SetEditValLpsz (&rgpropvarSumInfo[ PVSI_SUBJECT ], hDlg, IDD_SUMMARY_SUBJECT); SetEditValLpsz (&rgpropvarSumInfo[ PVSI_AUTHOR ], hDlg, IDD_SUMMARY_AUTHOR); SetEditValLpsz (&rgpropvarSumInfo[ PVSI_COMMENTS ], hDlg, IDD_SUMMARY_COMMENTS); SetEditValLpsz (&rgpropvarSumInfo[ PVSI_KEYWORDS ], hDlg, IDD_SUMMARY_KEYWORDS); // // Show the name of the template, if it exists, otherwise // don't even show the field. // if (rgpropvarSumInfo[ PVSI_TEMPLATE ].vt == VT_LPTSTR) { SetEditValLpsz (&rgpropvarSumInfo[ PVSI_TEMPLATE ], hDlg, IDD_SUMMARY_TEMPLATE); } else { EnableWindow (GetDlgItem (hDlg, IDD_SUMMARY_TEMPLATETEXT), SW_HIDE); } SetEditValLpsz (&rgpropvarDocSumInfo[ PVDSI_CATEGORY ], hDlg, IDD_SUMMARY_CATEGORY); SetEditValLpsz (&rgpropvarDocSumInfo[ PVDSI_COMPANY ], hDlg, IDD_SUMMARY_COMPANY); SetEditValLpsz (&rgpropvarDocSumInfo[ PVDSI_MANAGER ], hDlg, IDD_SUMMARY_MANAGER); SetEditValLpsz (&rgpropvarSumInfo[ PVSI_COMMENTS ], hDlg, IDD_SUMMARY_COMMENTS); if (dwMask & OSPD_NOSAVEPREVIEW) { ShowWindow(GetDlgItem(hDlg, IDD_SUMMARY_SAVEPREVIEW), SW_HIDE); } else { if (!GETSINFO(lpSIObj)->fSaveSINail) GETSINFO(lpSIObj)->fSaveSINail = (dwMask & OSPD_SAVEPREVIEW_ON); #ifdef SHELL if (!GETSINFO(lpSIObj)->fSaveSINail) EnableWindow (GetDlgItem (hDlg, IDD_SUMMARY_SAVEPREVIEW), FALSE); else #endif SendDlgItemMessage(hDlg, IDD_SUMMARY_SAVEPREVIEW, BM_SETCHECK, (WPARAM) GETSINFO(lpSIObj)->fSaveSINail,0); } lpallobjs->fPropDlgChanged = FALSE; // It might have been set by the EN_UPDATE check, so let's reset it here } return TRUE; case WM_CTLCOLOREDIT : if ((HWND)lParam != GetDlgItem(hDlg, IDD_SUMMARY_TEMPLATE)) // only change color for the break; // the template case WM_CTLCOLORDLG : case WM_CTLCOLORSTATIC : if (hBrushPropDlg == NULL) break; DeleteObject(hBrushPropDlg); if ((hBrushPropDlg = CreateSolidBrush(GetSysColor(COLOR_BTNFACE))) == NULL) break; SetBkColor ((HDC) wParam, GetSysColor (COLOR_BTNFACE)); SetTextColor((HDC) wParam, GetSysColor(COLOR_WINDOWTEXT)); return (INT_PTR) hBrushPropDlg; case WM_COMMAND: { BOOL fNailChanged = FALSE; AssertSz( (lpallobjs != NULL && lpallobjs->lpSIObj != NULL), TEXT("Invalid global structure in WM_COMMAND" )); if ((HIWORD (wParam) == BN_CLICKED) && (LOWORD(wParam) == IDD_SUMMARY_SAVEPREVIEW)) { GETSINFO(lpallobjs->lpSIObj)->fSaveSINail = !GETSINFO(lpallobjs->lpSIObj)->fSaveSINail; OfficeDirtySIObj (lpallobjs->lpSIObj, TRUE); fNailChanged = TRUE; } if (HIWORD (wParam) == EN_UPDATE || fNailChanged) { lpallobjs->fPropDlgChanged = TRUE; PropSheet_Changed(GetParent(hDlg), hDlg); } break; } case WM_NOTIFY : switch (((NMHDR FAR *) lParam)->code) { case PSN_APPLY : // // Save what user entered. // { LPSIOBJ lpSIObj; // All SumInfo data LPDSIOBJ lpDSIObj; // All DocSumInfo data BOOL fSIChanged = FALSE; // The SumInfo properties have changed BOOL fDSIChanged = FALSE; // The DocSumInfo properties have changed // SumInfo and DocSumInfo properties. LPPROPVARIANT rgpropvarSumInfo, rgpropvarDocSumInfo; lpSIObj = lpallobjs->lpSIObj; rgpropvarSumInfo = GETSINFO(lpSIObj)->rgpropvar; lpDSIObj = lpallobjs->lpDSIObj; rgpropvarDocSumInfo = GETDSINFO(lpDSIObj)->rgpropvar; fSIChanged |= GetEditValLpsz (&rgpropvarSumInfo[PVSI_TITLE], hDlg, IDD_SUMMARY_TITLE); fSIChanged |= GetEditValLpsz (&rgpropvarSumInfo[PVSI_SUBJECT], hDlg, IDD_SUMMARY_SUBJECT); fSIChanged |= GetEditValLpsz (&rgpropvarSumInfo[PVSI_AUTHOR], hDlg, IDD_SUMMARY_AUTHOR); fSIChanged |= GetEditValLpsz (&rgpropvarSumInfo[PVSI_COMMENTS], hDlg, IDD_SUMMARY_COMMENTS); fSIChanged |= GetEditValLpsz (&rgpropvarSumInfo[PVSI_KEYWORDS], hDlg, IDD_SUMMARY_KEYWORDS); fSIChanged |= GetEditValLpsz (&rgpropvarSumInfo[PVSI_TEMPLATE], hDlg, IDD_SUMMARY_TEMPLATE); fDSIChanged |= GetEditValLpsz (&rgpropvarDocSumInfo[PVDSI_CATEGORY], hDlg, IDD_SUMMARY_CATEGORY); fDSIChanged |= GetEditValLpsz (&rgpropvarDocSumInfo[PVDSI_MANAGER], hDlg, IDD_SUMMARY_MANAGER); fDSIChanged |= GetEditValLpsz (&rgpropvarDocSumInfo[PVDSI_COMPANY], hDlg, IDD_SUMMARY_COMPANY); if (fSIChanged) { OfficeDirtySIObj (lpSIObj, TRUE); } if (fDSIChanged) { OfficeDirtyDSIObj (lpDSIObj, TRUE); } MESSAGE (TEXT("PSN_APPLY - Summary Page")); if (FSumInfoShouldSave (lpSIObj) || FDocSumShouldSave (lpDSIObj) || lpallobjs->fPropDlgChanged ) { ApplyChangesBackToFile(hDlg, (BOOL)((PSHNOTIFY*)lParam)->lParam, lpallobjs, itabSUMMARY); } } return TRUE; case PSN_QUERYCANCEL: if (lpallobjs->fPropDlgChanged && !lpallobjs->fPropDlgPrompted) ISavePropDlgChanges(lpallobjs, hDlg, ((NMHDR FAR *)lParam)->hwndFrom); return TRUE; case PSN_SETACTIVE : return TRUE; } // switch (WM_NOTIFY) break; case WM_CLOSE: // // This page contains multi-line edit controls, which swallow // the ESC key but generat a WM_CLOSE. We need to pass this // message on to our parent (the property sheet) so that it is // handled correctly... // PostMessage( GetParent(hDlg), WM_CLOSE, wParam, lParam ); break; case WM_CONTEXTMENU: WinHelp((HANDLE)wParam, NULL, HELP_CONTEXTMENU, (DWORD_PTR)rgIdhSummary); break; case WM_HELP: WinHelp(((LPHELPINFO)lParam)->hItemHandle, NULL, HELP_WM_HELP, (DWORD_PTR)rgIdhSummary); break; } // switch (message) return FALSE; } // FSummaryDlgProc #endif //_ABBREVIATED_DOCPROP_ //////////////////////////////////////////////////////////////////////////////// // // FStatisticsDlgProc // // Purpose; // Displays the Statistics dialog // //////////////////////////////////////////////////////////////////////////////// #ifndef _ABBREVIATED_DOCPROP_ INT_PTR CALLBACK FStatisticsDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) { HWND hWndLV; LPSIOBJ lpSIObj; // All SumInfo data. LPDSIOBJ lpDSIObj; // All DocSumInfo data. LPPROPVARIANT rgpropvarSumInfo, rgpropvarDocSumInfo; HANDLE hFile; FILETIME ftTime; DWORD dwT; BOOL fListData; // Did we stick some data in the listview?? switch (message) { case WM_INITDIALOG : { PROPSHEETPAGE *ppspDlg = (PROPSHEETPAGE *) lParam; LPALLOBJS lpallobjs = (LPALLOBJS)ppspDlg->lParam; // Page does not do apply so don't worry // PropPageInit(lpallobjs, itabSTATISTICS); lpSIObj = lpallobjs->lpSIObj; // Get the summary object. lpDSIObj = lpallobjs->lpDSIObj; // Get the doc sum. object. if (lpSIObj->m_lpData == NULL || lpDSIObj->m_lpData == NULL) { MESSAGE (TEXT("Invalid SumInfo or DocSumInfo object")); return FALSE; } rgpropvarSumInfo = GETSINFO(lpSIObj)->rgpropvar; rgpropvarDocSumInfo = GETSINFO(lpDSIObj)->rgpropvar; // Let the app update the stats if they provided a callback if (((LPSINFO) ((LPOFFICESUMINFO) lpSIObj)->m_lpData)->lpfnFUpdateStats != NULL) (*(((LPSINFO) ((LPOFFICESUMINFO) lpSIObj)->m_lpData)->lpfnFUpdateStats))( GetFocus(), lpSIObj, lpDSIObj); hWndLV = GetDlgItem(hDlg, IDD_STATISTICS_LISTVIEW); InitListView (hWndLV, iszVAL, rgszStatHeadings, FALSE); // Last saved by if (rgpropvarSumInfo[ PVSI_LASTAUTHOR ].vt == VT_LPTSTR) { SendDlgItemMessage (hDlg, IDD_STATISTICS_LASTSAVEBY, WM_SETTEXT, 0, (LPARAM) rgpropvarSumInfo[ PVSI_LASTAUTHOR ].pszVal); } // Revision # if (rgpropvarSumInfo[ PVSI_REVNUMBER ].vt == VT_LPTSTR) { SendDlgItemMessage (hDlg, IDD_STATISTICS_REVISION, WM_SETTEXT, 0, (LPARAM) rgpropvarSumInfo[ PVSI_REVNUMBER ].pszVal); } fListData = FALSE; if (rgpropvarSumInfo[ PVSI_PAGECOUNT ].vt == VT_I4) { AddItemToListView (hWndLV, rgpropvarSumInfo[ PVSI_PAGECOUNT ].lVal, rgszStats[iszPAGES], FALSE); fListData = TRUE; } if (rgpropvarDocSumInfo[ PVDSI_SLIDECOUNT ].vt == VT_I4) { AddItemToListView (hWndLV, rgpropvarDocSumInfo[ PVDSI_SLIDECOUNT ].lVal, rgszStats[iszSLIDES], FALSE); fListData = TRUE; } if (rgpropvarDocSumInfo[ PVDSI_PARACOUNT ].vt == VT_I4) { AddItemToListView (hWndLV, rgpropvarDocSumInfo[ PVDSI_PARACOUNT ].lVal, rgszStats[iszPARA], FALSE); fListData = TRUE; } if (rgpropvarDocSumInfo[ PVDSI_LINECOUNT ].vt == VT_I4) { AddItemToListView (hWndLV, rgpropvarDocSumInfo[ PVDSI_LINECOUNT ].lVal, rgszStats[iszLINES], FALSE); fListData = TRUE; } if (rgpropvarSumInfo[ PVSI_WORDCOUNT ].vt == VT_I4) { AddItemToListView (hWndLV, rgpropvarSumInfo[ PVSI_WORDCOUNT ].lVal, rgszStats[iszWORDS], FALSE); fListData = TRUE; } if (rgpropvarSumInfo[ PVSI_CHARCOUNT ].vt == VT_I4) { AddItemToListView (hWndLV, rgpropvarSumInfo[ PVSI_CHARCOUNT ].lVal, rgszStats[iszCHARS], FALSE); fListData = TRUE; } if (rgpropvarDocSumInfo[ PVDSI_BYTECOUNT ].vt == VT_I4) { AddItemToListView (hWndLV, rgpropvarDocSumInfo[ PVDSI_BYTECOUNT ].lVal, rgszStats[iszBYTES], FALSE); fListData = TRUE; } if (rgpropvarDocSumInfo[ PVDSI_NOTECOUNT ].vt == VT_I4) { AddItemToListView (hWndLV, rgpropvarDocSumInfo[ PVDSI_NOTECOUNT ].lVal, rgszStats[iszNOTES], FALSE); fListData = TRUE; } if (rgpropvarDocSumInfo[ PVDSI_HIDDENCOUNT ].vt == VT_I4) { AddItemToListView (hWndLV, rgpropvarDocSumInfo[ PVDSI_HIDDENCOUNT ].lVal, rgszStats[iszHIDDENSLIDES], FALSE); fListData = TRUE; } if (rgpropvarDocSumInfo[ PVDSI_MMCLIPCOUNT ].vt == VT_I4) { AddItemToListView (hWndLV, rgpropvarDocSumInfo[ PVDSI_MMCLIPCOUNT ].lVal, rgszStats[iszMMCLIPS], FALSE); fListData = TRUE; } if (rgpropvarDocSumInfo[ PVDSI_PRESFORMAT ].vt == VT_LPTSTR) { AddItemToListView (hWndLV, (DWORD_PTR) rgpropvarDocSumInfo[ PVDSI_PRESFORMAT ].pszVal, rgszStats[iszFORMAT], TRUE); fListData = TRUE; } if (!fListData) { ShowWindow(GetDlgItem(hDlg, IDD_LINE_2), SW_HIDE); ShowWindow(GetDlgItem(hDlg, IDD_STATISTICS_LVLABEL), SW_HIDE); ShowWindow(hWndLV, SW_HIDE); hWndLV = NULL; } if (!lpallobjs->fFiledataInit) { hFile = FindFirstFile(lpallobjs->szPath, &lpallobjs->filedata); lpallobjs->fFiledataInit = TRUE; if (hFile != INVALID_HANDLE_VALUE) { FindClose(hFile); lpallobjs->fFindFileSuccess = TRUE; } } if (lpallobjs->fFindFileSuccess) { // Last Access PrintTimeInDlg (hDlg, IDD_STATISTICS_ACCESSED, &(lpallobjs->filedata.ftLastAccessTime)); // Last modified PrintTimeInDlg (hDlg, IDD_STATISTICS_CHANGED, &(lpallobjs->filedata.ftLastWriteTime)); } // Create Time if (rgpropvarSumInfo[ PVSI_CREATE_DTM ].vt == VT_FILETIME) { PrintTimeInDlg(hDlg, IDD_STATISTICS_CREATED, &rgpropvarSumInfo[ PVSI_CREATE_DTM ].filetime); } // Last Printed Time if (rgpropvarSumInfo[ PVSI_LASTPRINTED ].vt == VT_FILETIME) { PrintTimeInDlg(hDlg, IDD_STATISTICS_LASTPRINT, &rgpropvarSumInfo[ PVSI_LASTPRINTED ].filetime); } // Total Edit Time // If we are not allowing time tracking display 0 minutes if (GETSINFO(lpSIObj)->fNoTimeTracking) { ftTime.dwLowDateTime = 0; ftTime.dwHighDateTime = 0; PrintEditTimeInDlg(hDlg, &ftTime); } else if (rgpropvarSumInfo[ PVSI_EDITTIME ].vt == VT_FILETIME) { PrintEditTimeInDlg(hDlg, &rgpropvarSumInfo[ PVSI_EDITTIME ].filetime); } // lpallobjs->fPropDlgChanged = FALSE; } return TRUE; case WM_CTLCOLORBTN : case WM_CTLCOLOREDIT : case WM_CTLCOLORDLG : case WM_CTLCOLORSTATIC : if (hBrushPropDlg == NULL) break; DeleteObject(hBrushPropDlg); if ((hBrushPropDlg = CreateSolidBrush(GetSysColor(COLOR_BTNFACE))) == NULL) break; SetBkColor ((HDC) wParam, GetSysColor (COLOR_BTNFACE)); SetTextColor((HDC) wParam, GetSysColor(COLOR_WINDOWTEXT)); return (INT_PTR) hBrushPropDlg; case WM_SYSCOLORCHANGE: hWndLV = GetDlgItem(hDlg, IDD_STATISTICS_LISTVIEW); PostMessage(hWndLV, WM_SYSCOLORCHANGE, wParam, lParam); return TRUE; break; case WM_NOTIFY : switch (((NMHDR FAR *) lParam)->code) { case PSN_SETACTIVE : return TRUE; case PSN_RESET: case PSN_APPLY: MESSAGE (TEXT("PSN_APPLY - Statistics Page")); return TRUE; } // switch break; case WM_CONTEXTMENU: WinHelp((HANDLE)wParam, NULL, HELP_CONTEXTMENU, (DWORD_PTR)rgIdhStatistics); break; case WM_HELP: WinHelp(((LPHELPINFO)lParam)->hItemHandle, NULL, HELP_WM_HELP, (DWORD_PTR)rgIdhStatistics); break; } // switch return FALSE; } // FStatisticsDlgProc #endif //_ABBREVIATED_DOCPROP_ //////////////////////////////////////////////////////////////////////////////// // // FContentsDlgProc // // Purpose: // Display the contents dialog // //////////////////////////////////////////////////////////////////////////////// #ifndef _ABBREVIATED_DOCPROP_ INT_PTR CALLBACK FContentsDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) { LPDSIOBJ lpDSIObj; // All DocSumInfo data. LPPROPVARIANT rgpropvarDocSumInfo; // Just the DocSumInfo properties. switch (message) { case WM_INITDIALOG : { BOOL fInitDialogSuccess = TRUE; PROPSHEETPAGE *ppspDlg = (PROPSHEETPAGE *)lParam; SHORT cT; LRESULT lError; TCHAR *psz; TCHAR ch; ULONG cHeadings; // Number of document headings ULONG cDocParts; // Total count of document parts. LPPROPVARIANT rgpropvarHeadings; // The Variant|Vector of heading pairs LPTSTR *rglptstrDocParts; // The document parts. ULONG ulHeadingIndex; // Index into rgpropvarHeadings ULONG ulTotalDocPartIndex; // Index into rglptstrDocParts ULONG ulSubDocPartIndex; // Index into rglptstrDocParts for the current heading ULONG cbDocPart = 0; // # bytes in a particular docpart. LPTSTR tszDocumentPart = NULL; // One DocPart with a pre-pending tab. lpDSIObj = ((LPALLOBJS)ppspDlg->lParam)->lpDSIObj; // Get the document sum. object. // Validate our objects. if (lpDSIObj == NULL || lpDSIObj->m_lpData == NULL) return FALSE; // Get to the DocSumInfo properties. rgpropvarDocSumInfo = GETDSINFO(lpDSIObj)->rgpropvar; // See if we have any headings. if (rgpropvarDocSumInfo[ PVDSI_HEADINGPAIR ].vt != (VT_VECTOR | VT_VARIANT)) { // Nothing to display. return FALSE; } // Get the Heading-Pair array and count. Validate the size of the array. cHeadings = rgpropvarDocSumInfo[ PVDSI_HEADINGPAIR ].capropvar.cElems; rgpropvarHeadings = rgpropvarDocSumInfo[ PVDSI_HEADINGPAIR ].capropvar.pElems; if (cHeadings == 0) { goto ExitCaseWM_INITDIALOG; } if (cHeadings & 0x1) { // This is an invalid array; the elements always come in (heading,count) pairs, // so there should be an even number of elements in the array. MESSAGE (TEXT("Invalid Headings array (should be an even number of elements)")); goto ExitCaseWM_INITDIALOG; } // Get the DocParts array and its size. All elements of this array are LPTSTRs. // Note that this array need not exist. cDocParts = 0; if (rgpropvarDocSumInfo[ PVDSI_DOCPARTS ].vt == (VT_VECTOR | VT_LPTSTR)) { rglptstrDocParts = (LPTSTR*) rgpropvarDocSumInfo[ PVDSI_DOCPARTS ].calpstr.pElems; cDocParts = rgpropvarDocSumInfo[ PVDSI_DOCPARTS ].calpstr.cElems; } // Loop through the Heading-Pair array. For each heading, we'll write it // to the list box, and then use the associated count to write Document Parts // to the list box. We'll stop when we've processed the array, or when // fInitDialogSuccess goes FALSE. ulTotalDocPartIndex = 0; for (ulHeadingIndex = 0; (ulHeadingIndex < cHeadings) && fInitDialogSuccess; ulHeadingIndex+=2) { // Verify that the next two elements in the Heading-Pair array are // a string and a Long. if (rgpropvarHeadings[ ulHeadingIndex ].vt != VT_LPTSTR || rgpropvarHeadings[ ulHeadingIndex + 1 ].vt != VT_I4) { MESSAGE (TEXT("Invalid Heading Pair type")); fInitDialogSuccess = FALSE; break; } // Write the Heading to the list box. lError = SendDlgItemMessage ( hDlg, IDD_CONTENTS_LISTBOX, LB_ADDSTRING, (WPARAM) 0, (LPARAM) rgpropvarHeadings[ ulHeadingIndex ].pszVal ); if (lError == LB_ERR || lError == LB_ERRSPACE) { MESSAGE(TEXT("Could not write to list box")); fInitDialogSuccess = FALSE; break; } // Verify that the DocParts we've written so far, plus those we're about // to write, don't exceed the total in the DocParts array. if (ulTotalDocPartIndex + rgpropvarHeadings[ ulHeadingIndex + 1 ].lVal > cDocParts) { MESSAGE (TEXT("Invalid doc-part count for heading")); fInitDialogSuccess = FALSE; break; } // Now loop through the document parts that are associated with this // heading. We'll insert a tab character in front of each string // so that the display looks better. We'll stop when we've processed // all the DocParts under this heading, or when fInitDialogSuccess goes // FALSE; for (ulSubDocPartIndex = ulTotalDocPartIndex; fInitDialogSuccess && (ulSubDocPartIndex < ulTotalDocPartIndex + rgpropvarHeadings[ ulHeadingIndex + 1 ].lVal); ulSubDocPartIndex++) { // Determine how big the DocumentPart string is, including a NULL // terminator, and including a tab character that we're going to insert. cbDocPart // Count the characters. #ifdef UNICODE = CchTszLen (rglptstrDocParts[ ulSubDocPartIndex ]) + 2; #else = CchAnsiSzLen (rglptstrDocParts[ ulSubDocPartIndex ]) + 2; #endif cbDocPart *= sizeof(TCHAR); // Convert to a *byte* count. // Alloc a buffer which will hold a tab character followed by the DocPart string. // Since there's no easy way to add cleanup code for this case block, // we must ensure that we free this buffer before any break could possibly // occur. tszDocumentPart = PvMemAlloc (cbDocPart); if (tszDocumentPart == NULL) { AssertSz (0, TEXT("Couldn't alloc memory for doc-part display")); fInitDialogSuccess = FALSE; break; } // Put the tab in the new string, followed by the DocPart string. *tszDocumentPart = TEXT('\t'); PbMemCopy(&tszDocumentPart[1], rglptstrDocParts[ ulSubDocPartIndex ], cbDocPart - sizeof(TCHAR)); // Subtract the size of the tab // Write the result to the list box, and free the temporary string. lError = SendDlgItemMessage ( hDlg, IDD_CONTENTS_LISTBOX, LB_ADDSTRING, (WPARAM) 0, (LPARAM) tszDocumentPart); if (tszDocumentPart != NULL) { VFreeMemP (tszDocumentPart, cbDocPart); tszDocumentPart = NULL; cbDocPart = 0; } if (lError == LB_ERR || lError == LB_ERRSPACE) { AssertSz (0, TEXT("Could not write to list box")); fInitDialogSuccess = FALSE; break; } } // for (ulSubDocPartIndex = ulTotalDocPartIndex; ... // Add the cont for all the doc-parts that we just displayed // to the total. ulTotalDocPartIndex = ulSubDocPartIndex; } // for (ulHeadingIndex = 0; ulHeadingIndex < cHeadings; ulHeadingIndex++) fInitDialogSuccess = TRUE; ExitCaseWM_INITDIALOG: // Now that the headings and document-parts are in the dialog, // we don't need to hold on to them any longer. PropVariantClear (&GETDSINFO(lpDSIObj)->rgpropvar[PVDSI_HEADINGPAIR]); PropVariantClear (&GETDSINFO(lpDSIObj)->rgpropvar[PVDSI_DOCPARTS]); return fInitDialogSuccess; } // end - case WM_INITDIALOG case WM_CTLCOLORBTN : case WM_CTLCOLORDLG : case WM_CTLCOLORSTATIC : if (hBrushPropDlg == NULL) break; DeleteObject(hBrushPropDlg); if ((hBrushPropDlg = CreateSolidBrush(GetSysColor(COLOR_BTNFACE))) == NULL) break; SetBkColor ((HDC) wParam, GetSysColor (COLOR_BTNFACE)); SetTextColor((HDC) wParam, GetSysColor(COLOR_WINDOWTEXT)); return (INT_PTR) hBrushPropDlg; case WM_NOTIFY : switch (((NMHDR FAR *) lParam)->code) { case PSN_SETACTIVE : return TRUE; case PSN_RESET: case PSN_APPLY: MESSAGE (TEXT("PSN_APPLY - Contents Page")); return TRUE; } // switch break; case WM_CONTEXTMENU: WinHelp((HANDLE)wParam, NULL, HELP_CONTEXTMENU, (DWORD_PTR)rgIdhContents); break; case WM_HELP: WinHelp(((LPHELPINFO)lParam)->hItemHandle, NULL, HELP_WM_HELP, (DWORD_PTR)rgIdhContents); break; } // switch return FALSE; } // FContentsDlgProc #endif // _ABBREVIATED_DOCPROP_ int gOKButtonID; // need this to store the ID of the OK button, since it's not in the dlg template //////////////////////////////////////////////////////////////////////////////// // // FCustomDlgProc // // Purpose: // Custom tab control // //////////////////////////////////////////////////////////////////////////////// INT_PTR CALLBACK FCustomDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) { LPALLOBJS lpallobjs = (LPALLOBJS)GetWindowLongPtr(hDlg, DWLP_USER); switch (message) { case WM_INITDIALOG: { PROPSHEETPAGE *ppspDlg = (PROPSHEETPAGE *) lParam; int irg; HICON hIcon, hInvIcon; lpallobjs = (LPALLOBJS)ppspDlg->lParam; PropPageInit(lpallobjs, itabCUSTOM); SetWindowLongPtr(hDlg, DWLP_USER, ppspDlg->lParam); gOKButtonID = LOWORD(SendMessage(hDlg, DM_GETDEFID, 0L, 0L)); AssertSz ((sizeof(NUM) == (sizeof(FILETIME))), TEXT("Ok, who changed base type sizes?")); // // Fill out the Name dropdown // for (irg = 0; irg < NUM_BUILTIN_CUSTOM_NAMES; ++irg) { if (!CchGetString( idsCustomName1+ irg, lpallobjs->CDP_sz, sizeof(lpallobjs->CDP_sz)) ) { return(FALSE); } SendDlgItemMessage(hDlg, IDD_CUSTOM_NAME, CB_ADDSTRING, 0, (LPARAM)lpallobjs->CDP_sz); } // // Fill out the type drop-down & select the text type // for (irg = 0; irg <= iszBOOL; irg++) { SendDlgItemMessage(hDlg, IDD_CUSTOM_TYPE, CB_ADDSTRING, 0, (LPARAM) rgszTypes[irg]); } ResetTypeControl (hDlg, IDD_CUSTOM_TYPE, &lpallobjs->CDP_iszType); // // Set the link checkbox to be off. // lpallobjs->CDP_fLink = FALSE; SendDlgItemMessage( hDlg, IDD_CUSTOM_LINK, BM_SETCHECK, (WPARAM) lpallobjs->CDP_fLink, 0 ); #ifndef __CUSTOM_LINK_ENABLED__ ShowWindow( GetDlgItem( hDlg, IDD_CUSTOM_LINK ), SW_HIDE ); #endif __CUSTOM_LINK_ENABLED__ SendDlgItemMessage( hDlg, IDD_CUSTOM_VALUETEXT, WM_SETTEXT, 0, (LPARAM) rgszValue[iszVALUE] ); // // Hang on to the window handle of the value edit control & others // lpallobjs->CDP_hWndVal = GetDlgItem (hDlg, IDD_CUSTOM_VALUE); lpallobjs->CDP_hWndName = GetDlgItem (hDlg, IDD_CUSTOM_NAME); lpallobjs->CDP_hWndLinkVal = GetDlgItem (hDlg, IDD_CUSTOM_LINKVALUE); lpallobjs->CDP_hWndValText = GetDlgItem (hDlg, IDD_CUSTOM_VALUETEXT); lpallobjs->CDP_hWndBoolTrue = GetDlgItem (hDlg, IDD_CUSTOM_BOOLTRUE); lpallobjs->CDP_hWndBoolFalse = GetDlgItem (hDlg, IDD_CUSTOM_BOOLFALSE); lpallobjs->CDP_hWndGroup = GetDlgItem (hDlg, IDD_CUSTOM_GBOX); lpallobjs->CDP_hWndAdd = GetDlgItem (hDlg, IDD_CUSTOM_ADD); lpallobjs->CDP_hWndDelete = GetDlgItem (hDlg, IDD_CUSTOM_DELETE); lpallobjs->CDP_hWndType = GetDlgItem (hDlg, IDD_CUSTOM_TYPE); lpallobjs->CDP_hWndCustomLV = GetDlgItem(hDlg, IDD_CUSTOM_LISTVIEW); InitListView (lpallobjs->CDP_hWndCustomLV, iszTYPE, rgszHeadings, TRUE); // // Initially disable the Add & Delete buttons // EnableWindow (lpallobjs->CDP_hWndAdd, FALSE); EnableWindow (lpallobjs->CDP_hWndDelete, FALSE); lpallobjs->CDP_fAdd = TRUE; // // Don't let the user enter too much text // If you change this value, you must change the buffer // size (szDate) in FConvertDate // SendMessage (lpallobjs->CDP_hWndVal, EM_LIMITTEXT, BUFMAX-1, 0); SendMessage (lpallobjs->CDP_hWndName, EM_LIMITTEXT, BUFMAX-1, 0); // // Add the link icon to the image list // hIcon = LoadIcon (g_hmodThisDll, MAKEINTRESOURCE (IDD_LINK_ICON)); hInvIcon = LoadIcon (g_hmodThisDll, MAKEINTRESOURCE (IDD_INVLINK_ICON)); if (hIcon != NULL) { lpallobjs->CDP_hImlS = ListView_GetImageList( lpallobjs->CDP_hWndCustomLV, TRUE ); giLinkIcon = MsoImageList_ReplaceIcon( lpallobjs->CDP_hImlS, -1, hIcon ); Assert ((giLinkIcon != -1)); giInvLinkIcon = MsoImageList_ReplaceIcon (lpallobjs->CDP_hImlS, -1, hInvIcon); Assert ((giInvLinkIcon != -1)); } else { DebugSz (TEXT("Icon load failed")); } // // Make a temporary copy of the custom data // FMakeTmpUDProps (lpallobjs->lpUDObj); // // Fill in the list view box with any data from the object // PopulateUDListView (lpallobjs->CDP_hWndCustomLV, lpallobjs->lpUDObj); // // See if the client supports links - turn off checkbox if they don't // lpallobjs->CDP_cLinks = #ifdef __CUSTOM_LINK_ENABLED__ (lpallobjs->lpfnDwQueryLinkData != NULL) ? (*lpallobjs->lpfnDwQueryLinkData) (QLD_CLINKS, 0, NULL, NULL) : #endif __CUSTOM_LINK_ENABLED__ 0; if (!lpallobjs->CDP_cLinks) { EnableWindow (GetDlgItem (hDlg, IDD_CUSTOM_LINK), FALSE); EnableWindow (lpallobjs->CDP_hWndLinkVal, FALSE); } // lpallobjs->fPropDlgChanged = FALSE; // fItemSel = FALSE; return TRUE; break; } case WM_CTLCOLORBTN : case WM_CTLCOLORDLG : case WM_CTLCOLORSTATIC : if (hBrushPropDlg == NULL) break; DeleteObject(hBrushPropDlg); if ((hBrushPropDlg = CreateSolidBrush(GetSysColor(COLOR_BTNFACE))) == NULL) break; SetBkColor ((HDC) wParam, GetSysColor (COLOR_BTNFACE)); SetTextColor((HDC) wParam, GetSysColor(COLOR_WINDOWTEXT)); return (INT_PTR) hBrushPropDlg; case WM_SYSCOLORCHANGE: PostMessage(lpallobjs->CDP_hWndCustomLV, WM_SYSCOLORCHANGE, wParam, lParam); return TRUE; break; // // This message is posted when ever the user does something with the // Name field. That allows the system to finish what they are doing // and fill in the edit field if they have to. See bug 2820. // case WM_USER+0x1000: if (!(lpallobjs->CDP_fLink && (lpallobjs->lpfnDwQueryLinkData == NULL))) { lpallobjs->CDP_iszType = (int)SendMessage (lpallobjs->CDP_hWndType, CB_GETCURSEL, 0, 0); FSetupAddButton (lpallobjs->CDP_iszType, lpallobjs->CDP_fLink, &lpallobjs->CDP_fAdd, lpallobjs->CDP_hWndAdd, lpallobjs->CDP_hWndVal, lpallobjs->CDP_hWndName, hDlg); if (FAllocAndGetValLpstz (hDlg, IDD_CUSTOM_NAME, &glpstzName)) { LPUDPROP lpudp = LpudpropFindMatchingName (lpallobjs->lpUDObj, (LPTSTR)PSTR (glpstzName)); if (lpudp != NULL) { if (lpallobjs->CDP_fAdd) { SendMessage (lpallobjs->CDP_hWndAdd, WM_SETTEXT, 0, (LPARAM) rgszAdd[iszMODIFY]); lpallobjs->CDP_fAdd = FALSE; } } } EnableWindow(lpallobjs->CDP_hWndDelete, FALSE); // If the user touches the Name field, disable Delete button // Are we showing an invalid link? if (lpallobjs->CDP_fLink && !IsWindowEnabled(GetDlgItem(hDlg,IDD_CUSTOM_LINK))) { // Turn off the link checkbox lpallobjs->CDP_fLink = FALSE; SendDlgItemMessage (hDlg, IDD_CUSTOM_LINK, BM_SETCHECK, (WPARAM) lpallobjs->CDP_fLink, 0); if (lpallobjs->CDP_cLinks) // Could be that the app is allowing links EnableWindow (GetDlgItem (hDlg, IDD_CUSTOM_LINK), TRUE); // Clear the value window ClearEditControl (lpallobjs->CDP_hWndVal, 0); FSwapControls (lpallobjs->CDP_hWndVal, lpallobjs->CDP_hWndLinkVal, lpallobjs->CDP_hWndBoolTrue, lpallobjs->CDP_hWndBoolFalse, lpallobjs->CDP_hWndGroup, lpallobjs->CDP_hWndType, lpallobjs->CDP_hWndValText, FALSE, FALSE); } } return(TRUE); break; case WM_COMMAND : switch (HIWORD (wParam)) { case BN_CLICKED : switch (LOWORD (wParam)) { case IDD_CUSTOM_ADD : if (FGetCustomPropFromDlg(lpallobjs, hDlg)) { PropSheet_Changed(GetParent(hDlg), hDlg); } return(FALSE); // return 0 'cuz we process the message break; case IDD_CUSTOM_DELETE : // Assert (fItemSel); // fItemSel = FALSE; // We're about to delete it! DeleteItem (lpallobjs->lpUDObj, lpallobjs->CDP_hWndCustomLV, lpallobjs->CDP_iItem, lpallobjs->CDP_sz); // Turn off the link checkbox if it was on. lpallobjs->CDP_fLink = FALSE; SendDlgItemMessage (hDlg, IDD_CUSTOM_LINK, BM_SETCHECK, (WPARAM) lpallobjs->CDP_fLink, 0); ClearEditControl (lpallobjs->CDP_hWndVal, 0); FSwapControls (lpallobjs->CDP_hWndVal, lpallobjs->CDP_hWndLinkVal, lpallobjs->CDP_hWndBoolTrue, lpallobjs->CDP_hWndBoolFalse, lpallobjs->CDP_hWndGroup, lpallobjs->CDP_hWndType, lpallobjs->CDP_hWndValText, FALSE, FALSE); FSetupAddButton (lpallobjs->CDP_iszType, lpallobjs->CDP_fLink, &lpallobjs->CDP_fAdd, lpallobjs->CDP_hWndAdd, lpallobjs->CDP_hWndVal, lpallobjs->CDP_hWndName, hDlg); ResetTypeControl (hDlg, IDD_CUSTOM_TYPE, &lpallobjs->CDP_iszType); SendMessage(lpallobjs->CDP_hWndName, CB_SETEDITSEL, 0, MAKELPARAM(0,-1)); // Select entire string SendMessage(lpallobjs->CDP_hWndName, WM_CLEAR, 0, 0); SetFocus(lpallobjs->CDP_hWndName); // lpallobjs->fPropDlgChanged = TRUE; PropSheet_Changed(GetParent(hDlg), hDlg); return(FALSE); // return 0 'cuz we process the message break; case IDD_CUSTOM_LINK : { BOOL fMod = FALSE; // Should never get a message from a disabled control Assert (lpallobjs->CDP_cLinks); lpallobjs->CDP_fLink = !lpallobjs->CDP_fLink; SendDlgItemMessage (hDlg, IDD_CUSTOM_LINK, BM_SETCHECK, (WPARAM) lpallobjs->CDP_fLink, 0); // If the link box is checked, the value edit needs to change // to a combobox filled with link data if (lpallobjs->CDP_fLink) { Assert ((lpallobjs->lpfnDwQueryLinkData != NULL)); FCreateListOfLinks (lpallobjs->CDP_cLinks, lpallobjs->lpfnDwQueryLinkData, lpallobjs->CDP_hWndLinkVal); SendMessage (lpallobjs->CDP_hWndLinkVal, CB_SETCURSEL, 0, 0); FSetTypeControl ((*lpallobjs->lpfnDwQueryLinkData) (QLD_LINKTYPE, 0, NULL, NULL), lpallobjs->CDP_hWndType); } else ClearEditControl (lpallobjs->CDP_hWndVal, 0); FSwapControls (lpallobjs->CDP_hWndVal, lpallobjs->CDP_hWndLinkVal, lpallobjs->CDP_hWndBoolTrue, lpallobjs->CDP_hWndBoolFalse, lpallobjs->CDP_hWndGroup, lpallobjs->CDP_hWndType, lpallobjs->CDP_hWndValText, lpallobjs->CDP_fLink, FALSE); // HACK, we don't want FSetupAddButton to change the text of the add // button if (!lpallobjs->CDP_fAdd) fMod = lpallobjs->CDP_fAdd = TRUE; // Set up the "Add" button correctly FSetupAddButton (lpallobjs->CDP_iszType, lpallobjs->CDP_fLink, &lpallobjs->CDP_fAdd, lpallobjs->CDP_hWndAdd, lpallobjs->CDP_hWndVal, lpallobjs->CDP_hWndName, hDlg); if (fMod) lpallobjs->CDP_fAdd = FALSE; return(FALSE); // return 0 'cuz we process the message break; } case IDD_CUSTOM_BOOLTRUE: case IDD_CUSTOM_BOOLFALSE: { BOOL fMod = FALSE; lpallobjs->CDP_iszType = (int)SendMessage (lpallobjs->CDP_hWndType, CB_GETCURSEL, 0, 0); // HACK, we don't want FSetupAddButton to change the text of the add // button if (!lpallobjs->CDP_fAdd) fMod = lpallobjs->CDP_fAdd = TRUE; FSetupAddButton (lpallobjs->CDP_iszType, lpallobjs->CDP_fLink, &lpallobjs->CDP_fAdd, lpallobjs->CDP_hWndAdd, lpallobjs->CDP_hWndVal, lpallobjs->CDP_hWndName, hDlg); if (fMod) lpallobjs->CDP_fAdd = FALSE; return(FALSE); } default: return(TRUE); } case CBN_CLOSEUP: // Hack!! // We need to post a message to ourselves to check if the user's // actions entered text in the edit field. PostMessage(hDlg, WM_USER+0x1000, 0L, 0L); return(FALSE); case CBN_SELCHANGE : switch (LOWORD (wParam)) { case IDD_CUSTOM_NAME : // Hack!! // We need to post a message to ourselves to check if the user's // actions entered text in the edit field. PostMessage(hDlg, WM_USER+0x1000, 0L, 0L); return(FALSE); // return 0 'cuz we process the message break; case IDD_CUSTOM_TYPE : { BOOL fMod = FALSE; // If the user picks the Boolean type from the combo box, // we must replace the edit control for the value // with radio buttons. If the Link checkbox is set, // the type depends on the link value, not user selection lpallobjs->CDP_iszType = (int)SendMessage ((HWND) lParam, CB_GETCURSEL, 0, 0); FSwapControls (lpallobjs->CDP_hWndVal, lpallobjs->CDP_hWndLinkVal, lpallobjs->CDP_hWndBoolTrue, lpallobjs->CDP_hWndBoolFalse, lpallobjs->CDP_hWndGroup, lpallobjs->CDP_hWndType, lpallobjs->CDP_hWndValText, lpallobjs->CDP_fLink, (lpallobjs->CDP_iszType == iszBOOL)); // HACK: FSwapControls() resets the type selection to be // the first one (since all other clients need that to // happen). In this case, the user has selected a new // type, so we need to force it manually to what they picked. SendMessage (lpallobjs->CDP_hWndType, CB_SETCURSEL, lpallobjs->CDP_iszType, 0); // HACK: FSetupAddButton will change the Add button to // say "Add" if lpallobjs->CDP_fAdd is FALSE. Since we just changed // the button to "Modify", fake it out to not change // the Add button by flipping lpallobjs->CDP_fAdd, then flipping it back. if (!lpallobjs->CDP_fAdd) fMod = lpallobjs->CDP_fAdd = TRUE; FSetupAddButton (lpallobjs->CDP_iszType, lpallobjs->CDP_fLink, &lpallobjs->CDP_fAdd, lpallobjs->CDP_hWndAdd, lpallobjs->CDP_hWndVal, lpallobjs->CDP_hWndName, hDlg); if (fMod) lpallobjs->CDP_fAdd = FALSE; return(FALSE); // return 0 'cuz we process the message } case IDD_CUSTOM_LINKVALUE : // If the user has the "Link" box checked and starts picking // link values, make sure that the "Type" combobox is updated // to the type of the static value of the link. { DWORD irg; AssertSz (lpallobjs->CDP_fLink, TEXT("Link box must be checked in order for this dialog to be visible!")); // Get the link value from the combobox, and store // the link name and static value. irg = (int)SendMessage (lpallobjs->CDP_hWndLinkVal, CB_GETCURSEL, 0, 0); Assert ((lpallobjs->lpfnDwQueryLinkData != NULL)); // REVIEW: If apps really need the name, we can get it here.... FSetTypeControl ((*lpallobjs->lpfnDwQueryLinkData) (QLD_LINKTYPE, irg, NULL, NULL), lpallobjs->CDP_hWndType); return(FALSE); // return 0 'cuz we process the message } default: return TRUE; // we didn't process message } case CBN_EDITCHANGE: // The user typed their own switch (LOWORD (wParam)) { case IDD_CUSTOM_NAME : // Hack!! // We need to post a message to ourselves to check if the user's // actions entered text in the edit field. PostMessage(hDlg, WM_USER+0x1000, 0L, 0L); return(FALSE); // return 0 'cuz we process the message break; default: return(TRUE); break; } case EN_UPDATE : switch (LOWORD (wParam)) { case IDD_CUSTOM_VALUE : { BOOL fMod = FALSE; if (FAllocAndGetValLpstz (hDlg, IDD_CUSTOM_NAME, &glpstzName)) { LPUDPROP lpudp = LpudpropFindMatchingName (lpallobjs->lpUDObj, (LPTSTR)PSTR (glpstzName)); if (lpudp != NULL) { if (lpallobjs->CDP_fAdd) { SendMessage (lpallobjs->CDP_hWndAdd, WM_SETTEXT, 0, (LPARAM) rgszAdd[iszMODIFY]); lpallobjs->CDP_fAdd = FALSE; } } // HACK: FSetupAddButton will change the Add button to // say "Add" if lpallobjs->CDP_fAdd is FALSE. Since we just changed // the button to "Modify", fake it out to not change // the Add button by flipping lpallobjs->CDP_fAdd, then flipping it back. if (!lpallobjs->CDP_fAdd) fMod = lpallobjs->CDP_fAdd = TRUE; FSetupAddButton (lpallobjs->CDP_iszType, lpallobjs->CDP_fLink, &lpallobjs->CDP_fAdd, lpallobjs->CDP_hWndAdd, lpallobjs->CDP_hWndVal, lpallobjs->CDP_hWndName, hDlg); if (fMod) lpallobjs->CDP_fAdd = FALSE; } return(FALSE); // return 0 'cuz we process the message } default: return TRUE; // we didn't process message } case EN_KILLFOCUS : switch (LOWORD (wParam)) { // If the user finishes entering text in the Name edit control, // be really cool and check to see if the name they entered // is a property that is already defined. If it is, // change the Add button to Modify. case IDD_CUSTOM_NAME : if (FAllocAndGetValLpstz (hDlg, IDD_CUSTOM_NAME, &glpstzName)) { LPUDPROP lpudp = LpudpropFindMatchingName (lpallobjs->lpUDObj, (LPTSTR)PSTR (glpstzName)); if (lpudp != NULL) { if (lpallobjs->CDP_fAdd) { SendMessage (lpallobjs->CDP_hWndAdd, WM_SETTEXT, 0, (LPARAM) rgszAdd[iszMODIFY]); lpallobjs->CDP_fAdd = FALSE; } } } return FALSE; default: return TRUE; } default: return TRUE; } // switch case WM_DESTROY: MsoImageList_Destroy(lpallobjs->CDP_hImlS); return FALSE; case WM_NOTIFY : switch (((NMHDR FAR *) lParam)->code) { case LVN_ITEMCHANGING : // If an item is gaining focus, put it in the edit controls at // the top of the dialog. if (((NM_LISTVIEW FAR *) lParam)->uNewState & LVIS_SELECTED) { Assert ((((NM_LISTVIEW FAR *) lParam) != NULL)); lpallobjs->CDP_iItem = ((NM_LISTVIEW FAR *) lParam)->iItem; ListView_GetItemText (lpallobjs->CDP_hWndCustomLV, lpallobjs->CDP_iItem, 0, lpallobjs->CDP_sz, BUFMAX); PopulateControls (lpallobjs->lpUDObj, lpallobjs->CDP_sz, lpallobjs->CDP_cLinks, lpallobjs->lpfnDwQueryLinkData, hDlg, GetDlgItem (hDlg, IDD_CUSTOM_NAME), lpallobjs->CDP_hWndVal, lpallobjs->CDP_hWndValText, GetDlgItem (hDlg, IDD_CUSTOM_LINK), lpallobjs->CDP_hWndLinkVal, lpallobjs->CDP_hWndType, lpallobjs->CDP_hWndBoolTrue, lpallobjs->CDP_hWndBoolFalse, lpallobjs->CDP_hWndGroup, lpallobjs->CDP_hWndAdd, lpallobjs->CDP_hWndDelete, &lpallobjs->CDP_fLink, &lpallobjs->CDP_fAdd); return FALSE; } return TRUE; break; #ifdef OFFICE_96 case LVN_COLUMNCLICK: // We only sort the name column if (((LPARAM)((NM_LISTVIEW *)lParam)->iSubItem == 0)) ListView_SortItems(((NM_LISTVIEW *) lParam)->hdr.lpallobjs->CDP_hWndFrom, ListViewCompareFunc,0); return TRUE; #endif case PSN_APPLY : if (IsWindowEnabled(lpallobjs->CDP_hWndAdd)) FGetCustomPropFromDlg(lpallobjs, hDlg); // Swap the temp copy to be the real copy. FDeleteTmpUDProps (lpallobjs->lpUDObj); MESSAGE (TEXT("PSN_APPLY - Custom Page")); if (FUserDefShouldSave (lpallobjs->lpUDObj) || lpallobjs->fPropDlgChanged ) { if( !ApplyChangesBackToFile(hDlg, (BOOL)((PSHNOTIFY*)lParam)->lParam, lpallobjs, itabCUSTOM) ) { PostMessage( GetParent(hDlg), PSM_SETCURSEL, (WPARAM)-1, (LPARAM)lpallobjs->lpUDObj->m_hPage ); SetWindowLongPtr( hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE ); return TRUE; } } return PSNRET_NOERROR; case PSN_RESET : if (lpallobjs->fPropDlgChanged && !lpallobjs->fPropDlgPrompted) { if (ISavePropDlgChanges(lpallobjs, hDlg, ((NMHDR FAR *)lParam)->hwndFrom) != IDNO) { return(TRUE); } } // User cancelled the changes, so just delete the tmp stuff. FSwapTmpUDProps (lpallobjs->lpUDObj); FDeleteTmpUDProps (lpallobjs->lpUDObj); return TRUE; case PSN_SETACTIVE : return TRUE; default: break; } // switch break; case WM_CONTEXTMENU: WinHelp((HANDLE)wParam, NULL, HELP_CONTEXTMENU, (DWORD_PTR)rgIdhCustom); break; case WM_HELP: WinHelp(((LPHELPINFO)lParam)->hItemHandle, NULL, HELP_WM_HELP, (DWORD_PTR)rgIdhCustom); break; } // switch return FALSE; } // FCustomDlgProc // // FGetCustomPropFromDlg // // Purpose: To get a custom property from the dialog. // I.e. the user hit Add/Modify. // BOOL FGetCustomPropFromDlg(LPALLOBJS lpallobjs, HWND hDlg) { UDTYPES udtype; NUM dbl; LPVOID lpv; int iItemT; LPTSTR lpstzName; LPVOID lpvSaveAsDword; DWORD cch; BOOL f; lpstzName = NULL; cch = 0; if (FAllocAndGetValLpstz (hDlg, IDD_CUSTOM_NAME, &glpstzName)) { LPUDPROP lpudp; #ifdef __CUSTOM_LINK_ENABLED__ lpallobjs->CDP_fLink = SendDlgItemMessage(hDlg, IDD_CUSTOM_LINK, BM_GETCHECK, 0, 0); #else lpallobjs->CDP_fLink = FALSE; // just to be sure. #endif __CUSTOM_LINK_ENABLED__ Assert(lpallobjs->CDP_fLink == TRUE || lpallobjs->CDP_fLink == FALSE); // HACK: If the user enters a name that is already // a property name, the default action of the object // is to replace the data, treating it as an update. // This will cause there to be 2 names in the listview // though unless we just update the original one. So, first // see if the new name is in the list already, and if // it is, find it in the listview and set up to update it. lpudp = LpudpropFindMatchingName (lpallobjs->lpUDObj, (LPTSTR)PSTR (glpstzName)); if (lpudp != NULL) { LV_FINDINFO lvfi; lvfi.flags = LVFI_STRING; lvfi.psz = (LPTSTR) PSTR (glpstzName); iItemT = ListView_FindItem (lpallobjs->CDP_hWndCustomLV, -1, &lvfi); // If the property is being modified and the link // box is not checked, we need to remove the link // data and the IMoniker from the object. // if (!lpallobjs->CDP_fLink) // { // FUserDefAddProp (lpallobjs->lpUDObj, PSTR (glpstzName), NULL, // wUDlpsz, TRUE, FALSE, FALSE); // FUserDefAddProp (lpallobjs->lpUDObj, PSTR (glpstzName), NULL, // wUDlpsz, FALSE, FALSE, TRUE); // } } else iItemT = -1; // Let's get the type, since this might be a MODIFY case lpallobjs->CDP_iszType = (int)SendMessage(lpallobjs->CDP_hWndType, CB_GETCURSEL,0, 0); // If the user has checked the link box, then the value // must come from the client. if (lpallobjs->CDP_fLink) { DWORD irg; // Get the link name from the combobox, and store // the link name and static value. irg = (int)SendMessage (lpallobjs->CDP_hWndLinkVal, CB_GETCURSEL, 0, 0); Assert ((lpallobjs->lpfnDwQueryLinkData != NULL)); Assert (((irg < lpallobjs->CDP_cLinks) && ((int) irg >= 0))); cch = (DWORD)SendMessage (lpallobjs->CDP_hWndLinkVal, CB_GETLBTEXTLEN, irg, 0)+1; // Include the null-terminator if (!FAllocString (&lpstzName, cch)) return(FALSE); SendMessage (lpallobjs->CDP_hWndLinkVal, CB_GETLBTEXT, irg, (LPARAM) PSTR (lpstzName)); // Set up the static type and value for display // in the listbox udtype = (UDTYPES) (*lpallobjs->lpfnDwQueryLinkData) (QLD_LINKTYPE, irg, NULL, (LPTSTR)PSTR (lpstzName)); (*lpallobjs->lpfnDwQueryLinkData) (QLD_LINKVAL, irg, &lpv, (LPTSTR)PSTR (lpstzName)); // // HACK alert // // We want lpv to point to the value, not to be overloaded in the case of a dword or bool. // if ((udtype == wUDdw) || (udtype == wUDbool)) { lpvSaveAsDword = lpv; // Really a DWORD lpv = &lpvSaveAsDword; } // Add the link name itself to the object // FUserDefAddProp (lpallobjs->lpUDObj, PSTR (glpstzName), PSTR (lpstzName), // wUDlpsz, TRUE, FALSE, FALSE); } // if (lpallobjs->CDP_fLink) else { if (lpallobjs->CDP_iszType != iszBOOL) { if (!FAllocAndGetValLpstz (hDlg, IDD_CUSTOM_VALUE, &glpstzValue)) return(FALSE); } // Convert the type in the combobox to a UDTYPES switch (lpallobjs->CDP_iszType) { case iszTEXT : udtype = wUDlpsz; (LPTSTR) lpv = (LPTSTR)PSTR (glpstzValue); break; case iszNUM : udtype = UdtypesGetNumberType (glpstzValue, &dbl, ((LPUDINFO)lpallobjs->lpUDObj->m_lpData)->lpfnFSzToNum); switch (udtype) { case wUDdw : lpv = (DWORD *) &dbl; break; case wUDfloat : (NUM *) lpv = &dbl; break; default : (LPTSTR) lpv = (LPTSTR)PSTR (glpstzValue); // If the user doesn't want to convert the value to text, they can press "Cancel" and try again. if (FDisplayConversionWarning (hDlg)) { SetFocus(lpallobjs->CDP_hWndType); return(FALSE); } udtype = wUDlpsz; } // switch (udtype) break; case iszDATE : if (FConvertDate (glpstzValue, (LPFILETIME) &dbl)) { udtype = wUDdate; (NUM *) lpv = &dbl; } else { udtype = wUDlpsz; (LPTSTR) lpv = (LPTSTR)PSTR (glpstzValue); // If the user doesn't want to convert the value to text, they can press "Cancel" and try again. if (FDisplayConversionWarning (hDlg)) { SetFocus(lpallobjs->CDP_hWndType); return(FALSE); } } break; case iszBOOL : { udtype = wUDbool; f = (BOOL)(SendMessage (lpallobjs->CDP_hWndBoolTrue, BM_GETSTATE, 0, 0) & BST_CHECKED); lpv = &f; break; } default : AssertSz (0,TEXT("IDD_CUSTOM_TYPE combobox is whacked!")); udtype = wUDinvalid; } // switch (lpallobjs->CDP_iszType) } // if (lpallobjs->CDP_fLink) ... else // If we got valid input, add the property to the object // and listbox. if (udtype != wUDinvalid) { // The PropVariant created when we add this property. LPPROPVARIANT lppropvar = NULL; // The link data (link name itself) would have // been stored above if the property was a link. // This stores the static value that will eventually // appear in the list view. lppropvar = LppropvarUserDefAddProp (lpallobjs->lpUDObj, glpstzName, lpv, udtype, (lpstzName != NULL) ? lpstzName : NULL, (lpstzName != NULL) ? TRUE : FALSE, FALSE); // HACK alert // // Here we want lpv be overloaded in the case of a dword or bool, since // AddUDPropToListView calls WUdtypeToSz which assumes lpv is overloaded. // if ((udtype == wUDdw) || (udtype == wUDbool)) { lpv = *(LPVOID *)lpv; } if (lppropvar) AddUDPropToListView (lpallobjs->lpUDObj, lpallobjs->CDP_hWndCustomLV, (LPTSTR)PSTR (glpstzName), lppropvar, iItemT, lpallobjs->CDP_fLink, fTrue, fTrue); // For links, dealloc the buffer. if (lpallobjs->CDP_fLink) DeallocValue (&lpv, udtype); // Clear out the edit fields and disable the Add button again SetCustomDlgDefButton(hDlg, gOKButtonID); EnableWindow (lpallobjs->CDP_hWndAdd, FALSE); SendMessage(lpallobjs->CDP_hWndName, CB_SETEDITSEL, 0, MAKELPARAM(0,-1)); // Select entire string SendMessage(lpallobjs->CDP_hWndName, WM_CLEAR, 0, 0); EnableWindow (lpallobjs->CDP_hWndDelete, FALSE); // See bug 213 // if (fLink) // { // fLink = !fLink; // SendDlgItemMessage (hDlg, IDD_CUSTOM_LINK, BM_SETCHECK, (WPARAM) fLink, 0); // } FSwapControls (lpallobjs->CDP_hWndVal, lpallobjs->CDP_hWndLinkVal, lpallobjs->CDP_hWndBoolTrue, lpallobjs->CDP_hWndBoolFalse, lpallobjs->CDP_hWndGroup, lpallobjs->CDP_hWndType, lpallobjs->CDP_hWndValText, lpallobjs->CDP_fLink, lpallobjs->CDP_iszType == iszBOOL); FSetupAddButton (lpallobjs->CDP_iszType, lpallobjs->CDP_fLink, &lpallobjs->CDP_fAdd, lpallobjs->CDP_hWndAdd, lpallobjs->CDP_hWndVal, lpallobjs->CDP_hWndName, hDlg); // wUDbool doesn't use the edit control.... if (lpallobjs->CDP_iszType != iszBOOL) ClearEditControl (lpallobjs->CDP_hWndVal, 0); } // if (udtype != wUDinvalid) SendDlgItemMessage(hDlg, IDD_CUSTOM_TYPE, CB_SETCURSEL, lpallobjs->CDP_iszType,0); SetFocus(lpallobjs->CDP_hWndName); // lpallobjs->fPropDlgChanged = TRUE; if (lpstzName != NULL) VFreeMemP(lpstzName, CBTSTR (lpstzName)); return(TRUE); } return(FALSE); } ///////////////////////////////////////////////////////////////////////// // // SetCustomDlgDefButton // // Set the new default button // ///////////////////////////////////////////////////////////////////////// VOID SetCustomDlgDefButton(HWND hDlg, int IDNew) { int IDOld; if ((IDOld = LOWORD(SendMessage(hDlg, DM_GETDEFID, 0L, 0L))) != IDNew) { // Set the new default push button's control ID. SendMessage(hDlg, DM_SETDEFID, IDNew, 0L); // Set the new style. SendDlgItemMessage(hDlg, IDNew, BM_SETSTYLE, BS_DEFPUSHBUTTON, MAKELPARAM(TRUE,0)); SendDlgItemMessage(hDlg, IDOld, BM_SETSTYLE, BS_PUSHBUTTON, MAKELPARAM(TRUE,0)); } } #ifdef OFFICE_96 //////////////////////////////////////////////////////////////////////////////// // // ListViewCompareFunc // // Purpose: // Compares two items in a listview // We only sort the name column. // // Returns // A negative value if item 1 should come before item 2 // A positive value if item 1 should come after item 2 // Zero if the two items are equivalent // //////////////////////////////////////////////////////////////////////////////// int CALLBACK ListViewCompareFunc ( LPARAM lParam1, // lParam of the LV_ITEM struct (property name) LPARAM lParam2, // lParam of the LV_ITEM struct (property name) LPARAM lParamSort) // Index of column to sore { return(lstrcmp((LPTSTR)lParam1, (LPTSTR)lParam2)); } #endif //////////////////////////////////////////////////////////////////////////////// // // PrintTimeInDlg // // Purpose: // Prints the locale-specific time representation in control in the dialog. // //////////////////////////////////////////////////////////////////////////////// #ifndef _ABBREVIATED_DOCPROP_ void PASCAL PrintTimeInDlg ( HWND hDlg, // Dialog handle DWORD dwId, // Control id LPFILETIME lpft) // The time { SYSTEMTIME st; TCHAR szBuf[80], szTmp[64]; const TCHAR *c_szSpace = TEXT(" "); if ((lpft != NULL) && (lpft->dwLowDateTime != 0) && (lpft->dwHighDateTime != 0)) { FILETIME ft; FileTimeToLocalFileTime(lpft, &ft); // get in local time FileTimeToSystemTime(&ft, &st); GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, szBuf,ARRAYSIZE(szBuf)); // don't bother with the time if it is NULL if (st.wHour || st.wMinute || st.wSecond) { lstrcat(szBuf, c_szSpace); GetTimeFormat(LOCALE_USER_DEFAULT, 0, &st, NULL, szTmp, ARRAYSIZE(szTmp)); lstrcat(szBuf, szTmp); } SetDlgItemText(hDlg, dwId, szBuf); } } // PrintTimeInDlg #endif //_ABBREVIATED_DOCPROP_ //////////////////////////////////////////////////////////////////////////////// // // PrintEditTimeInDlg // // Purpose: // Prints the total edit time in the dialog. // //////////////////////////////////////////////////////////////////////////////// #ifndef _ABBREVIATED_DOCPROP_ void PASCAL PrintEditTimeInDlg ( HWND hDlg, // Dialog handle LPFILETIME lpft) // The time { TCHAR sz[100]; // Remember that the 64 bit number in lpft is units of 100ns VFtToSz(lpft, sz, ARRAYSIZE(sz), TRUE); SetDlgItemText(hDlg, IDD_STATISTICS_TOTALEDIT, sz); } // PrintEditTimeInDlg #endif _ABBREVIATED_DOCPROP_ //////////////////////////////////////////////////////////////////////////////// // // SetEditValLpsz // // Purpose: // If this PropVariant holds a LPTSTR, it is written // to the caller-specified Edit Control. If it is not // an LPTSTR, it is not treated as an error (it might // simply be a VT_EMPTY ... a non-existent property). // //////////////////////////////////////////////////////////////////////////////// #ifndef _ABBREVIATED_DOCPROP_ void PASCAL SetEditValLpsz( LPPROPVARIANT lppropvar, // PropVariant HWND hDlg, // Dialog handle DWORD dwID ) // Edit control ID { if (lppropvar->vt == VT_LPTSTR) { SendDlgItemMessage (hDlg, dwID, WM_SETTEXT, 0, (LPARAM) lppropvar->pszVal); PropVariantClear( lppropvar ); } } #endif //////////////////////////////////////////////////////////////////////////////// // // GetEditValLpsz // // Purpose: // Reads the string from the caller-specified edit // control, and loads it into a PropVariant. // If the Edit control says that it has not been // modified, then we don't read anything, and // return FALSE. // //////////////////////////////////////////////////////////////////////////////// #ifndef _ABBREVIATED_DOCPROP_ BOOL PASCAL GetEditValLpsz( LPPROPVARIANT lppropvar, // Sum info PropVariants HWND hDlg, // Dialog handle DWORD dwId) // Edit control id { BOOL fChanged = FALSE; DWORD cb, cch; // Did the data change? if ((BOOL) SendDlgItemMessage (hDlg, dwId, EM_GETMODIFY, 0, 0)) { LPTSTR tszNew; // Yes, it changed. Ask the Edit control how big the // string is. cch = (DWORD)SendDlgItemMessage (hDlg, dwId, WM_GETTEXTLENGTH, 0, 0); cb = ( cch + 1 ) * sizeof (TCHAR); // Includes the NULL. // Allocate a new string for this PropVariant, and set // the VT. if ( !(tszNew = CoTaskMemAlloc (cb))) { goto Exit; } PropVariantClear( lppropvar ); lppropvar->vt = VT_LPTSTR; (LPTSTR) lppropvar->pszVal = tszNew; // Get the string from the edit control into the buffer // (the size of the buffer in characters is cch+1, including // the NULL). SendDlgItemMessage (hDlg, dwId, WM_GETTEXT, (WPARAM) cch+1, (LPARAM) lppropvar->pszVal); fChanged = TRUE; } // if ((BOOL) SendDlgItemMessage (hDlg, dwId, EM_GETMODIFY, 0, 0)) // ---- // Exit // ---- Exit: return (fChanged); } // GetEditValLpsz #endif //_ABBREVIATED_DOCPROP_ //////////////////////////////////////////////////////////////////////////////// // // FAllocAndGetValLpstz // // Purpose: // Gets the value from the edit box into the local buffer. // //////////////////////////////////////////////////////////////////////////////// BOOL PASCAL FAllocAndGetValLpstz ( HWND hDlg, // Handle of dialog control is in DWORD dwId, // Id of control LPTSTR *lplpstz) // Buffer { DWORD cch; cch = (DWORD)SendDlgItemMessage (hDlg, dwId, WM_GETTEXTLENGTH, 0, 0); cch++; if (FAllocString (lplpstz, cch)) { // Get the entry. Remember to null-terminate it. cch = (DWORD)SendDlgItemMessage (hDlg, dwId, WM_GETTEXT, cch, (LPARAM) PSTR (*lplpstz)); ((LPTSTR)(PSTR (*lplpstz)))[cch] = TEXT('\0'); return TRUE; } return FALSE; } // FAllocAndGetValLpstz //////////////////////////////////////////////////////////////////////////////// // // FAllocString // // Purpose: // Allocates a string big enough to to hold cch char's. Only allocates if needed. // //////////////////////////////////////////////////////////////////////////////// BOOL PASCAL FAllocString ( LPTSTR *lplpstz, DWORD cch) { // Figure out how many bytes we need to allocate. DWORD cbNew = (cch * sizeof(TCHAR)); // And how many bytes we need to free. DWORD cbOld = *lplpstz == NULL ? 0 : (CchTszLen (*lplpstz) + 1) * sizeof(TCHAR); // If we need to free or allocate data. if (*lplpstz == NULL || cbNew > cbOld) { LPTSTR lpszNew; // Allocate the new data. lpszNew = PvMemAlloc(cbNew); if (lpszNew == NULL) { return FALSE; } // Free the old data. if (*lplpstz != NULL) VFreeMemP(*lplpstz, cbOld); *lplpstz = lpszNew; } // Make this a valid (empty) string. **lplpstz = TEXT('\0'); return TRUE; } // FAllocString //////////////////////////////////////////////////////////////////////////////// // // ClearEditControl // // Purpose: // Clears any text from an edit control // //////////////////////////////////////////////////////////////////////////////// void PASCAL ClearEditControl (HWND hDlg, // Dialog handle DWORD dwId) // Id of edit control { // Really cheesey. Clear the edit control by selecting // everything then clearing the selection if (dwId == 0) { SendMessage (hDlg, EM_SETSEL, 0, -1); SendMessage (hDlg, WM_CLEAR, 0, 0); } else { SendDlgItemMessage (hDlg, dwId, EM_SETSEL, 0, -1); SendDlgItemMessage (hDlg, dwId, WM_CLEAR, 0, 0); } } // ClearEditControl //////////////////////////////////////////////////////////////////////////////// // // UdtypesGetNumberType // // Purpose: // Gets the number type from the string and returns the value, either // a float or dword in numval. // //////////////////////////////////////////////////////////////////////////////// UDTYPES PASCAL UdtypesGetNumberType (LPTSTR lpstz, // String containing the number NUM *lpnumval, // The value of the number BOOL (*lpfnFSzToNum)(NUM *, LPTSTR)) // Sz To Num routine, can be null { TCHAR *pc; errno = 0; *(DWORD *) lpnumval = strtol ((LPTSTR)PSTR (lpstz), &pc, 10); if ((!errno) && (*pc == TEXT('\0'))) return wUDdw; // Try doing a float conversion if int fails if (lpfnFSzToNum != NULL) { if ((*lpfnFSzToNum)(lpnumval, (LPTSTR)PSTR(lpstz))) return wUDfloat; } return wUDinvalid; } // UdtypesGetNumberType //////////////////////////////////////////////////////////////////////////////// // // YearIndexFromShortDateFormat // // // Determines the zero-based position index of the year component // of a textual representation of the date based on the specified date format. // This value may be used as the iYear arg to ScanDateNums function. // //////////////////////////////////////////////////////////////////////////////// int YearIndexFromShortDateFormat( TCHAR chFmt ) { switch( chFmt ) { case MMDDYY: case DDMMYY: return 2; case YYMMDD: return 0; } return -1; } //////////////////////////////////////////////////////////////////////////////// // // IsGregorian // // Purpose: // Reports whether the specified calendar is a gregorian calendar. // //////////////////////////////////////////////////////////////////////////////// BOOL IsGregorian( CALID calid ) { switch (calid) { case CAL_GREGORIAN: case CAL_GREGORIAN_US: case CAL_GREGORIAN_ME_FRENCH: case CAL_GREGORIAN_ARABIC: case CAL_GREGORIAN_XLIT_ENGLISH: case CAL_GREGORIAN_XLIT_FRENCH: return TRUE; // these are non-gregorian: //case CAL_JAPAN //case CAL_TAIWAN //case CAL_KOREA //case CAL_HIJRI //case CAL_THAI //case CAL_HEBREW } return FALSE; } //////////////////////////////////////////////////////////////////////////////// // // GregorianYearFromAbbreviatedYear // // Purpose: // Based on current locale settings, calculates the year corresponding to the // specified 1- or 2-digit abbreviated value. // //////////////////////////////////////////////////////////////////////////////// int GregorianYearFromAbbreviatedYear( LCID lcid, CALID calid, int nAbbreviatedYear ) { TCHAR szData[16]; LONG nYearHigh = -1; int nBaseCentury; int nYearInCentury = 0; // We're handling two-digit values for gregorian calendars only if (nAbbreviatedYear < 100) { // We don't support non-gregorian date windowing here // because that would be insanely complex and prone to error -ccooney 2000/02/04 if( !IsGregorian( calid ) || !GetCalendarInfo( lcid, calid, CAL_ITWODIGITYEARMAX|CAL_RETURN_NUMBER, NULL, 0, &nYearHigh ) ) { // In the absence of a default, use 2029 as the cutoff, just like monthcal. nYearHigh = 2029; } // // Copy the century of nYearHigh into nAbbreviatedYear. // nAbbreviatedYear += (nYearHigh - nYearHigh % 100); // // If it exceeds the max, then drop to previous century. // if (nAbbreviatedYear > nYearHigh) nAbbreviatedYear -= 100; } return nAbbreviatedYear; } //////////////////////////////////////////////////////////////////////////////// // // FConvertDate // // Purpose: // Converts the given string to a date. // //////////////////////////////////////////////////////////////////////////////// BOOL PASCAL FConvertDate (LPTSTR lpstz, // String having the date LPFILETIME lpft) // The date in FILETIME format { FILETIME ft; SYSTEMTIME st; TCHAR szSep[3]; TCHAR szFmt[10]; TCHAR szCalID[8]; unsigned int ai[3]; int iYear =-1; // index of ai member that represents the year value CALID calid; TCHAR szDate[256]; TCHAR szMonth[256]; TCHAR *pch; TCHAR *pchT; DWORD cch; DWORD i; if (!(GetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_IDATE, szFmt, ARRAYSIZE(szFmt))) || !(GetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_SDATE, szSep, ARRAYSIZE(szSep))) || !(GetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_ICALENDARTYPE, szCalID, ARRAYSIZE(szCalID))) ) return FALSE; iYear = YearIndexFromShortDateFormat(szFmt[0]); // Augh! It's an stz so we need to pass the DWORDs at the start if (!ScanDateNums(lpstz, szSep, ai, sizeof(ai)/sizeof(unsigned int),iYear)) { // Could be that the string contains the short version of the month, e.g. 03-Mar-95 PbMemCopy(szDate, lpstz, CBTSTR(lpstz)); pch = szDate; // Let's get to the first character of the month, if there is one while((isdigit(*pch) || (*pch == szSep[0])) && (*pch != 0)) ++pch; // If we got to the end of the string, there really was an error if (*pch == 0) return(FALSE); // Let's find the length of the month string pchT = pch+1; while ((*pchT != szSep[0]) && (*pchT != 0)) ++pchT; cch = (DWORD)(pchT - pch); // Loop through all the months and see if we match one // There can be 13 months for (i = 1; i <= 13; ++i) { if (!GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVMONTHNAME1+i-1, szMonth, ARRAYSIZE(szMonth))) return(FALSE); if (CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE | NORM_IGNOREKANATYPE | NORM_IGNOREWIDTH, pch, cch, szMonth, CchTszLen(szMonth)) == 2) break; } if (i > 13) return(FALSE); // We found the month. wsprintf zero-terminates cch = wsprintf(pch, TEXT("%u"), i); pch += cch; while (*pch++ = *(pch+1)); // Try and convert again if (!ScanDateNums(szDate, szSep, ai, 3, iYear)) return(FALSE); } // if (!ScanDateNums(lpstz, szSep, ai, 3)) FillBuf (&st, 0, sizeof(st)); switch (szFmt[0]) { case MMDDYY: st.wMonth = (WORD)ai[0]; st.wDay = (WORD)ai[1]; st.wYear = (WORD)ai[2]; break; case DDMMYY: st.wDay = (WORD)ai[0]; st.wMonth = (WORD)ai[1]; st.wYear = (WORD)ai[2]; break; case YYMMDD: st.wYear = (WORD)ai[0]; st.wMonth = (WORD)ai[1]; st.wDay = (WORD)ai[2]; break; default: return FALSE; } if (st.wYear < ONECENTURY) { calid = strtol( szCalID, NULL, 10 ); st.wYear = (WORD)GregorianYearFromAbbreviatedYear( LOCALE_USER_DEFAULT, calid, st.wYear ); } if (!SystemTimeToFileTime (&st, &ft)) return(FALSE); return(LocalFileTimeToFileTime(&ft, lpft)); } // FConvertDate //////////////////////////////////////////////////////////////////////////////// // // PopulateUDListView // // Purpose: // Populates the entire ListView with the User-defined properties // in the given object. // //////////////////////////////////////////////////////////////////////////////// void PASCAL PopulateUDListView (HWND hWnd, // Handle of list view window LPUDOBJ lpUDObj) // UD Prop object { LPUDITER lpudi; LPPROPVARIANT lppropvar; BOOL fLink; BOOL fLinkInvalid; // Iterate through the list of user-defined properties, adding each // one to the listview. for( lpudi = LpudiUserDefCreateIterator (lpUDObj); FUserDefIteratorValid (lpudi); FUserDefIteratorNext (lpudi) ) { // Get the name of this property. LPTSTR tszPropertyName = LpszUserDefIteratorName( lpudi, 1, (LPTSTR) UD_PTRWIZARD ); // If the property has no name, or the name indicates that it // is a hidden property, then move on to the next property. if( tszPropertyName == NULL || *tszPropertyName == HIDDENPREFIX ) { continue; } lppropvar = LppropvarUserDefGetIteratorVal (lpudi, &fLink, &fLinkInvalid); if (lppropvar == NULL) return; // If this isn't a supported type, don't display it. if( !ISUDTYPE(lppropvar->vt) ) continue; #ifdef SHELL // // In the Shell, we want all links to show up as invalid, so set that here... // fLinkInvalid = TRUE; #endif AddUDPropToListView (lpUDObj, hWnd, LpszUserDefIteratorName (lpudi, 1, (TCHAR *) UD_PTRWIZARD), lppropvar, -1, fLink, fLinkInvalid, FALSE); } // for( lpudi = LpudiUserDefCreateIterator (lpUDObj); ... FUserDefDestroyIterator (&lpudi); } // PopulateUDListView //////////////////////////////////////////////////////////////////////////////// // // AddUDPropToListView // // Purpose: // Adds the given property to the list view or updates an existing one // if iItem >= 0 // //////////////////////////////////////////////////////////////////////////////// void PASCAL AddUDPropToListView ( LPUDOBJ lpUDObj, HWND hWnd, // Handle of list view LPTSTR lpszName, // Name of property LPPROPVARIANT lppropvar, // The property value. int iItem, // Index to add item at BOOL fLink, // Indicates the value is a link BOOL fLinkInvalid, // Is the link invalid? BOOL fMakeVisible) // Should the property be forced to be visible { LV_ITEM lvi; TCHAR sz[BUFMAX]; WORD irg; BOOL fSuccess; BOOL fUpdate; // If iItem >= 0, then the item should be updated, otherwise, // it should be added. if (fUpdate = (iItem >= 0)) { lvi.iItem = iItem; if (fLink) lvi.iImage = (fLinkInvalid) ? giInvLinkIcon : giLinkIcon; else lvi.iImage = giBlankIcon; lvi.mask = LVIF_IMAGE; lvi.iSubItem = iszNAME; fSuccess = ListView_SetItem (hWnd, &lvi); Assert (fSuccess); // We don't *really* care, just want to know when it happens } else { // This always adds to the end of the list.... lvi.iItem = ListView_GetItemCount (hWnd); // First add the label to the list lvi.iSubItem = iszNAME; lvi.pszText = lpszName; if (fLink) lvi.iImage = (fLinkInvalid) ? giInvLinkIcon : giLinkIcon; else lvi.iImage = giBlankIcon; lvi.mask = LVIF_TEXT | LVIF_IMAGE; lvi.iItem = ListView_InsertItem (hWnd, &lvi); if (lvi.iItem == 0) ListView_SetItemState(hWnd, 0, LVIS_FOCUSED, LVIS_FOCUSED); } // Convert the data to a string and print it lvi.mask = LVIF_TEXT; irg = WUdtypeToSz (lppropvar, sz, BUFMAX, ((LPUDINFO)lpUDObj->m_lpData)->lpfnFNumToSz); lvi.pszText = sz; lvi.iSubItem = iszVAL; fSuccess = ListView_SetItem (hWnd, &lvi); Assert (fSuccess); // We don't *really* care, just want to know when it happens // Put the type in the listview lvi.iSubItem = iszTYPE; lvi.pszText = (LPTSTR) rgszTypes[irg]; fSuccess = ListView_SetItem (hWnd, &lvi); Assert (fSuccess); // We don't *really* care, just want to know when it happens if (fMakeVisible) { fSuccess = ListView_EnsureVisible(hWnd, lvi.iItem, FALSE); Assert (fSuccess); // We don't *really* care, just want to know when it happens } // if (fUpdate) // { // ListView_RedrawItems (hWnd, lvi.iItem, lvi.iItem); // UpdateWindow (hWnd); // } } // AddUDPropToListView //////////////////////////////////////////////////////////////////////////////// // // AddItemToListView // // Purpose: // Adds the given string and number to the end of a listview // //////////////////////////////////////////////////////////////////////////////// void PASCAL AddItemToListView (HWND hWnd, // ListView handle DWORD_PTR dw, // Number to add const TCHAR *lpsz, // String to add BOOL fString) // Indicates if dw is actually a string { LV_ITEM lvi; TCHAR sz[BUFMAX]; BOOL fSuccess; if (!fString) // _itoa (dw, sz, BASE10); wsprintf(sz, TEXT("%lu"), dw); // This always adds to the end of the list.... lvi.iItem = ListView_GetItemCount (hWnd); // First add the label to the list lvi.mask = LVIF_TEXT; lvi.iSubItem = iszNAME; lvi.pszText = (LPTSTR) lpsz; lvi.iItem = ListView_InsertItem (hWnd, &lvi); if (lvi.iItem == 0) // Adding the 1st item ListView_SetItemState(hWnd, 0, LVIS_FOCUSED, LVIS_FOCUSED); Assert ((lvi.iItem != -1)); // Then add the value lvi.mask = LVIF_TEXT; lvi.iSubItem = iszVAL; lvi.pszText = (fString) ? (LPTSTR) dw : sz; fSuccess = ListView_SetItem (hWnd, &lvi); Assert (fSuccess); } // AddItemToListView //////////////////////////////////////////////////////////////////////////////// // // InitListView // // Purpose: // Initializes a list view control // //////////////////////////////////////////////////////////////////////////////// void PASCAL InitListView (HWND hWndLV, // Handle of parent dialog int irgLast, // Index of last column in array TCHAR rgsz[][SHORTBUFMAX], // Array of column headings BOOL fImageList) // Should the listview have an image list { HICON hIcon; RECT rect; HIMAGELIST hImlS; LV_COLUMN lvc; int irg; lvc.mask = LVCF_FMT | LVCF_TEXT | LVCF_SUBITEM | LVCF_WIDTH; lvc.fmt = LVCFMT_LEFT; // Initially force all columns to be the same size & fill the control. GetClientRect(hWndLV, &rect); // Subtract fudge factor lvc.cx = (rect.right-rect.left)/(irgLast+1)-(GetSystemMetrics(SM_CXVSCROLL)/(irgLast+1)); // Add in all the columns. for (irg = 0; irg <= irgLast; irg++) { lvc.pszText = rgsz[irg]; lvc.iSubItem = irg; ListView_InsertColumn (hWndLV, irg, &lvc); } if (!fImageList) return; hIcon = LoadIcon (g_hmodThisDll, MAKEINTRESOURCE (IDD_BLANK_ICON)); if (hIcon != NULL) { hImlS = MsoImageList_Create (16, 16, TRUE, ICONSMAX, 0); ListView_SetImageList (hWndLV, hImlS, LVSIL_SMALL); giBlankIcon = MsoImageList_ReplaceIcon (hImlS, -1, hIcon); Assert ((giBlankIcon != -1)); } } // InitListView //////////////////////////////////////////////////////////////////////////////// // // FSwapControls // // Purpose: // Swaps the controls needed to display link info. // //////////////////////////////////////////////////////////////////////////////// BOOL PASCAL FSwapControls (HWND hWndVal, // Handle of Value window HWND hWndLinkVal, // Handle of Link Value Combo box HWND hWndBoolTrue, // Handle of True radio button HWND hWndBoolFalse, // Handle of False radio button HWND hWndGroup, // Handle of Group box HWND hWndType, // Handle of Type window HWND hWndValText, BOOL fLink, // Flag indicating a link BOOL fBool) // Flag indicating a bool { if (fLink) { SendMessage (hWndValText, WM_SETTEXT, 0, (LPARAM) rgszValue[iszSOURCE]); ShowWindow (hWndVal, SW_HIDE); ShowWindow (hWndBoolTrue, SW_HIDE); ShowWindow (hWndBoolFalse, SW_HIDE); ShowWindow (hWndGroup, SW_HIDE); ShowWindow (hWndLinkVal, SW_SHOW); EnableWindow (hWndType, FALSE); ClearEditControl (hWndVal, 0); } else { SendMessage (hWndValText, WM_SETTEXT, 0, (LPARAM) rgszValue[iszVALUE]); ShowWindow (hWndLinkVal, SW_HIDE); EnableWindow (hWndType, TRUE); if (fBool) { ShowWindow (hWndVal, SW_HIDE); ShowWindow (hWndBoolTrue, SW_SHOW); ShowWindow (hWndBoolFalse, SW_SHOW); ShowWindow (hWndGroup, SW_SHOW); SendMessage (hWndBoolTrue, BM_SETCHECK, (WPARAM) CHECKED, 0); SendMessage (hWndBoolFalse, BM_SETCHECK, (WPARAM) CLEAR, 0); SendMessage (hWndType, CB_SETCURSEL, iszBOOL, 0); ClearEditControl (hWndVal, 0); } else { ShowWindow (hWndVal, SW_SHOW); EnableWindow(hWndVal, TRUE); ShowWindow (hWndBoolTrue, SW_HIDE); ShowWindow (hWndBoolFalse, SW_HIDE); ShowWindow (hWndGroup, SW_HIDE); SendMessage (hWndType, CB_SETCURSEL, iszTEXT, 0); } } return TRUE; } // FSwapControls //////////////////////////////////////////////////////////////////////////////// // // PopulateControls // // Purpose: // Populates the edit controls with the appropriate date from the object // //////////////////////////////////////////////////////////////////////////////// VOID PASCAL PopulateControls ( LPUDOBJ lpUDObj, // Pointer to object LPTSTR szName, // Name of the item to populate controls with DWORD cLinks, // Number of links DWQUERYLD lpfnDwQueryLinkData, // Pointer to app link callback HWND hDlg, // Handle of the dialog HWND hWndName, // Handle of the Name window HWND hWndVal, // Handle of Value window HWND hWndValText, // Handle of Value LTEXT HWND hWndLink, // Handle of Link checkbox HWND hWndLinkVal, // Handle of Link Value window HWND hWndType, // Handle of Type window HWND hWndBoolTrue, // Handle of True radio button HWND hWndBoolFalse, // Handle of False radio button HWND hWndGroup, // Handle of Group window HWND hWndAdd, // Handle of Add button HWND hWndDelete, // Handle of Delete button BOOL *pfLink, // Indicates that the value is a link BOOL *pfAdd) // Indicates the state of the Add button { UDTYPES udtype; LPVOID lpv; LPPROPVARIANT lppropvar; // A property from the UDObj linked-list. BOOL f,fT; TCHAR sz[BUFMAX]; LPUDPROP lpudp; // Grab the type for the string and set up the dialog to have the right // controls to display it. udtype = UdtypesUserDefType (lpUDObj, szName); AssertSz ((udtype != wUDinvalid), TEXT("User defined properties or ListView corrupt")); // Get a name-specified property from the UD linked-list. lppropvar = LppropvarUserDefGetPropVal (lpUDObj, szName, pfLink, &fT); Assert (lppropvar != NULL || udtype == wUDbool || udtype == wUDdw); if (lppropvar == NULL) return; lpv = LpvoidUserDefGetPropVal (lpUDObj, szName, 1, NULL, UD_STATIC | UD_PTRWIZARD, pfLink, &fT); Assert((lpv != NULL) || (udtype == wUDbool) || (udtype == wUDdw)); FSwapControls (hWndVal, hWndLinkVal, hWndBoolTrue, hWndBoolFalse, hWndGroup, hWndType, hWndValText, *pfLink, (udtype == wUDbool)); SendMessage (hWndType, CB_SETCURSEL, (WPARAM) WUdtypeToSz (lppropvar, (TCHAR *) sz, BUFMAX, ((LPUDINFO)lpUDObj->m_lpData)->lpfnFNumToSz), 0); SendMessage (hWndLink, BM_SETCHECK, (WPARAM) *pfLink, 0); if (cLinks) // Let's make sure we enable the window if links are allowed EnableWindow(hWndLink, TRUE); if (*pfLink) { FCreateListOfLinks (cLinks, lpfnDwQueryLinkData, hWndLinkVal); lpv = LpvoidUserDefGetPropVal (lpUDObj, szName, 1, NULL, UD_LINK | UD_PTRWIZARD, pfLink, &fT); Assert (lpv != NULL || udtype == wUDbool || udtype == wUDdw); // if (lpfnDwQueryLinkData == NULL) // { // SetCustomDlgDefButton(hDlg, gOKButtonID); // EnableWindow (hWndAdd, FALSE); // SendMessage (hWndLinkVal, CB_INSERTSTRING, (WPARAM) -1, (LPARAM) lpv); // } AssertSz ((lpv != NULL), TEXT("Dialog is corrupt in respect to Custom Properties database")); // This code is added for bug 188 and the code is ugly !! :) lpudp = LpudpropFindMatchingName (lpUDObj, szName); if ((lpudp != NULL) && (lpudp->fLinkInvalid)) { SetCustomDlgDefButton(hDlg, IDD_CUSTOM_DELETE); SendMessage(hWndName, WM_SETTEXT, 0, (LPARAM)szName); SendMessage(hWndVal, WM_SETTEXT, 0, (LPARAM)lpv); EnableWindow(hWndDelete, TRUE); EnableWindow(hWndAdd, FALSE); EnableWindow(hWndLink, FALSE); EnableWindow(hWndType, FALSE); ShowWindow(hWndLinkVal, SW_HIDE); ShowWindow(hWndVal, SW_SHOW); EnableWindow(hWndVal, FALSE); return; } // Select the current link for this property in the combobox. If the link // name no longer exists (there's some contrived cases where this can // happen) then this will select nothing. SendMessage (hWndLinkVal, CB_SELECTSTRING, 0, (LPARAM) lpv); EnableWindow(hWndLink, TRUE); } else if (udtype == wUDbool) { SendMessage ((lpv) ? hWndBoolTrue : hWndBoolFalse, BM_SETCHECK, CHECKED, 0); SendMessage ((lpv) ? hWndBoolFalse : hWndBoolTrue, BM_SETCHECK, CLEAR, 0); EnableWindow(hWndType, TRUE); } else { SendMessage (hWndVal, WM_SETTEXT, 0, (LPARAM) sz); EnableWindow (hWndVal, TRUE); EnableWindow(hWndType, TRUE); } if (*pfAdd) { SendMessage (hWndAdd, WM_SETTEXT, 0, (LPARAM) rgszAdd[iszMODIFY]); *pfAdd = FALSE; } // HACK: Because the EN_UPDATE handler for hWndName checks fAdd to // see if the button should be set to Add, when we set the text // in the edit control, the button will change to Add unless // fAdd is set to TRUE. Temporarily set the flag to TRUE to force // the button to not change. Restore the original value after the // text has been set. f = *pfAdd; *pfAdd = TRUE; SendMessage (hWndName, WM_SETTEXT, 0, (LPARAM) szName); *pfAdd = f; // If we can fill the data in the controls, turn on the // Delete button too. // fItemSel = TRUE; EnableWindow (hWndDelete, TRUE); SetCustomDlgDefButton(hDlg, gOKButtonID); EnableWindow (hWndAdd, FALSE); } // PopulateControls //////////////////////////////////////////////////////////////////////////////// // // FSetupAddButton // // Purpose: // Sets up the Add button correctly based on the type & flags. // //////////////////////////////////////////////////////////////////////////////// BOOL PASCAL FSetupAddButton (DWORD iszType, // Index of the type in combobox BOOL fLink, // Indicates a link BOOL *pfAdd, // Indicates if the Add button is showing HWND hWndAdd, // Handle of Add button HWND hWndVal, // Handle of value button HWND hWndName, // Handle of Name HWND hDlg) // Handle of dialog { // Once the user starts typing, we can enable the Add button // if there is text in the name & the value (unless this // is a link or boolean, in which case we don't care about // the value). BOOL f; if ((iszType != iszBOOL) && (!fLink)) { if (SendMessage (hWndVal, EM_LINELENGTH, 0, 0) != 0) { f = (SendMessage (hWndName, WM_GETTEXTLENGTH, 0, 0) != 0); if (f) SetCustomDlgDefButton(hDlg, IDD_CUSTOM_ADD); else SetCustomDlgDefButton(hDlg, gOKButtonID); EnableWindow (hWndAdd, f); } else { SetCustomDlgDefButton(hDlg, gOKButtonID); EnableWindow (hWndAdd, FALSE); } } // If it's a bool or link, just check to see that the name // has stuff in it. else { f = SendMessage (hWndName, WM_GETTEXTLENGTH, 0, 0) != 0; if (f) SetCustomDlgDefButton(hDlg, IDD_CUSTOM_ADD); else SetCustomDlgDefButton(hDlg, gOKButtonID); EnableWindow (hWndAdd, f); } if (!*pfAdd) { SendMessage (hWndAdd, WM_SETTEXT, 0, (LPARAM) rgszAdd[iszADD]); *pfAdd = TRUE; } return TRUE; } // FSetupAddButton //////////////////////////////////////////////////////////////////////////////// // // WUdtypeToSz // // Purpose: // Converts the given type into a string representation. Returns the // index in the type combobox of the type. // //////////////////////////////////////////////////////////////////////////////// WORD PASCAL WUdtypeToSz ( LPPROPVARIANT lppropvar, // Value with the type to be converted. LPTSTR sz, // Buffer to put converted val in DWORD cchMax, // Size of buffer (in chars) BOOL (*lpfnFNumToSz)(NUM *, LPTSTR, DWORD)) { SYSTEMTIME st; WORD irg; FILETIME ft; Assert (lppropvar != NULL); switch (lppropvar->vt) { case wUDlpsz : PbSzNCopy (sz, lppropvar->pwszVal, cchMax); irg = iszTEXT; break; case wUDdate : if (FScanMem((LPBYTE)&lppropvar->filetime, 0, sizeof(FILETIME))) // if the date struct is all 0's { *sz = 0; // display the empty string } else if (!FileTimeToLocalFileTime(&lppropvar->filetime, &ft) || !FileTimeToSystemTime (&ft, &st) || (!GetDateFormat (LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, sz, cchMax))) { #ifdef DEBUG DWORD dwErr = GetLastError(); #endif DEBUG irg = iszUNKNOWN; *sz = 0; break; } irg = iszDATE; break; case wUDdw : Assert(cchMax >= 11); Assert(lppropvar->vt == VT_I4); wsprintf (sz, TEXT("%ld"), lppropvar->lVal); irg = iszNUM; break; case wUDfloat : if (lpfnFNumToSz != NULL) irg = (*lpfnFNumToSz)((NUM*)&lppropvar->dblVal, sz, cchMax) ? iszNUM : iszUNKNOWN; else { irg = iszUNKNOWN; *sz = 0; } break; case wUDbool : PbSzNCopy (sz, lppropvar->boolVal ? (LPTSTR) &rgszBOOL[iszTRUE] : (LPTSTR) &rgszBOOL[iszFALSE], cchMax); irg = iszBOOL; break; default : irg = iszUNKNOWN; } // switch return irg; } // WUdtypeToSz //////////////////////////////////////////////////////////////////////////////// // // FCreateListOfLinks // // Purpose: // Creates the dropdown list of linkable items. // //////////////////////////////////////////////////////////////////////////////// BOOL PASCAL FCreateListOfLinks( DWORD cLinks, // Number of links DWQUERYLD lpfnDwQueryLinkData, // Link data callback HWND hWndLinkVal) // Link Value window handle { DWORD irg; LPTSTR lpstz; // If the combobox is already filled, don't fill it if (irg = (int)SendMessage(hWndLinkVal, CB_GETCOUNT,0, 0)) { Assert(irg == cLinks); return(TRUE); } lpstz = NULL; // Call back the client app to get the list of linkable // values, and put them in the value combobox. for (irg = 0; irg < cLinks; irg++) { lpstz = (TCHAR *) ((*lpfnDwQueryLinkData) (QLD_LINKNAME, irg, &lpstz, NULL)); if (lpstz != NULL) { SendMessage (hWndLinkVal, CB_INSERTSTRING, (WPARAM) -1, (LPARAM) PSTR (lpstz)); VFreeMemP(lpstz, CBTSTR(lpstz)); // REVIEW: We probably ought to figure out a way to be more efficient here.... } } return TRUE; } // FCreateListOfLinks //////////////////////////////////////////////////////////////////////////////// // // FSetTypeControl // // Purpose: // Sets the type control to have the given type selected. // //////////////////////////////////////////////////////////////////////////////// BOOL PASCAL FSetTypeControl ( UDTYPES udtype, // Type to set the type to HWND hWndType) // Handle of type control { WORD iType; switch (udtype) { case wUDlpsz : iType = iszTEXT; break; case wUDfloat : case wUDdw : iType = iszNUM; break; case wUDbool : iType = iszBOOL; break; case wUDdate : iType = iszDATE; break; default: return FALSE; } SendMessage (hWndType, CB_SETCURSEL, (WPARAM) iType, 0); return TRUE; } // FSetTypeControl //////////////////////////////////////////////////////////////////////////////// // // DeleteItem // // Purpose: // Deletes an item from the UD object and the listview. // //////////////////////////////////////////////////////////////////////////////// void PASCAL DeleteItem ( LPUDOBJ lpUDObj, HWND hWndLV, int iItem, TCHAR sz[]) { int i; ListView_DeleteItem (hWndLV, iItem); FUserDefDeleteProp (lpUDObj, sz); // We just nuked the item with the focus, so let's get the new one // if there are still items in the listview if ((i = ListView_GetItemCount(hWndLV)) != 0) { // Figure out the index of the item to get the focus i = (i == iItem) ? iItem - 1 : iItem; ListView_SetItemState(hWndLV, i, LVIS_FOCUSED, LVIS_FOCUSED); } } // DeleteItem //////////////////////////////////////////////////////////////////////////////// // // ResetTypeControl // // Purpose: // Resets the value of the type control to Text. // //////////////////////////////////////////////////////////////////////////////// void PASCAL ResetTypeControl ( HWND hDlg, // Handle of dialog DWORD dwId, // Id of control DWORD *piszType) // The type we've reset to { SendDlgItemMessage (hDlg, dwId, CB_SETCURSEL, iszTEXT, 0); *piszType = iszTEXT; } // ResetTypeControl //////////////////////////////////////////////////////////////////////////////// // // FDisplayConversionWarning // // Purpose: // Displays a warning about types being converted. Returns TRUE if // the user presses "Cancel" // //////////////////////////////////////////////////////////////////////////////// BOOL PASCAL FDisplayConversionWarning(HWND hDlg) // Handle of parent window { return (IdDoAlert(hDlg, idsPEWarningText, MB_ICONEXCLAMATION | MB_OKCANCEL) == IDCANCEL); } // FDisplayConversionWarning //////////////////////////////////////////////////////////////////////////////// // // LoadTextStrings // // Purpose: // Loads all of the text needed by the dialogs from the DLL. // //////////////////////////////////////////////////////////////////////////////// BOOL PASCAL FLoadTextStrings (void) { register int cLoads = 0; register int cAttempts = 0; // CchGetString returns a cch, so make it into a 1 or 0 // then add up the results,making sure we load as many as // we try. cLoads += (CchGetString (idsPEB, rgszOrders[iszBYTES], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEKB, rgszOrders[iszORDERKB], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEMB, rgszOrders[iszORDERMB], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEGB, rgszOrders[iszORDERGB], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPETB, rgszOrders[iszORDERTB], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEBytes, rgszStats[iszBYTES], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEPages, rgszStats[iszPAGES], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEPara, rgszStats[iszPARA], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPELines, rgszStats[iszLINES], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEWords, rgszStats[iszWORDS], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEChars, rgszStats[iszCHARS], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPESlides, rgszStats[iszSLIDES], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPENotes, rgszStats[iszNOTES], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEHiddenSlides, rgszStats[iszHIDDENSLIDES], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEMMClips, rgszStats[iszMMCLIPS], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEFormat, rgszStats[iszFORMAT], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEText, rgszTypes[iszTEXT], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEDate, rgszTypes[iszDATE], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPENumber, rgszTypes[iszNUM], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEBool, rgszTypes[iszBOOL], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEUnknown, rgszTypes[iszUNKNOWN], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEStatName, rgszStatHeadings[iszNAME], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEValue, rgszStatHeadings[iszVAL], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEPropName, rgszHeadings[iszNAME], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEValue, rgszHeadings[iszVAL], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEType, rgszHeadings[iszTYPE], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPETrue, rgszBOOL[iszTRUE], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEFalse, rgszBOOL[iszFALSE], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEAdd, rgszAdd[iszADD], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEModify, rgszAdd[iszMODIFY], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPESource, rgszValue[iszSOURCE], SHORTBUFMAX) && TRUE); cAttempts++; cLoads += (CchGetString (idsPEValueColon, rgszValue[iszVALUE], BUFMAX) && TRUE); cAttempts++; return (cLoads == cAttempts); } // LoadTextStrings // // Function: ISavePropDlgChanges // // Parameters: // // hwndDlg - dialog window handle // hwndFrom - window handle from the NMHDR struct (see code above) // // Returns: // // TRUE since we handled the message. // // History: // // Created 09/16/94 martinth // int PASCAL ISavePropDlgChanges(LPALLOBJS lpallobjs, HWND hwndDlg, HWND hwndFrom) { TCHAR sz[BUFMAX]; int iRet = IDABORT; // MessageBox return. LRESULT lRet = 0L; // (FALSE == dismiss property sheet). if (CchGetString(idsCustomWarning, sz, ARRAYSIZE(sz)) == 0) return(FALSE); lpallobjs->fPropDlgPrompted = TRUE; // no warning next time! iRet = MessageBox( hwndDlg, sz, TEXT("Warning"), MB_ICONEXCLAMATION | MB_YESNOCANCEL ); switch( iRet ) { case IDYES: PropSheet_Apply(hwndFrom); // Let's get them changes break; // case IDNO: // do nothing case IDCANCEL: // cancel and disallow sheet destroy. lRet = TRUE; break; } SetWindowLongPtr( hwndDlg, DWLP_MSGRESULT, lRet ); return iRet; }