3547 lines
131 KiB
C
3547 lines
131 KiB
C
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 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 <winnls.h>
|
|
#include <prsht.h>
|
|
#include <commctrl.h>
|
|
#include <shlwapi.h>
|
|
#include <shlapip.h>
|
|
|
|
|
|
#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;
|
|
}
|