able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/shdocvw/thicket.cpp

1539 lines
46 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1994
//
// File: persist.cxx
//
// Contents: Implmentation of Office9 Thicket Save API
//
//----------------------------------------------------------------------------
#include "priv.h"
//#include "headers.hxx"
//#include "formkrnl.hxx"
#include <platform.h>
#include <mlang.h>
#include "resource.h"
#include "impexp.h"
#include "reload.h"
//#include <siterc.h>
#include "packager.h"
#include "iehelpid.h"
#include "thicket.h"
#include "apithk.h"
#include <mluisupp.h>
#include <mshtmcid.h>
#define NUM_OLE_CMDS 1
#define SAVEAS_OK 0x00000001
#define SAVEAS_NEVER_ASK_AGAIN 0x00000002
#define CODEPAGE_UNICODE 0x000004B0
#define CODEPAGE_UTF8 0x0000FDE9
#define UNICODE_TEXT TEXT("Unicode")
#define REGSTR_VAL_SAVEDIRECTORY TEXT("Save Directory")
#define REGKEY_SAVEAS_WARNING_RESTRICTION TEXT("SOFTWARE\\Microsoft\\Internet Explorer\\Main")
#define REGVALUE_SAVEAS_WARNING TEXT("NoSaveAsPOSTWarning")
#define WM_WORKER_THREAD_COMPLETED WM_USER + 1000
#define MAX_ENCODING_DESC_LEN 1024
const static DWORD aSaveAsHelpIDs[] =
{
IDC_SAVE_CHARSET, IDH_CHAR_SET_SAVE_AS,
0, 0
};
INT_PTR CALLBACK SaveAsWarningDlgProc(HWND hDlg, UINT msg, WPARAM wParam,
LPARAM lParam);
HRESULT SaveToThicket( HWND hwnd, LPCTSTR pszFileName, IHTMLDocument2 *pDoc,
UINT codepageSrc, UINT codepageDst,
UINT iPackageStyle );
HRESULT
FormsGetFileName(
HWND hwndOwner,
LPTSTR pstrFile,
int cchFile,
LPARAM lCustData,
DWORD *pnFilterIndex,
BOOL bForceHTMLOnly);
HRESULT
GetFileNameFromURL( LPWSTR pwszURL, LPTSTR pszFile, DWORD cchFile);
void ReportThicketError( HWND hwnd, HRESULT hr );
#define DOWNLOAD_PROGRESS 0x9001
#define DOWNLOAD_COMPLETE 0x9002
#define THICKET_TIMER 0x9003
#define THICKET_INTERVAL 1000
#define MDLGMSG(psz, x) TraceMsg(0, "shd TR-MODELESS::%s %x", psz, x)
static DWORD s_dwInetComVerMS = 0;
static DWORD s_dwInetComVerLS = 0;
struct ThicketCPInfo
{
UINT cpSrc;
UINT cpDst;
LPWSTR lpwstrDocCharSet;
};
class CThicketUI
{
public:
CThicketUI(void) :
_hDlg(NULL),
_hWndProg(NULL),
_iErrorDL(0),
_hrDL(E_FAIL),
#ifndef NO_MARSHALLING
_pstmDoc(NULL),
#else
_pDoc(NULL),
#endif
_pszFileName(NULL),
_dwDLMax(0),
_codepageSrc(0),
_codepageDst(0),
_iPackageStyle(PACKAGE_THICKET),
_fCancel(FALSE) {};
~CThicketUI(void)
{
#ifndef NO_MARSHALLING
SAFERELEASE(_pstmDoc);
#endif
SAFELOCALFREE(_pszFileName);
};
// CThicketUI methods
HRESULT SaveDocument( HWND hWnd, LPCTSTR pszFileName, IHTMLDocument2 *pDoc,
UINT codepageSrc, UINT codepageDst,
UINT iPackageStyle );
protected:
static BOOL_PTR ThicketUIDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam);
static DWORD WINAPI ThicketUIThreadProc( LPVOID );
BOOL DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam);
HWND _hDlg;
HWND _hWndProg;
int _iErrorDL;
HRESULT _hrDL;
#ifndef UNIX
IStream *_pstmDoc; // marshalled IHTMLDocument2
#else
IHTMLDocument2 *_pDoc;
#endif
LPTSTR _pszFileName;
DWORD _dwDLMax;
UINT _codepageSrc;
UINT _codepageDst;
BOOL _fThreadStarted;
UINT _iPackageStyle;
BOOL _fCancel;
};
HRESULT
CThicketUI::SaveDocument( HWND hWnd, LPCTSTR pszFileName, IHTMLDocument2 *pDoc,
UINT codepageSrc, UINT codepageDst,
UINT iPackageStyle)
{
_pszFileName = StrDup(pszFileName);
_codepageSrc = codepageSrc;
_codepageDst = codepageDst;
_iPackageStyle = iPackageStyle;
#ifndef NO_MARSHALLING
// We don't do anything with pDoc until we're on the worker thread,
// so marshall it.
_hrDL = CoMarshalInterThreadInterfaceInStream(IID_IHTMLDocument2, pDoc, &_pstmDoc);
if (SUCCEEDED(_hrDL))
#else
_pDoc = pDoc;
#endif
{
// Needs to be modal cuz we're going to work with pDoc on the worker thread
// so we don't want the user to navigate away from it, close the window, etc.
DialogBoxParam(MLGetHinst(), MAKEINTRESOURCE(IDD_SAVETHICKET),
hWnd, CThicketUI::ThicketUIDlgProc, (LPARAM)this);
// HWND hwnd = MLCreateDialogParamWrap(MLGetHinst(), MAKEINTRESOURCE(IDD_SAVETHICKET),
// NULL, CThicketUI::ThicketUIDlgProc, (LPARAM)this);
// if (!hwnd)
// _hrDL = E_FAIL;
}
return _hrDL;
}
BOOL_PTR
CThicketUI::ThicketUIDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
BOOL fRet = FALSE;
CThicketUI* ptui = NULL;
if (msg == WM_INITDIALOG)
{
ptui = (CThicketUI*)lParam;
}
else
ptui = (CThicketUI*)GetWindowLongPtr(hDlg, DWLP_USER);
if (ptui)
{
fRet = ptui->DlgProc(hDlg, msg, wParam, lParam);
if (msg == WM_DESTROY || msg == WM_WORKER_THREAD_COMPLETED)
{
SetWindowLongPtr(hDlg, DWLP_USER, lParam);
fRet = TRUE;
}
}
return fRet;
}
BOOL
CThicketUI::DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
BOOL fRet = TRUE;
switch (msg)
{
case WM_INITDIALOG:
_hDlg = hDlg;
_hWndProg = GetDlgItem(hDlg, IDC_THICKETPROGRESS);
SetWindowLongPtr(hDlg, DWLP_USER, lParam);
_hrDL = S_FALSE;
#ifndef NO_MARSHALLING
//_hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) ThicketUIThreadProc, this, 0, &_idThread);
if (!(_fThreadStarted = SHQueueUserWorkItem(ThicketUIThreadProc,
this,
0,
(DWORD_PTR)NULL,
(DWORD_PTR *)NULL,
"shdocvw.dll",
TPS_LONGEXECTIME)))
_hrDL = E_FAIL;
#else
ThicketUIThreadProc((LPVOID)this);
#endif
if (FAILED(_hrDL))
EndDialog(hDlg, 0);
else
{
ShowWindow(hDlg, SW_SHOWNORMAL);
Animate_OpenEx(GetDlgItem(hDlg, IDD_ANIMATE), HINST_THISDLL, IDA_DOWNLOAD);
ShowWindow(GetDlgItem(hDlg, IDD_DOWNLOADICON), SW_HIDE);
}
fRet = FALSE;
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDCANCEL:
_fCancel = TRUE;
// and wait for the worker thread to quit, polling at WM_TIMER
break;
default:
break;
}
break;
case WM_WORKER_THREAD_COMPLETED:
_hrDL = (DWORD) wParam;
EndDialog(hDlg,0);
break;
//case WM_CLOSE:
// KillTimer( hDlg, THICKET_TIMER );
// _fCancel = TRUE;
// while( _hrDL == S_FALSE );
// break;
case WM_DESTROY:
_fCancel = TRUE;
while( _hrDL == S_FALSE )
{
Sleep(0);
}
break;
default:
fRet = FALSE;
}
return fRet;
}
DWORD WINAPI CThicketUI::ThicketUIThreadProc( LPVOID ppv )
{
HRESULT hr = S_OK;
CThicketUI* ptui = (CThicketUI *)ppv;
ASSERT(ptui);
hr = CoInitialize(NULL);
if (SUCCEEDED(hr))
{
IHTMLDocument2 *pDoc = NULL;
#ifndef NO_MARSHALLING
hr = CoGetInterfaceAndReleaseStream( ptui->_pstmDoc, IID_IHTMLDocument2,(LPVOID*)&pDoc);
// CoGetInterfaceAndReleaseStream always releases the stream
ptui->_pstmDoc = NULL;
#else
pDoc = ptui->_pDoc;
pDoc->AddRef();
#endif
if (SUCCEEDED(hr))
{
CThicketProgress tprog( ptui->_hDlg );
CDocumentPackager docPkgr(ptui->_iPackageStyle);
hr = S_FALSE;
hr = docPkgr.PackageDocument( pDoc, ptui->_pszFileName,
&ptui->_fCancel, &tprog,
0, 100,
ptui->_codepageDst );
pDoc->Release(); // release marshalled interface
}
CoUninitialize();
}
PostMessage(ptui->_hDlg, WM_WORKER_THREAD_COMPLETED, hr, 0);
return 0;
}
//+------------------------------------------------------------------------
//
//
//
//-------------------------------------------------------------------------
HRESULT
SaveToThicket( HWND hWnd, LPCTSTR pszFileName, IHTMLDocument2 *pDoc,
UINT codepageSrc, UINT codepageDst, UINT iPackageStyle )
{
HRESULT hr;
CThicketUI* ptui;
#ifdef OLD_THICKET
LPTSTR lpszURL;
lpszURL = bstrDocURL;
const DWORD dwMaxPathLen = 24;
URL_COMPONENTS urlComp;
TCHAR rgchUrlPath[MAX_PATH];
TCHAR rgchCanonicalUrl[MAX_URL_STRING];
DWORD dwLen;
dwLen = ARRAYSIZE(rgchCanonicalUrl);
hr = UrlCanonicalize( lpszURL, rgchCanonicalUrl, &dwLen, 0);
if (FAILED(hr))
return E_FAIL;
ZeroMemory(&urlComp, sizeof(urlComp));
urlComp.dwStructSize = sizeof(urlComp);
urlComp.lpszUrlPath = rgchUrlPath;
urlComp.dwUrlPathLength = ARRAYSIZE(rgchUrlPath);
hr = InternetCrackUrl(rgchCanonicalUrl, lstrlen(rgchCanonicalUrl), ICU_DECODE, &urlComp);
if (FAILED(hr))
return E_FAIL;
// Since this is not a snap-shot, saving the doc over itself is a no-op.
// This means we can avoid some nasty issues with the save-over, safe-save,
// et al, by short circuiting the save here.
if ( StrCmpI(pszFileName, rgchUrlPath) == 0 )
{
if (PathFileExists(pszFileName))
return S_OK;
else
return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
}
#endif //OLD_THICKET
ptui = new CThicketUI;
if (ptui)
{
hr = ptui->SaveDocument( hWnd, pszFileName, pDoc, codepageSrc, codepageDst, iPackageStyle );
delete ptui;
}
else
hr = E_OUTOFMEMORY;
return hr;
}
//+------------------------------------------------------------------------
//
//
//
//-------------------------------------------------------------------------
void SaveBrowserFile( HWND hwnd, LPUNKNOWN punk )
{
HRESULT hr;
TCHAR szFileDst[MAX_PATH];
DWORD iFilter = 1;
IHTMLDocument2 *pDoc;
BSTR bstrURL = NULL;
ThicketCPInfo tcpi;
BSTR bstrCharSet = NULL;
BSTR bstrTitle = NULL;
BSTR bstrMime = NULL;
IOleCommandTarget *pOleCommandTarget = NULL;
WCHAR *pwzExt = NULL;
OLECMD pCmd[NUM_OLE_CMDS];
ULONG nCmds = NUM_OLE_CMDS;
BOOL bForceHTMLOnly = FALSE;
static const WCHAR *wzImage = L" Image";
hr = punk->QueryInterface(IID_IHTMLDocument2, (void**)&pDoc);
if (FAILED(hr))
goto Cleanup;
if (FAILED(pDoc->get_URL( &bstrURL )))
goto Cleanup;
hr = pDoc->get_charset( &bstrCharSet );
if (FAILED(hr))
goto Cleanup;
tcpi.cpSrc = CP_ACP;
tcpi.lpwstrDocCharSet = bstrCharSet;
// If it is an image file, then bring up trident to do the save.
// APPCOMPAT: This is a crappy way to do this. We are hard-coding the
// image types, so we know to put up the "Save as image" dialog.
// We originally tried looking at the MIME type, but Trident returns
// inconsistent MIME types to us (ex. under some platforms we get
// "JPG Image" and under others we get "JPG File"!).
ASSERT(bstrURL);
pwzExt = bstrURL + lstrlenW(bstrURL);
while (pwzExt > bstrURL && *pwzExt != L'.')
{
pwzExt--;
}
hr = pDoc->QueryInterface(IID_IOleCommandTarget,
(void **)&pOleCommandTarget);
if (FAILED(hr))
{
goto Cleanup;
}
if (pwzExt > bstrURL) {
// Found a "dot". Now pwzExt points to what we think is the extension
if (!StrCmpIW(pwzExt, L".JPG") ||
!StrCmpIW(pwzExt, L".GIF") ||
!StrCmpIW(pwzExt, L".BMP") ||
!StrCmpIW(pwzExt, L".XBM") ||
!StrCmpIW(pwzExt, L".ART") ||
!StrCmpIW(pwzExt, L".PNG") ||
!StrCmpIW(pwzExt, L".WMF") ||
!StrCmpIW(pwzExt, L".TIFF") ||
!StrCmpIW(pwzExt, L".JPEG"))
{
hr = pOleCommandTarget->Exec(&CGID_MSHTML, IDM_SAVEPICTURE, 0,
NULL, NULL);
// FEATURE: Handle a failed HR here. It is very unlikely that
// this will fail, yet regular save-as code (that follows)
// will succeed. We always exit out of here, so we will
// never get two UI dialogs thrown at the user. We should
// come up with a good scheme to propagate an error dialog
// to the user. Possible scenario: low disk space causing
// a fail-out.
goto Cleanup;
}
}
// IE5 RAID #54672: Save-as has problems saving pages generated by POSTs
// This code is to detect if the page was generated by POST data and
// warn the user that saving may not work.
pCmd[0].cmdID = SHDVID_PAGEFROMPOSTDATA;
hr = pOleCommandTarget->QueryStatus(&CGID_ShellDocView, nCmds, pCmd, NULL);
if (FAILED(hr))
{
goto Cleanup;
}
if (pCmd[0].cmdf & OLECMDF_LATCHED)
{
HKEY hkeySaveAs = 0;
DWORD dwValue = 0;
DWORD dwSize = 0;
INT_PTR iFlags = 0;
bForceHTMLOnly = TRUE;
if (RegOpenKeyEx(HKEY_CURRENT_USER,
REGKEY_SAVEAS_WARNING_RESTRICTION, 0,
KEY_READ, &hkeySaveAs) == ERROR_SUCCESS)
{
dwSize = sizeof(DWORD);
if (RegQueryValueEx(hkeySaveAs, REGVALUE_SAVEAS_WARNING, NULL,
NULL, (LPBYTE)&dwValue, &dwSize) == ERROR_SUCCESS)
{
if (dwValue)
{
// restriction set, don't show dialog
RegCloseKey(hkeySaveAs);
goto Continue;
}
}
RegCloseKey(hkeySaveAs);
}
iFlags = DialogBoxParam(MLGetHinst(), MAKEINTRESOURCE(DLG_SAVEAS_WARNING),
hwnd, SaveAsWarningDlgProc, (LPARAM)0);
if (!(iFlags & SAVEAS_OK))
{
goto Cleanup;
}
if (iFlags & SAVEAS_NEVER_ASK_AGAIN)
{
HKEY hkey = 0;
DWORD dwNeverAsk = 1;
if (RegOpenKeyEx(HKEY_CURRENT_USER,
REGKEY_SAVEAS_WARNING_RESTRICTION, 0,
KEY_ALL_ACCESS, &hkey) == ERROR_SUCCESS)
{
RegSetValueEx(hkey, REGVALUE_SAVEAS_WARNING, 0, REG_DWORD,
(CONST BYTE *)&dwNeverAsk,
sizeof(dwNeverAsk));
RegCloseKey(hkey);
}
}
}
Continue:
// Suggest a file name
szFileDst[0] = 0;
// Our favorite candidate is the title, fall back on the file name.
hr = pDoc->get_title(&bstrTitle);
if (SUCCEEDED(hr) && lstrlenW(bstrTitle))
{
StrCpyN(szFileDst, bstrTitle, ARRAYSIZE(szFileDst));
}
else
hr = GetFileNameFromURL(bstrURL, szFileDst, ARRAYSIZE(szFileDst));
if (FAILED(hr))
goto Cleanup;
PathCleanupSpec(NULL, szFileDst);
hr = FormsGetFileName(hwnd, szFileDst, ARRAYSIZE(szFileDst),
(LONG_PTR)&tcpi, &iFilter, bForceHTMLOnly);
if (hr==S_OK)
hr = SaveToThicket( hwnd, szFileDst, pDoc, tcpi.cpSrc, tcpi.cpDst, iFilter);
Cleanup:
if (FAILED(hr))
ReportThicketError(hwnd, hr);
if (pOleCommandTarget)
pOleCommandTarget->Release();
if (pDoc)
pDoc->Release();
if (bstrURL)
SysFreeString(bstrURL);
if (bstrCharSet)
SysFreeString(bstrCharSet);
if (bstrTitle)
SysFreeString(bstrTitle);
return;
}
void ReportThicketError( HWND hwnd, HRESULT hr )
{
LPTSTR lpstrMsg = NULL;
switch (hr)
{
case HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY):
case E_OUTOFMEMORY:
lpstrMsg = MAKEINTRESOURCE(IDS_THICKETERRMEM);
break;
case E_ACCESSDENIED:
case STG_E_ACCESSDENIED:
lpstrMsg = MAKEINTRESOURCE(IDS_THICKETERRACC);
break;
case HRESULT_FROM_WIN32(ERROR_DISK_FULL):
case STG_E_MEDIUMFULL:
lpstrMsg = MAKEINTRESOURCE(IDS_THICKETERRFULL);
break;
case HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND):
lpstrMsg = MAKEINTRESOURCE(IDS_THICKETERRFNF);
break;
case E_ABORT:
// Ray says we don't want a canceled message box.
//lpstrMsg = MAKEINTRESOURCE(IDS_THICKETABORT);
break;
case E_FAIL:
default:
lpstrMsg = MAKEINTRESOURCE(IDS_THICKETERRMISC);
break;
}
if ( lpstrMsg )
{
MLShellMessageBox(
hwnd,
lpstrMsg,
MAKEINTRESOURCE(IDS_THICKETERRTITLE),
MB_OK | MB_ICONERROR);
}
}
//+--------------------------------------------------------------------------
//
// File: file.cxx
//
// Contents: Import/export dialog helpers
//
// History: 16-May-95 RobBear Taken from formtool
//
//---------------------------------------------------------------------------
const CHAR c_szNT4ResourceLocale[] = ".DEFAULT\\Control Panel\\International";
const CHAR c_szWin9xResourceLocale[] = ".Default\\Control Panel\\desktop\\ResourceLocale";
const CHAR c_szLocale[] = "Locale";
LANGID
MLGetShellLanguage()
{
LANGID lidShell = 0;
// FEATURE: this fn is copied from shlwapi. there really should be a
// shlwapi export. if MLGetUILanguage has any merit, then
// MLGetShellLanguage has merit as well.
if (IsOS(OS_WIN2000ORGREATER))
{
static LANGID (CALLBACK* pfnGetUserDefaultUILanguage)(void) = NULL;
if (pfnGetUserDefaultUILanguage == NULL)
{
HMODULE hmod = GetModuleHandle(TEXT("KERNEL32"));
if (hmod)
pfnGetUserDefaultUILanguage = (LANGID (CALLBACK*)(void))GetProcAddress(hmod, "GetUserDefaultUILanguage");
}
if (pfnGetUserDefaultUILanguage)
lidShell = pfnGetUserDefaultUILanguage();
}
else
{
CHAR szLangID[12];
DWORD cb, dwRet;
cb = sizeof(szLangID) - 2*sizeof(szLangID[0]); // avoid 2 byte buffer overrun
if (IsOS(OS_NT))
dwRet = SHGetValueA(HKEY_USERS, c_szNT4ResourceLocale, c_szLocale, NULL, szLangID + 2, &cb);
else
dwRet = SHGetValueA(HKEY_USERS, c_szWin9xResourceLocale, NULL, NULL, szLangID + 2, &cb);
if (ERROR_SUCCESS == dwRet)
{
// IE uses a string rep of the hex value
szLangID[0] = '0';
szLangID[1] = 'x';
StrToIntExA(szLangID, STIF_SUPPORT_HEX, (LPINT)&lidShell);
}
}
return lidShell;
}
/*
* Stolen from Trident's src\core\cdutil\file.cxx
*/
// Hook procedure for open file dialog.
UINT_PTR APIENTRY SaveOFNHookProc(HWND hdlg,
UINT uiMsg,
WPARAM wParam,
LPARAM lParam)
{
ULONG i, iCurSel;
BOOL bFoundEncoding = FALSE;
WCHAR wzEncoding[MAX_ENCODING_DESC_LEN];
switch (uiMsg)
{
// Populate the dropdown.
case WM_INITDIALOG:
{
HRESULT hr;
LPOPENFILENAME pofn = (LPOPENFILENAME)lParam;
ThicketCPInfo *ptcpi = (ThicketCPInfo *)pofn->lCustData;
IMultiLanguage2 *pMultiLanguage = NULL;
IEnumCodePage *pEnumCodePage = NULL;
//UINT codepageDefault = ptcpi->cp;
MIMECSETINFO csetInfo;
LANGID langid;
#ifdef UNIX
SetWindowLongPtr(hdlg, DWLP_USER, (LONG_PTR)ptcpi);
#endif /* UNIX */
hr = CoCreateInstance(
CLSID_CMultiLanguage,
NULL,
CLSCTX_INPROC_SERVER,
IID_IMultiLanguage2,
(void**)&pMultiLanguage);
if (hr)
break;
hr = pMultiLanguage->GetCharsetInfo(ptcpi->lpwstrDocCharSet,&csetInfo);
if (hr)
break;
#ifndef UNIX
// the shell combobox where this stuff shows up
// doesn't know how to fontlink... so we have
// to stay in the shell's codepage
langid = MLGetShellLanguage();
#else
langid = GetSystemDefaultLangID();
#endif /* UNIX */
if (pMultiLanguage->EnumCodePages( MIMECONTF_SAVABLE_BROWSER | MIMECONTF_VALID,
langid,
&pEnumCodePage) == S_OK)
{
MIMECPINFO cpInfo;
ULONG ccpInfo;
UINT cpDefault;
if (pMultiLanguage->GetCodePageInfo(csetInfo.uiInternetEncoding, langid, &cpInfo) == S_OK &&
!(cpInfo.dwFlags & MIMECONTF_SAVABLE_BROWSER))
{
// If the codepage selected is not savable (eg JP_AUTO),
// use the family codepage.
cpDefault = cpInfo.uiFamilyCodePage;
}
else
cpDefault = csetInfo.uiInternetEncoding;
ptcpi->cpSrc = csetInfo.uiInternetEncoding;
if (cpDefault == CODEPAGE_UNICODE &&
pofn->nFilterIndex == PACKAGE_MHTML) {
cpDefault = CODEPAGE_UTF8;
}
for (i = 0; pEnumCodePage->Next(1, &cpInfo, &ccpInfo) == S_OK; ++i)
{
TCHAR *lpszDesc;
INT_PTR iIdx;
if (cpInfo.uiCodePage == CODEPAGE_UNICODE &&
pofn->nFilterIndex == PACKAGE_MHTML) {
i--;
continue;
}
if (cpDefault == cpInfo.uiCodePage)
{
StrCpyNW(wzEncoding, cpInfo.wszDescription,
lstrlen(cpInfo.wszDescription) + 1);
bFoundEncoding = TRUE;
}
lpszDesc = cpInfo.wszDescription;
iIdx = SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET,
CB_ADDSTRING, 0,
(LPARAM)lpszDesc);
SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET,
CB_SETITEMDATA, iIdx,
(LPARAM)cpInfo.uiCodePage);
}
if (bFoundEncoding)
{
INT_PTR iIndex = 0;
iIndex = SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET,
CB_FINDSTRINGEXACT, -1,
(LPARAM)wzEncoding);
SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET, CB_SETCURSEL,
(WPARAM)iIndex, 0);
}
else
{
// No encoding found! Bad error. Recover by selecting
// the first one.
SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET, CB_SETCURSEL,
0, 0);
}
}
SAFERELEASE(pEnumCodePage);
SAFERELEASE(pMultiLanguage);
break;
}
#ifdef UNIX
case WM_COMMAND:
{
switch (GET_WM_COMMAND_ID(wParam,lParam))
{
case IDOK:
{
ThicketCPInfo *ptcpi = (ThicketCPInfo *)GetWindowLongPtr(hdlg,DWLP_USER);
ptcpi->cpDst = CP_ACP;
iCurSel = (int) SendDlgItemMessage (hdlg, IDC_SAVE_CHARSET, CB_GETCURSEL, 0, 0);
ptcpi->cpDst =
(UINT)SendDlgItemMessage (hdlg, IDC_SAVE_CHARSET, CB_GETITEMDATA,
(WPARAM)iCurSel, (LPARAM)0);
// To spare us from re-instantiating MLANG, we'll set the src and dest
// to CP_ACP if no change is indicated.
if (ptcpi->cpDst == ptcpi->cpSrc)
ptcpi->cpDst = ptcpi->cpSrc = CP_ACP;
}
break;
}
}
break;
#endif /* UNIX */
case WM_NOTIFY:
{
LPOFNOTIFY phdr = (LPOFNOTIFY)lParam;
switch (phdr->hdr.code)
{
case CDN_FILEOK:
{
LPOPENFILENAME pofn = (LPOPENFILENAME)phdr->lpOFN;
ThicketCPInfo *ptcpi = (ThicketCPInfo *)pofn->lCustData;
iCurSel = (int) SendDlgItemMessage (hdlg, IDC_SAVE_CHARSET, CB_GETCURSEL, 0, 0);
ptcpi->cpDst = //*(UINT *)phdr->lpOFN->lCustData =
(UINT)SendDlgItemMessage (hdlg, IDC_SAVE_CHARSET, CB_GETITEMDATA,
(WPARAM)iCurSel, (LPARAM)0);
}
// HACK! This case is implemented to implement a hack for
// IE5 RAID #60672. MIMEOLE cannot save UNICODE encoding,
// so when the user selects MHTML saves, we should remove
// this option. This code should be removed when MIMEOLE
// fixes their bug (targeted for NT5 RTM). Contact SBailey
// for the status of this.
case CDN_TYPECHANGE:
{
LPOPENFILENAME pofn = (LPOPENFILENAME)phdr->lpOFN;
ThicketCPInfo *ptcpi = (ThicketCPInfo *)pofn->lCustData;
UINT uiCPSel, uiCP;
int iType = pofn->nFilterIndex;
UINT iCount;
int iCurSel;
int iSet = -1;
if (iType == PACKAGE_MHTML)
{
iCurSel = (int)SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET, CB_GETCURSEL, 0, 0);
uiCPSel = (UINT)SendDlgItemMessage (hdlg, IDC_SAVE_CHARSET, CB_GETITEMDATA,
(WPARAM)iCurSel, (LPARAM)0);
// If you selected unicode, make it look like you
// really selected UTF-8
if (uiCPSel == CODEPAGE_UNICODE)
{
uiCPSel = CODEPAGE_UTF8;
}
i = (int) SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET,
CB_FINDSTRINGEXACT,
(WPARAM)0,
(LPARAM)UNICODE_TEXT);
if (i != CB_ERR)
{
SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET,
CB_DELETESTRING, i, (LPARAM)0);
}
iCount = (int)SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET,
CB_GETCOUNT, 0, 0);
// Set selected item back
for (i = 0; i < iCount; i++)
{
uiCP = (UINT)SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET, CB_GETITEMDATA,
(WPARAM)i, (LPARAM)0);
if (uiCP == uiCPSel)
{
iSet = i;
}
}
if (iSet != 0xffffffff)
{
SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET, CB_SETCURSEL,
(WPARAM)iSet, (LPARAM)0);
}
}
else
{
// Store current selection
iCurSel = (int)SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET, CB_GETCURSEL, 0, 0);
uiCPSel = (UINT)SendDlgItemMessage (hdlg, IDC_SAVE_CHARSET, CB_GETITEMDATA,
(WPARAM)iCurSel, (LPARAM)0);
// Add unicode back in, if it was removed
i = (int) SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET,
CB_FINDSTRINGEXACT,
(WPARAM)0,
(LPARAM)UNICODE_TEXT);
if (i == CB_ERR) {
// Unicode does not exist, add it back in
i = (int) SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET,
CB_ADDSTRING, 0,
(LPARAM)UNICODE_TEXT);
SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET,
CB_SETITEMDATA, i,
(LPARAM)CODEPAGE_UNICODE);
// Make sure the same encoding selected before is
// still selected.
iCount = (int)SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET,
CB_GETCOUNT, 0, 0);
for (i = 0; i < iCount; i++)
{
uiCP = (UINT)SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET, CB_GETITEMDATA,
(WPARAM)i, (LPARAM)0);
if (uiCP == uiCPSel)
{
iSet = i;
}
}
if (iCurSel != 0xffffffff)
{
SendDlgItemMessage(hdlg, IDC_SAVE_CHARSET, CB_SETCURSEL,
(WPARAM)iSet, (LPARAM)0);
}
}
}
}
break;
}
}
break;
case WM_HELP:
{
SHWinHelpOnDemandWrap((HWND)((LPHELPINFO) lParam)->hItemHandle,
c_szHelpFile,
HELP_WM_HELP,
(DWORD_PTR)aSaveAsHelpIDs);
}
break;
case WM_CONTEXTMENU:
{
SHWinHelpOnDemandWrap((HWND) wParam,
c_szHelpFile,
HELP_CONTEXTMENU,
(DWORD_PTR)aSaveAsHelpIDs);
}
break;
}
return (FALSE);
}
//
// Protect the naive users from themselves, if somebody enters a filename
// of microsoft.com when saving http://www.microsoft.com we don't want
// to save a .COM file since this will be interpreted as an executable.
// bad things will happen
//
void CleanUpFilename(LPTSTR pszFile, int iPackageStyle)
{
//
// If we find .COM as the file extension replace it with the file extension
// of the filetype they are saving the file as
//
LPTSTR pszExt = PathFindExtension(pszFile);
ASSERT(pszExt);
if (StrCmpI(pszExt, TEXT(".COM")) == 0) // REVIEW any other file types???
{
//
// Map the package style to a default extension. NOTE this relies on
// the fact that the filter index maps to the PACKAGE style enum
// (as does the rest of the thicket code).
//
switch (iPackageStyle)
{
case PACKAGE_THICKET:
case PACKAGE_HTML:
StrCatBuff(pszFile, TEXT(".htm"), MAX_PATH);
break;
case PACKAGE_MHTML:
StrCatBuff(pszFile, TEXT(".mht"), MAX_PATH);
break;
case PACKAGE_TEXT:
StrCatBuff(pszFile, TEXT(".txt"), MAX_PATH);
break;
default:
ASSERT(FALSE); // Unknown package type
break;
}
}
}
//+---------------------------------------------------------------------------
//
// Function: FormsGetFileName
//
// Synopsis: Gets a file name using either the GetOpenFileName or
// GetSaveFileName functions.
//
// Arguments: [fSaveFile] -- TRUE means use GetSaveFileName
// FALSE means use GetOpenFileName
//
// [idFilterRes] -- The string resource specifying text in the
// dialog box. It must have the
// following format:
// Note: the string has to be _one_ contiguous string.
// The example is broken up to make it fit
// on-screen. The verical bar ("pipe") characters
// are changed to '\0'-s on the fly.
// This allows the strings to be localized
// using Espresso.
//
// IDS_FILENAMERESOURCE, "Save Dialog As| // the title
// odg| // default extension
// Forms3 Dialog (*.odg)| // pairs of filter strings
// *.odg|
// Any File (*.*)|
// *.*|"
//
// [pstrFile] -- Buffer for file name.
// [cchFile] -- Size of buffer in characters.
//
// Modifies: [pstrFile]
//
//----------------------------------------------------------------------------
#ifdef _MAC
extern "C" {
char * __cdecl _p2cstr(unsigned char *);
}
#endif
#define CHAR_DOT TEXT('.')
#define CHAR_DOT_REPLACEMENT TEXT('_')
void ReplaceDotsInFileName(LPTSTR pszFileName)
{
ASSERT(pszFileName);
while (*pszFileName)
{
if (*pszFileName == CHAR_DOT)
{
*pszFileName = CHAR_DOT_REPLACEMENT;
}
pszFileName++;
}
}
HRESULT
FormsGetFileName(
HWND hwndOwner,
LPTSTR pstrFile,
int cchFile,
LPARAM lCustData,
DWORD *pnFilterIndex,
BOOL bForceHTMLOnly)
{
HRESULT hr = S_OK;
BOOL fOK;
DWORD dwCommDlgErr;
LPTSTR pstr;
OPENFILENAME ofn;
TCHAR achBuffer[4096]; // Max. size of a string resource
TCHAR * cp;
TCHAR * pstrExt;
int cbBuffer;
TCHAR achPath[MAX_PATH];
DWORD dwType = REG_SZ;
DWORD cbData = MAX_PATH * sizeof(TCHAR);
int idFilterRes;
// Initialize ofn struct
memset(&ofn, 0, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = hwndOwner;
ofn.Flags = OFN_FILEMUSTEXIST |
OFN_PATHMUSTEXIST |
OFN_OVERWRITEPROMPT |
OFN_HIDEREADONLY |
#ifndef UNIX
OFN_NOCHANGEDIR |
OFN_EXPLORER;
#else
OFN_NOCHANGEDIR;
#endif /* UNIX */
ofn.lpfnHook = NULL;
ofn.nMaxFile = cchFile;
ofn.lCustData = lCustData;
ofn.lpstrFile = pstrFile;
#ifndef NO_IME
// We add an extra control to the save file dialog.
if (lCustData)
{
ofn.Flags |= OFN_ENABLETEMPLATE | OFN_ENABLEHOOK;
ofn.lpfnHook = SaveOFNHookProc;
ofn.lpTemplateName = MAKEINTRESOURCE(IDD_ADDTOSAVE_DIALOG);
ofn.hInstance = g_hinst;
}
#endif
//
// Find the extension and set the filter index based on what the
// extension is. After these loops pstrExt will either be NULL if
// we didn't find an extension, or will point to the extension starting
// at the '.'
pstrExt = pstrFile;
while (*pstrExt)
pstrExt++;
while ( pstrExt >= pstrFile )
{
if( *pstrExt == TEXT('.') )
break;
pstrExt--;
}
if( pstrExt < pstrFile )
pstrExt = NULL;
// Load the filter spec.
// FEATURE: Convert table to stringtable for localization
if ( SHRestricted2W( REST_NoBrowserSaveWebComplete, NULL, 0 ) )
idFilterRes = IDS_NOTHICKET_SAVE;
else if ( s_dwInetComVerMS != 0xFFFFFFFF )
{
#ifndef UNIX
if (s_dwInetComVerMS == 0)
{
TCHAR szPath[MAX_PATH];
GetSystemDirectory( szPath, MAX_PATH );
StrCatBuff( szPath, TEXT("\\INETCOMM.DLL"), MAX_PATH );
if (FAILED(GetVersionFromFile(szPath, &s_dwInetComVerMS, &s_dwInetComVerLS)))
s_dwInetComVerMS = 0xFFFFFFFF;
}
if (s_dwInetComVerMS >= 0x50000 && s_dwInetComVerMS != 0xFFFFFFFF)
idFilterRes = IDS_THICKET_SAVE;
else
idFilterRes = IDS_NOMHTML_SAVE;
#else
// on UNIX we don't have inetcomm.dll if oe is not installed
{
HINSTANCE hInetComm = NULL;
if ((hInetComm = LoadLibrary(TEXT("INETCOMM.DLL"))))
{
idFilterRes = IDS_THICKET_SAVE;
FreeLibrary(hInetComm);
}
else
idFilterRes = IDS_NOMHTML_SAVE;
}
#endif
}
else
idFilterRes = IDS_THICKET_SAVE;
cbBuffer = MLLoadShellLangString(idFilterRes, achBuffer, ARRAYSIZE(achBuffer));
ASSERT(cbBuffer > 0);
if ( ! cbBuffer )
return E_FAIL;
ofn.lpstrTitle = achBuffer;
for ( cp = achBuffer; *cp; cp++ )
{
if ( *cp == TEXT('|') )
{
*cp = TEXT('\0');
}
}
ASSERT(ofn.lpstrTitle);
// Default extension is second string.
pstr = (LPTSTR) ofn.lpstrTitle;
while (*pstr++)
{
}
// N.B. (johnv) Here we assume that filter index one corresponds with the default
// extension, otherwise we would have to introduce a default filter index into
// the resource string.
ofn.nFilterIndex = ((pnFilterIndex)? *pnFilterIndex : 1);
ofn.lpstrDefExt = pstr;
// Filter is third string.
while(*pstr++)
{
}
ofn.lpstrFilter = pstr;
// Try to match the extension with an entry in the filter list
// If we match, remove the extension from the incoming path string,
// set the default extension to the one we found, and appropriately
// set the filter index.
if (pstrExt && !bForceHTMLOnly)
{
// N.B. (johnv) We are searching more than we need to.
int iIndex = 0;
const TCHAR* pSearch = ofn.lpstrFilter;
while( pSearch )
{
if( StrStr( pSearch, pstrExt ) )
{
ofn.nFilterIndex = (iIndex / 2) + 1;
ofn.lpstrDefExt = pstrExt + 1;
// Remove the extension from the file name we pass in
*pstrExt = TEXT('\0');
break;
}
pSearch += lstrlen(pSearch);
if( pSearch[1] == 0 )
break;
pSearch++;
iIndex++;
}
}
// Suggest HTML Only as default save-type
if (bForceHTMLOnly)
{
// NOTE: These are hard-coded indices based on shdoclc.rc's
// IDS_THICKET_SAVE, IDS_NOMHTML_SAVE, IDS_NOTHICKET_SAVE ordering.
// This saves us the perf hit of doing string comparisons to find
// HTML only
switch (idFilterRes)
{
case IDS_NOTHICKET_SAVE:
ofn.nFilterIndex = 1;
break;
case IDS_NOMHTML_SAVE:
ofn.nFilterIndex = 2;
break;
default:
ASSERT(idFilterRes == IDS_THICKET_SAVE);
ofn.nFilterIndex = 3;
break;
}
}
if ( SHGetValue(HKEY_CURRENT_USER, REGSTR_PATH_MAIN, REGSTR_VAL_SAVEDIRECTORY,
&dwType, achPath, &cbData) != ERROR_SUCCESS ||
!PathFileExists(achPath))
{
SHGetSpecialFolderPath(hwndOwner, achPath, CSIDL_PERSONAL, FALSE);
}
ofn.lpstrInitialDir = achPath;
// We don't want to suggest dots in the filename
ReplaceDotsInFileName(pstrFile);
// Now, at last, we're ready to call the save file dialog
fOK = GetSaveFileName(&ofn);
// if working with the abbreviated format list, adjust the index
if (idFilterRes == IDS_NOTHICKET_SAVE)
ofn.nFilterIndex += 2;
else if ( idFilterRes == IDS_NOMHTML_SAVE && ofn.nFilterIndex > 1 )
ofn.nFilterIndex += 1;
if (fOK)
{
//
// Protect the naive users from themselves, if somebody enters a filename
// of microsoft.com when saving http://www.microsoft.com we don't want
// to save a .COM file since this will be interpreted as an executable.
// bad things will happen
//
CleanUpFilename(pstrFile, ofn.nFilterIndex);
TCHAR *lpszFileName;
StrCpyN( achPath, pstrFile, ARRAYSIZE(achPath) );
lpszFileName = PathFindFileName( achPath );
*lpszFileName = 0;
SHSetValue(HKEY_CURRENT_USER, REGSTR_PATH_MAIN, REGSTR_VAL_SAVEDIRECTORY,
REG_SZ, achPath, (lstrlen(achPath) * sizeof(TCHAR)));
if (pnFilterIndex)
*pnFilterIndex = ofn.nFilterIndex;
if (ofn.nFilterIndex != PACKAGE_MHTML)
{
// we can only do this if we're not packaging MHTML
// because MHTML requires that we tag with the explicit
// charset, even if it was the default. unlike thicket
// which inherits the charset from the original document,
// MHTML must be explicitly tagged or else some system
// charset tags will sneak in.
ThicketCPInfo * ptcpi = (ThicketCPInfo *)lCustData;
// To spare us from re-instantiating MLANG, we'll set the src and dest
// to CP_ACP if no change is indicated.
if (ptcpi->cpDst == ptcpi->cpSrc)
ptcpi->cpDst = ptcpi->cpSrc = CP_ACP;
}
}
else
{
#ifndef WINCE
dwCommDlgErr = CommDlgExtendedError();
if (dwCommDlgErr)
{
hr = HRESULT_FROM_WIN32(dwCommDlgErr);
}
else
{
hr = S_FALSE;
}
#else // WINCE
hr = E_FAIL;
#endif // WINCE
}
return hr;
}
HRESULT
GetFileNameFromURL( LPWSTR pwszURL, LPTSTR pszFile, DWORD cchFile)
{
HRESULT hr = S_OK;
PARSEDURLW puw = {0};
int cchUrl;
cchUrl = SysStringLen(pwszURL);
if (cchUrl)
{
puw.cbSize = sizeof(PARSEDURLW);
if (SUCCEEDED(ParseURLW(pwszURL, &puw)))
{
OLECHAR *pwchBookMark;
DWORD dwSize;
INTERNET_CACHE_ENTRY_INFOW ceiT;
LPINTERNET_CACHE_ENTRY_INFOW pcei = NULL;
// Temporarily, null out the '#' in the url
pwchBookMark = StrRChrW(puw.pszSuffix, NULL,'#');
if (pwchBookMark)
{
*pwchBookMark = 0;
}
dwSize = sizeof(INTERNET_CACHE_ENTRY_INFO);
if ( !GetUrlCacheEntryInfoW( pwszURL, &ceiT, &dwSize ) &&
GetLastError() == ERROR_INSUFFICIENT_BUFFER &&
(pcei = (LPINTERNET_CACHE_ENTRY_INFOW)new BYTE[dwSize]) != NULL &&
GetUrlCacheEntryInfoW( pwszURL, pcei, &dwSize ) )
{
StrCpyN(pszFile, PathFindFileName(pcei->lpszLocalFileName), cchFile);
PathUndecorate(pszFile);
}
if(pcei)
delete[] pcei;
if (pwchBookMark)
*pwchBookMark = '#';
if ( !pszFile[0] )
{
OLECHAR *pwchQuery;
TCHAR szFileT[MAX_PATH];
// Temporarily, null out the '?' in the url
pwchQuery = StrRChrW(puw.pszSuffix, NULL,'?');
if (pwchQuery)
{
*pwchQuery = 0;
}
// IE5 bug 15055 - http://my.excite.com/?uid=B56E4E2D34DF3FED.save_uid
// fails to save because we were passing "my.excite.com/" as the file
// name to the file dialog. It doesn't like this.
if (!pwchQuery || (pwchQuery[-1] != '/' && pwchQuery[-1] != '\\'))
{
dwSize = ARRAYSIZE(szFileT);
StrCpyN(szFileT, PathFindFileName(puw.pszSuffix), dwSize);
if ( !InternetCanonicalizeUrl( szFileT, pszFile, &dwSize, ICU_DECODE | ICU_NO_ENCODE) )
StrCpyN(pszFile, szFileT, cchFile);
pszFile[cchFile - 1] = 0;
}
if (pwchQuery)
*pwchQuery = '?';
}
}
}
if (!pszFile[0])
{
MLLoadString(IDS_UNTITLED, pszFile, cchFile);
}
return hr;
}
INT_PTR CALLBACK SaveAsWarningDlgProc(HWND hDlg, UINT msg, WPARAM wParam,
LPARAM lParam)
{
BOOL fRet = FALSE;
HRESULT hr = S_OK;
int iFlags = 0;
INT_PTR bChecked = 0;
switch (msg)
{
case WM_INITDIALOG:
MessageBeep(MB_ICONEXCLAMATION);
fRet = TRUE;
case WM_COMMAND:
bChecked = SendDlgItemMessage(hDlg, IDC_SAVEAS_WARNING_CB,
BM_GETCHECK, 0, 0 );
iFlags = (bChecked) ? (SAVEAS_NEVER_ASK_AGAIN) : (0);
switch (LOWORD(wParam))
{
case IDYES:
iFlags |= SAVEAS_OK;
// fall through
case IDNO:
EndDialog(hDlg, iFlags);
fRet = TRUE;
break;
}
default:
fRet = FALSE;
}
return fRet;
}
Reference in a new issue Copy permalink