Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
unixstuff.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 56k
Category:

Windows Kernel

Development Platform:

Visual C++

unixstuff.cpp：Code Content
  2. /*----------------------------------------------------------
  3. Purpose: Unix-menus related functions.
  5. */
  7. #include <tchar.h>
  8. #include <process.h>
  9. #include <ieverp.h>
  11. #include "priv.h"
  12. #include "unixstuff.h"
  13. #include "resource.h"
  14. #include "dochost.h"
  15. #include "winlist.h"
  16. #include "runonnt.h"
  17. #include "impexp.h"
  19. #include "mluisupp.h"
  21. #define WINDOWS_MENU_ARROW_WIDTH  4
  22. #define WINDOWS_MENU_ARROW_HEIGHT 8
  23. #define MOTIF_ARROW_TEXT_MARGIN   4
  25. // From download.cpp
  26. #define TITLE_LEN    (256 + 32)
  27. #define MAX_DISPLAY_LEN 96
  29. #ifdef NO_MARSHALLING
  30. extern DWORD g_TLSThreadWindowInfo;
  31. #endif
  33. const TCHAR c_szExploreClass[] = TEXT("ExploreWClass");
  34. const TCHAR c_szIExploreClass[] = TEXT("IEFrame");
  35. const TCHAR c_szCabinetClass[] = 
  36. #ifdef IE3CLASSNAME
  37.     TEXT("IEFrame");
  38. #else
  39.     TEXT("CabinetWClass");
  40. #endif
  43. extern HMENU g_hmenuFullSB;
  45. extern "C" {
  47.     /* Common controls */
  48.     void UnixPaintArrow(HDC hDC, BOOL bHoriz, BOOL bDown, int nXCenter, int nYCenter, int nWidth, int nHeight);
  50.     /* mainwin */
  51.     void MwDrawMotifPopupArrowParams(BOOL bDrawAsDown, HDC hDC, int nShadowThickness, DWORD cButtonSunny, 
  52.                                      DWORD cButtonShadow, DWORD cSelect, DWORD cBackground, const RECT* rItemSize, 
  53.                                      int nIndicatorSize);
  55.     void MwPaintMotifPushButtonGadgetUpDown(HDC hDC, int nButtonWidth, int nButtonHeight, BOOL bFocus, 
  56.                                             BOOL bDrawDefaultPB, BOOL bDown, BOOL bDrawTopBottomShadowOnly,
  57.                                             BOOL bMenu,  void* /* NULL */, int nOffsetx, int nOffsety);
  59.     BOOL MwGetMotifPullDownMenuResourcesExport(int *lpnShadowThickness, int *lpnMarginHeight, int *lpnMarginWidth,
  60.                                                int *lpnButtonSpacing, DWORD *lpcBackground, DWORD *lpcForeground,
  61.                                                DWORD *lpcButtonSunny, DWORD *lpcButtonShadow, HFONT * phFont);
  63.     COLORREF MwGetMotifColor(int index);
  65. };
  67. static void
  68. GetMotifMenuParams(int* pnShadowThickness, DWORD* pcBackground, DWORD* pcForeground, 
  69.                     DWORD* pcButtonSunny, DWORD* pcButtonShadow, DWORD* pcSelect, 
  70.                     int* pnIndicatorSize)
  71. {
  72.     const int nIndicatorSize = 12;
  73.     const int MR_PULLDOWNMENU_CHECKBOX_TOGGLEBUTTON_SELECTCOLOR=167;
  75.     MwGetMotifPullDownMenuResourcesExport(pnShadowThickness, NULL, NULL, NULL, pcBackground, pcForeground,
  76.                                           pcButtonSunny, pcButtonShadow, NULL);          
  77.    
  78.     if (pcSelect != NULL)
  79.         *pcSelect = MwGetMotifColor(MR_PULLDOWNMENU_CHECKBOX_TOGGLEBUTTON_SELECTCOLOR);
  81.     if (pnIndicatorSize != NULL)
  82.      *pnIndicatorSize = nIndicatorSize;
  83. }
  85. EXTERN_C void SelectMotifMenu(HDC hdc, const RECT* prc, BOOL bSelected)
  86. {
  87.     MwPaintMotifPushButtonGadgetUpDown(hdc, prc->right - prc->left, prc->bottom - prc->top,
  88.                                        FALSE, FALSE, bSelected, FALSE, TRUE, NULL,
  89.                                        prc->left, prc->top);
  90. }
  92. EXTERN_C void PaintMotifMenuArrow(HDC hdc, const RECT* prc, BOOL bSelected)
  93. {
  94.     int nShadowThickness, nIndicatorSize;
  95.     DWORD cBackground, cForeground, cButtonSunny, cButtonShadow, cSelect;
  96.     RECT rect = *prc;
  97.     
  98.     GetMotifMenuParams(&nShadowThickness, &cBackground, &cForeground, &cButtonSunny, 
  99.                        &cButtonShadow, &cSelect, &nIndicatorSize);
  101.     // Compensation for space added in the indicatorSize.
  102.     rect.left += MOTIF_ARROW_TEXT_MARGIN;
  104.     MwDrawMotifPopupArrowParams(bSelected, hdc, nShadowThickness, cButtonSunny, cButtonShadow,
  105.                                 cSelect, cBackground, &rect, nIndicatorSize);
  106. }
  108. EXTERN_C void PaintWindowsMenuArrow(HDC hdc, const RECT* prc)
  109. {
  110.      int cy = prc->bottom - prc->top;
  111.      UnixPaintArrow( hdc, TRUE, TRUE, prc->left, prc->top + cy/2, 
  112.          WINDOWS_MENU_ARROW_WIDTH, WINDOWS_MENU_ARROW_HEIGHT );
  113. }
  115. EXTERN_C void PaintUnixMenuArrow(HDC hdc, const RECT* prc, DWORD data)
  116. { 
  117.     if (MwCurrentLook() == LOOK_MOTIF) {
  118.          COLORREF rgbText = (COLORREF) data;
  119.          BOOL bSelected = (rgbText == GetSysColor(COLOR_HIGHLIGHTTEXT));
  121.          PaintMotifMenuArrow(hdc, prc, bSelected);
  122.      }
  123.      else {
  124.          PaintWindowsMenuArrow( hdc, prc );
  125.      }
  126. }
  128. EXTERN_C int GetUnixMenuArrowWidth()
  129. {
  130.     if (MwCurrentLook() == LOOK_MOTIF)
  131.     {
  132.         int nShadowThickness, nIndicatorSize;
  133.         DWORD cBackground, cForeground, cButtonSunny, cButtonShadow, cSelect;
  135.         GetMotifMenuParams(&nShadowThickness, &cBackground, &cForeground, &cButtonSunny,
  136.                        &cButtonShadow, &cSelect, &nIndicatorSize);
  138.         // Indicator Size increased for space between
  139.         return (nIndicatorSize + MOTIF_ARROW_TEXT_MARGIN);
  140.     }
  141.     else
  142.     {
  143.         return ( WINDOWS_MENU_ARROW_WIDTH );
  144.     }
  145. }
  147. EXTERN_C BOOL CheckAndExecNewsScript( HWND hwnd )
  148. {
  149.      HKEY hkey;
  150.      DWORD dwType;
  151.      DWORD dwSize = sizeof(DWORD);
  152.      DWORD dwUseOENews = FALSE;
  153.      HRESULT hres = S_FALSE;
  154.      BOOL  fRet = FALSE;
  155.      TCHAR tszCommandLine[ INTERNET_MAX_URL_LENGTH + 1];
  156.      TCHAR tszExpandedCommand[INTERNET_MAX_URL_LENGTH + 1];
  158. #ifndef DISABLE_OE
  160.      SHGetValue(IE_USE_OE_NEWS_HKEY, IE_USE_OE_NEWS_KEY, IE_USE_OE_NEWS_VALUE,
  161.            &dwType, (void*)&dwUseOENews, &dwSize);
  163.      if (dwType != REG_DWORD)
  164.      {
  165.          // The default value for mail is FALSE
  166.          dwUseOENews = FALSE;
  167.      }
  169. #endif
  171.      if (! dwUseOENews )
  172.      {
  173.          hres = RegOpenKeyEx(
  174.             HKEY_CURRENT_USER,
  175.             REGSTR_PATH_NEWSCLIENTS,
  176.             0,
  177.             KEY_READ,
  178.             &hkey);
  180.          if (hres == ERROR_SUCCESS)
  181.          {
  182.              dwSize = sizeof( tszExpandedCommand );
  183.              hres = RegQueryValueEx(hkey, REGSTR_PATH_CURRENT, NULL, NULL,
  184.                    (LPBYTE)tszCommandLine, &dwSize);
  186.              if (hres == ERROR_SUCCESS)
  187.              {
  188.                   STARTUPINFO stInfo;
  189.                   memset(&stInfo, 0, sizeof(stInfo));
  190.                   stInfo.cb = sizeof(stInfo);
  191.                   SHExpandEnvironmentStrings(tszCommandLine, tszExpandedCommand,
  192.                       INTERNET_MAX_URL_LENGTH);
  193.                   if( CreateProcess(tszExpandedCommand, tszCommandLine, NULL, NULL,
  194.                         FALSE, DETACHED_PROCESS, NULL,
  195.                         NULL, &stInfo, NULL) )
  196.                       fRet = TRUE;
  197.              }
  198.            
  199.              RegCloseKey( hkey );
  200.          }
  201.      }
  203.      if( !dwUseOENews && !fRet )
  204.      {
  205.          ShellMessageBox(
  206.              MLGetHinst(),
  207.              hwnd,
  208.              MAKEINTRESOURCE(IDS_NEWS_SCRIPT_ERROR),
  209.              MAKEINTRESOURCE(IDS_NEWS_SCRIPT_ERROR_TITLE),
  210.              MB_ICONWARNING|MB_OK);
  211.          fRet = TRUE;
  212.      }
  214.      return fRet;
  215. }
  217. EXTERN_C int  ConvertModuleNameToUnix( LPTSTR path )
  218. {
  219.     TCHAR drive[_MAX_DRIVE];   
  220.     TCHAR dir[_MAX_DIR];
  221.     TCHAR fname[_MAX_FNAME];   
  222.     TCHAR ext[_MAX_EXT];
  224.     if( !path || !*path )
  225.         return 0;
  227. #ifndef UNICODE
  228.     _splitpath( path, drive, dir, fname, ext );
  229. #else
  230.     _wsplitpath( path, drive, dir, fname, ext );
  231. #endif
  233.     if(StrCmpNI( fname, TEXT("lib"), 3 ))
  234.        StrCpyN( path, fname, _MAX_FNAME );
  235.     else
  236.        StrCpyN( path, fname+3, (_MAX_FNAME-3) );
  238.     if(StrCmpNI( ext, TEXT(".so"), 3 ))
  239.        StrCatBuff( path, ext, _MAX_EXT );
  240.     else
  241.        StrCatBuff( path, TEXT(".dll"), _MAX_EXT );
  243.     return lstrlen( path );
  244. }
  246. void ContentHelp( IShellBrowser* psb )
  247. {
  248.     UnixHelp("Content Index", psb);
  249. }
  251. EXTERN_C void UnixHelp(LPWSTR pszName, IShellBrowser* psb )
  252. {
  253.     WCHAR szPathTemp[MAX_URL_STRING+1];
  254.     
  255.     HRESULT hres = E_FAIL;
  256.     UINT  cbTempSize = ARRAYSIZE(szPathTemp);
  258.     // Get the path for installed pages from registry. This entry
  259.     // in registry is modified by the setup   program to point to
  260.     // location where help files are installed.
  262.     hres = URLSubRegQuery(L"Software\Microsoft\Internet Explorer\Unix",
  263.            pszName, TRUE, szPathTemp, cbTempSize, URLSUB_ALL);
  265.     if( FAILED(hres) ) return;
  267.     if(psb)
  268.     {
  269.         LPITEMIDLIST searchPidl;
  271.         // searchPidl = SHSimpleIDListFromPath( szPathTemp );
  273.         ::IEParseDisplayName(CP_ACP, szPathTemp, &searchPidl );
  274.         if(searchPidl)
  275.         {
  276.             psb->BrowseObject(searchPidl,SBSP_NEWBROWSER|SBSP_HELPMODE|SBSP_NOTRANSFERHIST);
  277.             ILFree( searchPidl );
  278.         }
  279.     }
  280. }
  283. EXTERN_C BOOL  OEHandlesMail( void )
  284. {
  285. #ifdef DISABLE_OE
  286.     return FALSE;
  287. #endif
  289.     DWORD dwType;
  290.     DWORD dwSize;
  291.     DWORD dwUseOEMail;
  292.     HRESULT hr;
  294.     dwSize = sizeof(DWORD);
  296.     hr = SHGetValue(IE_USE_OE_MAIL_HKEY, IE_USE_OE_MAIL_KEY, IE_USE_OE_MAIL_VALUE, &dwType, (void*)&dwUseOEMail, &dwSize);
  297.     if ((hr) && (dwType != REG_DWORD))
  298.     {
  299.         // The default value for mail is FALSE
  300.         dwUseOEMail = FALSE;
  301.     }
  303.     if (dwUseOEMail)
  304.     {
  305.         return TRUE; 
  306.     }
  307.     else
  308.     {
  309.         return FALSE;
  310.     }
  311. }
  314. // PORT QSY SendDocToMailRecipient has already been used to
  315. // invoke native UNIX mailers. Invent a new function to
  316. // let OE do the job.
  317. // Most of the code copied from WAB and  shell/ext/sendmail/sendmail.c
  318. // We probably should port sendmail.dll after preview 1.
  319. #include <mapi.h>
  321. #define MRPARAM_DOC          0x00000001
  322. #define MRPARAM_DELETEFILE   0x00000002 // The temporary file was created by us and need to be deleted
  323. #define MRPARAM_USECODEPAGE  0x00000004
  324. typedef struct {
  325.     DWORD dwFlags;    // Attributes passed to the MAPI apis
  326.     LPTSTR pszFiles;  // All files names separated by NULL;
  327.     LPTSTR pszURL;    // All files names of URLs separated by ';', this will
  328.                       // be the title;
  329.     CHAR paszFiles[MAX_PATH + 1];
  330.     CHAR paszURL[INTERNET_MAX_URL_LENGTH + 1];
  331.                       // be the title;
  332.     int nFiles;       // The number of files being sent.
  333.     UINT uiCodePage;  // Code page
  334. } MRPARAM;
  336. const LPTSTR szDefMailKey = TEXT("Software\Clients\Mail");
  337. const LPTSTR szOEDllPathKey =  TEXT("DllPath");
  338. const LPTSTR szOEName = TEXT("Outlook Express");
  340. BOOL CheckForOutlookExpress(LPTSTR szDllPath)
  341. {
  342. #ifdef DISABLE_OE
  343.     return FALSE;
  344. #endif
  346.     HKEY hKeyMail   = NULL;
  347.     HKEY hKeyOE     = NULL;
  348.     DWORD dwErr     = 0;
  349.     DWORD dwSize    = 0;
  350.     TCHAR szBuf[MAX_PATH];
  351.     DWORD dwType    = 0;
  352.     BOOL bRet = FALSE;
  355.     StrCpyN(szDllPath, TEXT(""), 1);
  357.     // Open the key for default internet mail client
  358.     // HKLMSoftwareClientsMail
  360.     dwErr = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  361.                                 szDefMailKey,
  362.                                 0,
  363.                                 KEY_ALL_ACCESS,
  364.                                 &hKeyMail);
  365.     if(dwErr != ERROR_SUCCESS)
  366.     {
  367.         goto out;
  368.     }
  370.     dwSize = sizeof(szBuf);         // Expect ERROR_MORE_DATA
  372.     dwErr = RegQueryValueEx(
  373.                                 hKeyMail,
  374.                                 NULL,
  375.                                 NULL,
  376.                                 &dwType,
  377.                                 (LPBYTE)szBuf,
  378.                                 &dwSize);
  379.     if(dwErr != ERROR_SUCCESS)
  380.     {
  381.         goto out;
  382.     }
  384.     if(!StrCmpI(szBuf, szOEName))
  385.     {
  386.         // Yes its outlook express ..
  387.         bRet = TRUE;
  389.         // Get the DLL Path
  390.         dwErr = RegOpenKeyEx(hKeyMail,
  391.                                     szOEName,
  392.                                     0,
  393.                                     KEY_ALL_ACCESS,
  394.                                     &hKeyOE);
  395.         if(dwErr != ERROR_SUCCESS)
  396.         {
  397.             goto out;
  398.         }
  400.         dwSize = sizeof(szBuf);
  401.         StrCpyN(szBuf, TEXT(""), 1);
  403.         dwErr = RegQueryValueEx(
  404.                                 hKeyOE,
  405.                                 szOEDllPathKey,
  406.                                 NULL,
  407.                                 &dwType,
  408.                                 (LPBYTE)szBuf,
  409.                                 &dwSize);
  411.         if(dwErr != ERROR_SUCCESS)
  412.         {
  413.             goto out;
  414.         }
  416.         if(lstrlen(szBuf))
  417.             StrCpyN(szDllPath, szBuf, lstrlen(szBuf) + 1);
  418.     }
  420. out:
  421.     if(hKeyOE)
  422.         RegCloseKey(hKeyOE);
  423.     if(hKeyMail)
  424.         RegCloseKey(hKeyMail);
  426.     return bRet;
  428. }
  430. HANDLE LoadMailProvider()
  431. {
  432.     TCHAR szBuf[MAX_PATH];
  433.     HANDLE hLibMapi = NULL;
  435.     if(CheckForOutlookExpress(szBuf) == TRUE)
  436.     {
  437.         hLibMapi = LoadLibrary(szBuf);
  438. return hLibMapi;
  439.     }
  440.     else
  441.         return 0;
  442. }
  444. BOOL AllocatePMP(MRPARAM * pmp, DWORD cchUrlBufferSize, DWORD cchFileBufferSize)
  445. {
  446.     pmp->pszURL = (LPTSTR) GlobalAlloc(GPTR, cchUrlBufferSize * sizeof(TCHAR));
  447.     if (!pmp->pszURL)
  448.         return FALSE;
  449.  
  450.     pmp->pszFiles = (LPTSTR) GlobalAlloc(GPTR, cchFileBufferSize * sizeof(TCHAR));
  451.     if (!pmp->pszFiles)
  452.         return FALSE;
  453.  
  454.     return TRUE;
  455. }
  457. BOOL CleanupPMP(MRPARAM * pmp)
  458. {
  459.     if (pmp->pszFiles)
  460.         GlobalFree((LPVOID)pmp->pszFiles);
  461.     pmp->pszFiles = NULL;
  462.     if (pmp->pszURL)
  463.         GlobalFree((LPVOID)pmp->pszURL);
  464.     pmp->pszURL = NULL;
  465.     pmp->nFiles = 0;
  466.     GlobalFree(pmp);
  467.     return TRUE;
  468. }
  470. HRESULT _CreateShortcutToPath(LPCTSTR pszPath, LPCTSTR pszTarget)
  471. {
  472.     IShellLink *psl;
  473.     HRESULT hres = CoCreateInstance(CLSID_ShellLink, 
  474. NULL, 
  475. CLSCTX_INPROC_SERVER, 
  476. IID_IShellLink, 
  477. (LPVOID*)&psl);
  479.     if (SUCCEEDED(hres))
  480.     {
  481.         IPersistFile *ppf;
  483.         psl->SetPath(pszTarget);
  485.         hres = psl->QueryInterface(IID_IPersistFile, (LPVOID *)&ppf);
  486.         if (SUCCEEDED(hres))
  487.         {
  488.             WCHAR wszPath[MAX_PATH];
  489. #ifndef UNICODE
  490.             AnsiToUnicode(pszPath, wszPath, ARRAYSIZE(wszPath));
  491. #else
  492.     StrCpyN(wszPath, pszPath, MAX_PATH);
  493. #endif
  494.  
  495.             hres = ppf->Save(wszPath, TRUE);
  496.             ppf->Release();
  497.         }
  498.         psl->Release();
  499.     }
  500.     return hres;
  501. }
  503. // create a temporary shortcut to a file
  504. // BUGBUG: Colision is not handled here
  505. BOOL _CreateTempFileShortcut(LPCTSTR IN pszFile, LPTSTR OUT pszShortcut)
  506. {
  507.     TCHAR szPath[MAX_PATH];
  508.     
  509.     if (GetTempPath(ARRAYSIZE(szPath), szPath))
  510.     {
  511.         StrCatBuff(szPath, PathFindFileName(pszFile), lstrlen(pszFile) + 1);
  512.         PathRenameExtension(szPath, TEXT(".lnk"));
  514.         if (SUCCEEDED(_CreateShortcutToPath(szPath, pszFile)))
  515.         {
  516.             StrCpyN(pszShortcut, szPath, MAX_PATH);
  517.             return TRUE;
  518.         }
  519.     }
  520.     return FALSE;
  521. } 
  523. HRESULT CopyHtmlFile(HANDLE hOrig, HANDLE hNew, DWORD dwSize)
  524. {
  525.     BYTE Buff[4096];
  526.     int iBlock, nBlocks = dwSize / SIZEOF(Buff);
  527.  
  528.     for (iBlock = 0; iBlock <= nBlocks; iBlock++)
  529.     {
  530.         DWORD dwRead, dwWrite;
  531.  
  532.         ReadFile(hOrig, Buff, SIZEOF(Buff), &dwRead, NULL);
  533.         if ((iBlock < nBlocks) && (dwRead != SIZEOF(Buff)))
  534.             return E_FAIL;
  535.         WriteFile(hNew, Buff, dwRead, &dwWrite, NULL);
  536.         if (dwWrite != dwRead)
  537.             return E_FAIL;
  538.     }
  539.  
  540.     return S_OK;
  541. }
  543. typedef BOOL (RETRIEVE_URL_CACHE_ENTRY_FILEA) (
  544. LPCSTR lpszUrlName,
  545. LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
  546. LPDWORD lpdwCacheEntryInfoBufferSize,
  547. DWORD dwReserved
  548. );
  549. typedef RETRIEVE_URL_CACHE_ENTRY_FILEA FAR *LP_RETRIEVE_URL_CACHE_ENTRY_FILEA;
  551. typedef BOOL (RETRIEVE_URL_CACHE_ENTRY_FILEW) (
  552.         LPCWSTR lpszUrlName,
  553.         LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo,
  554.         LPDWORD lpdwCacheEntryInfoBufferSize,
  555.         DWORD dwReserved
  556. );
  557. typedef RETRIEVE_URL_CACHE_ENTRY_FILEW *LP_RETRIEVE_URL_CACHE_ENTRY_FILEW;
  559. HRESULT CreateHtmlFileFromUrl(LPCTSTR pszURL, LPCTSTR pszFile)
  560. {
  561.     DWORD dwSize;
  562.     HRESULT hr = E_FAIL;
  563.     INTERNET_CACHE_ENTRY_INFO *picei=NULL;
  564.     #ifdef UNICODE
  565.     LP_RETRIEVE_URL_CACHE_ENTRY_FILEW lpfnRetrieveUrlCacheEntryFile;
  566.     #else
  567.     LP_RETRIEVE_URL_CACHE_ENTRY_FILEA lpfnRetrieveUrlCacheEntryFile;
  568.     #endif
  570.     HINSTANCE hLibWininet = LoadLibrary(TEXT("wininet.dll"));
  571.  
  572.     if (!hLibWininet)
  573.         return E_FAIL;
  575.     #ifdef UNICODE
  576.     lpfnRetrieveUrlCacheEntryFile = 
  577. (LP_RETRIEVE_URL_CACHE_ENTRY_FILEW) GetProcAddress(hLibWininet, "RetrieveUrlCacheEntryFileW");
  578.     #else
  579.     lpfnRetrieveUrlCacheEntryFile = 
  580. (LP_RETRIEVE_URL_CACHE_ENTRY_FILEA)GetProcAddress(hLibWininet, "RetrieveUrlCacheEntryFileA");
  581.     #endif
  583.     if (!lpfnRetrieveUrlCacheEntryFile)
  584. return E_FAIL;
  585.  
  586.   
  587.     // Find size of Cache Entry File struct for this url. Call fails with
  588.     // error insufficient buffer and puts size in dwSize. Any other failure
  589.     // value implies the item isn't in the cache.
  590.     dwSize = 0;
  591.     if (!lpfnRetrieveUrlCacheEntryFile(pszURL, picei, &dwSize, 0))
  592.     {
  593.         if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
  594.             picei = (INTERNET_CACHE_ENTRY_INFO *) GlobalAlloc(GPTR,  dwSize);
  595.     }
  596.     
  597.     if (picei)
  598.     {
  599.         if (lpfnRetrieveUrlCacheEntryFile(pszURL, picei, &dwSize, 0))
  600.         {
  601.             HANDLE hOrigFile = CreateFile(picei->lpszLocalFileName, GENERIC_READ, FILE_SHARE_READ, NULL,
  602.                                           OPEN_EXISTING, 0, NULL);
  603.             if (hOrigFile != INVALID_HANDLE_VALUE)
  604.             {
  605.                 HANDLE hNewFile = CreateFile(pszFile, GENERIC_READ | GENERIC_WRITE, 0, NULL,
  606.                                              CREATE_ALWAYS, 0, NULL);
  607.                 if (hNewFile != INVALID_HANDLE_VALUE)
  608.                 {
  609.                     DWORD dwWritten;
  611.                     TCHAR szBaseTag[INTERNET_MAX_URL_LENGTH + 20];
  612.                     wnsprintf(szBaseTag, ARRAYSIZE(szBaseTag), TEXT("<BASE HREF="%s">n"), pszURL);
  613.                     
  614.                     if (WriteFile(hNewFile, szBaseTag, lstrlen(szBaseTag)*SIZEOF(TCHAR), &dwWritten, NULL))
  615.                         hr = CopyHtmlFile(hOrigFile, hNewFile, picei->dwSizeLow);
  616.                     CloseHandle(hNewFile);
  617.                 }
  618.                 CloseHandle(hOrigFile);
  619.             }
  620.         }
  621.         GlobalFree(picei);
  622.     }
  623.     return hr;
  624. }
  626. extern HRESULT PersistShortcut(IUniformResourceLocator * purl, LPCWSTR pwszFile);
  628. /*
  629.  * pcszURL -> "ftp://ftp.microsoft.com"
  630.  * pcszPath -> "c:windowsdesktopinternetMicrosoft FTP.url"
  631.  */
  632. HRESULT CreateNewURLShortcut(LPCTSTR pcszURL, LPCTSTR pcszURLFile)
  633. {
  634.     HRESULT hr;
  635.     WCHAR wszFile[INTERNET_MAX_URL_LENGTH];
  637. #ifndef UNICODE
  638.     if (AnsiToUnicode(pcszURLFile,
  639.                       wszFile, ARRAYSIZE(wszFile)) > 0)
  640. #else
  641.     if (StrCpyN(wszFile, pcszURLFile, ARRAYSIZE(wszFile)) > 0)
  642. #endif
  643.     {
  644.         IUniformResourceLocator *purl;
  646.         hr = CoCreateInstance(CLSID_InternetShortcut, NULL, CLSCTX_INPROC_SERVER,
  647.                               IID_IUniformResourceLocator, (LPVOID*)&purl);
  649.         if (SUCCEEDED(hr))
  650.         {
  651.             hr = purl->SetURL( pcszURL, 0);
  652.             if (SUCCEEDED(hr))
  653.                 hr = PersistShortcut(purl, wszFile);
  654.             purl->Release();
  655.         }
  656.     }
  657.     else
  658.         hr = E_FAIL;
  660.     return(hr);
  661. }
  663. HRESULT _GetFileDescription(IDataObject * pdtobj, LPTSTR pszDescription)
  664. {
  665.     STGMEDIUM medium;
  666.     HRESULT hres;
  667.     FORMATETC fmteURL = {0, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
  668.     UINT g_cfFileDesc;
  670.     InitClipboardFormats();
  672.     #ifdef UNICODE
  673.     g_cfFileDesc = g_cfFileDescW;
  674.     #else
  675.     g_cfFileDesc = g_cfFileDescA;
  676.     #endif
  677.     
  678.     fmteURL.cfFormat = g_cfFileDesc;
  680.     hres = E_FAIL;
  681.     if (SUCCEEDED(pdtobj->GetData(&fmteURL, &medium)))
  682.     {
  683. #ifdef UNICODE
  684.         FILEGROUPDESCRIPTORW * pfgd = (FILEGROUPDESCRIPTORW *)GlobalLock(medium.hGlobal);
  685. #else   
  686.         FILEGROUPDESCRIPTORA * pfgd = (FILEGROUPDESCRIPTORA *)GlobalLock(medium.hGlobal);
  687. #endif
  688.         if (pfgd)
  689.         {
  690. #ifdef UNICODE
  691.             FILEDESCRIPTORW * pfd = &(pfgd->fgd[0]);
  692. #else           
  693.             FILEDESCRIPTORA * pfd = &(pfgd->fgd[0]);
  694. #endif                  
  696.             StrCpyN(pszDescription, (LPTSTR)pfd->cFileName, lstrlen((LPTSTR)pfd->cFileName) + 1);
  697.             GlobalUnlock(medium.hGlobal);
  698.             PathRemoveExtension(pszDescription);
  699.             hres = S_OK;
  700.         }
  701.     }
  702.     ReleaseStgMedium(&medium);
  703.     return hres;
  704. }       
  706. #define STR_SENDMAIL_URL_FILENAME     TEXT("Send Mail Message.url")
  707. #define STR_SENDMAIL_HTM_FILENAME      TEXT("Send Mail Message.htm")
  708. #define STR_SENDMAIL_URL_SHORTFILENAME TEXT("SendMail.url")
  709. #define STR_SENDMAIL_HTM_SHORTFILENAME TEXT("SendMaihtm")
  710. #define STR_SENDMAIL_FAILUREMSG        TEXT("The current document is not available. Would  you like to send the URL instead?")
  711. #define STR_SENDMAIL_FAILUREMSGTITLE   TEXT("SendMail Failed")
  713. HRESULT _CreateFileToSend(IDataObject *pdtobj, MRPARAM * pmp, DWORD grfKeyState)
  714. {
  715.     HRESULT hr;
  716.     BOOL bCreateUrl = FALSE;
  718.     hr = E_FAIL;
  719.     if (grfKeyState != FORCE_LINK)
  720.     {
  721.         hr = CreateHtmlFileFromUrl(pmp->pszURL, pmp->pszFiles);
  722.         if (FAILED(hr))
  723.         {
  724.             int iRet;
  725.                         
  726.             iRet = ShellMessageBox(MLGetHinst(),
  727.                                    NULL,
  728.                                    STR_SENDMAIL_FAILUREMSG,
  729.                                    STR_SENDMAIL_FAILUREMSGTITLE,
  730.                                    MB_YESNO);
  731.             if (iRet == IDYES)
  732.             {
  733.                 PathRenameExtension(pmp->pszFiles, TEXT(".url"));
  734.                 PathYetAnotherMakeUniqueName(pmp->pszFiles, pmp->pszFiles, pmp->pszFiles, pmp->pszFiles);      
  735.                 bCreateUrl = TRUE;
  736.             }
  737.         }
  738.         else
  739.         {
  740.             // We have succeeded in creating the HTML DOC to send
  741.             IQueryCodePage * pQcp;
  743.             // First set the flag for sending a doc
  744.             pmp->dwFlags |= MRPARAM_DOC;
  746.             // Then get the code page if there is one
  747.             if (SUCCEEDED(pdtobj->QueryInterface(IID_IQueryCodePage, (LPVOID *)&pQcp)))
  748.             {
  749.                 if (SUCCEEDED(pQcp->GetCodePage( &pmp->uiCodePage)))
  750.                     pmp->dwFlags |= MRPARAM_USECODEPAGE;
  751.                 pQcp->Release();
  752.             }
  753.         }
  754.     }
  755.     else
  756.         bCreateUrl = TRUE;
  757.     
  758.     if (bCreateUrl)
  759.         hr = CreateNewURLShortcut(pmp->pszURL, pmp->pszFiles);
  761.     pmp->dwFlags |= MRPARAM_DELETEFILE;
  763.     // Get the title of this homepage
  764.     if (SUCCEEDED(hr))
  765.         _GetFileDescription(pdtobj, pmp->pszURL);
  766.     
  767.     return hr;
  768. }
  770. HRESULT _GetFilesFromDataObj(IDataObject *pdtobj, DWORD grfKeyState, MRPARAM * pmp)
  771. {
  772.     HRESULT hr = E_FAIL;
  773.     STGMEDIUM medium;
  774.     FORMATETC fmteHDROP = {CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
  775.     FORMATETC fmteURL = {g_cfURL, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
  777.     
  778.     if (SUCCEEDED(pdtobj->GetData(&fmteHDROP, &medium)))
  779.     {
  780.         TCHAR szPath[MAX_PATH];
  782.         DWORD cchFileBufferSize = 0;   // This will be the size of the buffer that holds all files names
  783.         DWORD cchUrlBufferSize = 0;
  785.         for (pmp->nFiles = 0; DragQueryFile((HDROP)medium.hGlobal, pmp->nFiles, szPath, ARRAYSIZE(szPath)); pmp->nFiles++)         
  786.             cchFileBufferSize += (lstrlen(szPath) + 1) * SIZEOF(TCHAR);
  787.     
  788.         cchUrlBufferSize += MAX_PATH * SIZEOF(TCHAR) * pmp->nFiles;
  790.         if (cchFileBufferSize && AllocatePMP(pmp, cchFileBufferSize, cchUrlBufferSize))
  791.         {
  792.             int i;
  793.             LPTSTR psz, pszNames;
  794.             for (i = 0, psz = pmp->pszFiles, pszNames = pmp->pszURL; DragQueryFile((HDROP)medium.hGlobal, i, szPath, ARRAYSIZE(szPath)); i++)            {
  795.                 // This is used to separate the names
  796.                 if (pszNames != pmp->pszURL)
  797.                     *pszNames++ = TEXT(';');
  798.                 
  799.                 if (grfKeyState == FORCE_LINK)
  800.                 {
  801.                     // Want to send a link even for the real file, we will create links to the real files
  802.                     // and send it.
  803.                     TCHAR szShortCut[MAX_PATH];
  804.                     if (_CreateTempFileShortcut(szPath, szShortCut))
  805.                         StrCpyN(psz, szShortCut, MAX_PATH);
  806.                     pmp->dwFlags |= MRPARAM_DELETEFILE;
  807.                 }
  808.                 else
  809.                     StrCpyN(psz, szPath, MAX_PATH);
  810.                 psz += lstrlen(psz) + 1;
  811.                 
  812.                 StrCpyN(pszNames, szPath, MAX_PATH);
  813.                 pszNames += lstrlen(szPath);
  814.             }
  815.             hr = S_OK;
  816.         }
  817.     }
  818.     else if (SUCCEEDED(pdtobj->GetData( &fmteURL, &medium)))
  819.     {
  820.         // This DataObj is from the internet -----------------
  821.         // NOTE: We only allow to send one file here.
  822.         pmp->nFiles = 1;
  823.         if (AllocatePMP(pmp, max(SIZEOF(TCHAR)*GlobalSize(medium.hGlobal), MAX_PATH)
  824. , MAX_PATH))
  825.         {
  826.             if ((fmteURL.cfFormat == g_cfURL) && (TYMED_HGLOBAL == medium.tymed))
  827.             {
  829. #ifdef UNICODE
  830.                 // medium.hGlobal is an ansi string
  831.                 LPSTR pchBuf = NULL;
  832.                 int cchLen = strlen((LPSTR)GlobalLock(medium.hGlobal)) + 1;
  833.                 int cchBufLen = max(SIZEOF(TCHAR)*GlobalSize(medium.hGlobal), MAX_PATH);
  834.                 if (!(pchBuf = (LPSTR)GlobalAlloc(GPTR, max(SIZEOF(TCHAR)*GlobalSize(medium.hGlobal), MAX_PATH) * sizeof(CHAR))))
  835.                  return E_FAIL;
  837.                 strncpy(pchBuf, (LPSTR)GlobalLock(medium.hGlobal), cchLen);
  838.                 AnsiToUnicode(pchBuf, pmp->pszURL, cchBufLen);
  839.                 GlobalFree(pchBuf);
  840. #else
  841.                 StrCpyN(pmp->pszURL, (LPTSTR)GlobalLock(medium.hGlobal), lstrlen((LPTSTR)GlobalLock(medium.hGlobal)) + 1);
  842. #endif
  843.                 GlobalUnlock(medium.hGlobal);
  844.             }
  846.             if (pmp->pszURL[0])
  847.             {
  848.                 // Note some of these functions depend on which OS we
  849.                 // are running on to know if we should pass ansi or unicode strings
  850.                 // to it
  851.                 // Windows 95
  852.                 if (GetTempPath(MAX_PATH, pmp->pszFiles))
  853.                 {
  854.                     TCHAR szFileName[MAX_PATH];
  855.                     TCHAR szShortFileName[20];
  857.                     StrCpyN(szFileName, (grfKeyState == FORCE_LINK) ? STR_SENDMAIL_URL_FILENAME : STR_SENDMAIL_HTM_FILENAME, MAX_PATH);
  858.                     StrCpyN(szShortFileName, (grfKeyState == FORCE_LINK) ? STR_SENDMAIL_URL_SHORTFILENAME : STR_SENDMAIL_HTM_SHORTFILENAME, 20);
  860.                     if (PathYetAnotherMakeUniqueName(pmp->pszFiles, pmp->pszFiles, szShortFileName, szFileName)) 
  861.                         hr = _CreateFileToSend(pdtobj, pmp, grfKeyState);
  862.                 }
  863.                 
  864.             }
  865.             
  866.         }
  867.     }   
  869.     ReleaseStgMedium(&medium);
  870.     return hr;
  871. }
  873. typedef struct {
  874.     CHAR szTempShortcut[MAX_PATH];
  875.     WCHAR szTempShortcutW[MAX_PATH];
  876.     MapiMessage mm;
  877.     MapiFileDesc mfd[1];
  878. } MAPI_FILES;
  880. void _FreeMapiFiles(MAPI_FILES *pmf)
  881. {
  882.     if (pmf->szTempShortcut[0])
  883.         DeleteFile(pmf->szTempShortcutW);
  884.     GlobalFree(pmf);
  885. }
  887. MAPI_FILES *_AllocMapiFiles(int nFiles, LPCTSTR pszFiles, MRPARAM *pmp)
  888. {
  889.     MAPI_FILES *pmf;
  891.     pmf = (MAPI_FILES *)GlobalAlloc(GPTR, SIZEOF(*pmf) + (nFiles * SIZEOF(pmf->mfd[0])));
  892.     if (pmf)
  893.     {
  894.         int i;
  896.         pmf->mm.nFileCount = nFiles;
  897.         if (nFiles)
  898.         {
  899.             LPCTSTR psz;
  901.             pmf->mm.lpFiles = pmf->mfd;
  903.             for (i = 0, psz = pszFiles; ((i < nFiles) && (*psz)); psz += lstrlen(psz) + 1, i++)
  904.             {
  905.                 // if the first item is a folder, we will create a shortcut to
  906.                 // that instead of trying to mail the folder (that MAPI does
  907.                 // not support)
  909.                 if ((i == 0) && PathIsDirectory(pszFiles) &&
  910. #ifndef UNICODE
  911.                     _CreateTempFileShortcut(pszFiles, pmf->szTempShortcut))
  912. #else
  913.                     _CreateTempFileShortcut(pszFiles, pmf->szTempShortcutW))
  914. #endif
  915.                 {
  916. #ifdef UNICODE
  917.     WCHAR wszTemp;
  918.     WideCharToMultiByte(CP_ACP, 0, pmf->szTempShortcutW, -1, 
  919. pmf->szTempShortcut, MAX_PATH, 
  920. NULL, NULL);
  921. #endif
  922.                     pmf->mfd[i].lpszPathName = pmf->szTempShortcut;
  923. #ifndef UNICODE
  924.                     pmf->mfd[i].lpszFileName = PathFindFileName(pszFiles);
  925. #else
  926.     WideCharToMultiByte(CP_ACP, 0, pszFiles, -1, 
  927. pmp->paszFiles, MAX_PATH, 
  928. NULL, NULL);
  929.                     pmf->mfd[i].lpszFileName = PathFindFileNameA(pmp->paszFiles);
  930. #endif
  931.                 }
  932.                 else
  933.                 {
  934. #ifndef UNICODE
  935.                     pmf->mfd[i].lpszPathName = (LPTSTR)psz; // const -> non const
  936.                     pmf->mfd[i].lpszFileName = PathFindFileName(psz);
  937. #else
  938.     WideCharToMultiByte(CP_ACP, 0, psz, -1, 
  939. pmp->paszFiles, MAX_PATH, 
  940. NULL, NULL);
  941.                     pmf->mfd[i].lpszPathName = pmp->paszFiles; // const -> non const
  942.                     pmf->mfd[i].lpszFileName = PathFindFileNameA(pmp->paszFiles);
  943. #endif
  944.                 }
  945.                 pmf->mfd[i].nPosition = (UINT)-1;
  946.             }
  947.         }
  948.     }
  949.     return pmf;
  950. }
  952. BOOL _IsShortcut(LPCTSTR pszFile)
  953. {
  954.     SHFILEINFO sfi;
  955.     return SHGetFileInfo(pszFile, 0, &sfi, sizeof(sfi), SHGFI_ATTRIBUTES) && (sfi.dwAttributes & SFGAO_LINK);
  956. }
  959. // get the target of a shortcut. this uses IShellLink which 
  960. // Internet Shortcuts (.URL) and Shell Shortcuts (.LNK) support so
  961. // it should work generally
  962. //
  963. BOOL _GetShortcutTarget(LPCTSTR pszPath, LPTSTR pszTarget, UINT cch)
  964. {
  965.     IUnknown *psl;
  966.     CLSID clsid;
  968.     *pszTarget = 0;     // assume none
  970.     if (!_IsShortcut(pszPath))
  971.         return FALSE;
  973.     // BUGBUG: we really should call GetClassFile() but this could
  974.     // slow this down a lot... so chicken out and just look in the registry
  976.     if (FAILED(_CLSIDFromExtension(PathFindExtension(pszPath), &clsid)))
  977.         clsid = CLSID_ShellLink;        // assume it's a shell link
  979.     if (SUCCEEDED(CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, IID_IUnknown, (LPVOID *)&psl)))
  980.     {
  981.         IPersistFile *ppf;
  983.         if (SUCCEEDED(psl->QueryInterface(IID_IPersistFile, (LPVOID *)&ppf)))
  984.         {
  985. #ifdef UNICODE
  986.             ppf->Load(pszPath, 0);
  987. #else
  988.             WCHAR wszPath[MAX_PATH];
  989.             AnsiToUnicode(pszPath, wszPath, ARRAYSIZE(wszPath));
  991.             ppf->Load(wszPath, 0);
  992. #endif
  993.             ppf->Release();
  994.         }
  995.         IShellLink_GetPath(psl, pszTarget, cch, SLGP_UNCPRIORITY);
  996.         psl->Release();
  998.         return TRUE;
  999.     }
  1001.     return FALSE;
  1002. }
  1004. void _DeleteMultipleFiles(LPCTSTR pszFiles)
  1005. {
  1006.     int i;
  1007.     LPCTSTR psz;
  1008.     for (i = 0, psz = pszFiles; *psz; psz += lstrlen(psz) + 1, i++)
  1009.         DeleteFile(psz);
  1010. }
  1012. const TCHAR c_szPad[] = TEXT(" rn ");
  1014. STDAPI_(DWORD) MailRecipientThreadProc(void *pmp)
  1015. {
  1016.     TCHAR szText[2148];     // hold a URL/FilePath + some formatting text
  1017. #ifdef UNICODE
  1018.     CHAR aszText[2148];     // hold a URL/FilePath + some formatting text
  1019. #endif
  1020.     MAPI_FILES *pmf;
  1022.     DWORD dwFlags = ((MRPARAM *)pmp)->dwFlags;
  1023.     LPCTSTR pv = ((MRPARAM *)pmp)->pszFiles;
  1024.     LPCTSTR pszTitle = ((MRPARAM *)pmp)->pszURL; 
  1026.     CoInitialize(NULL);     // we are going to do some COM stuff
  1028.     pmf = _AllocMapiFiles(((MRPARAM *)pmp)->nFiles, pv, (MRPARAM *)pmp);
  1029.     if (pmf)
  1030.     {
  1031.         TCHAR szTitle[80]; // because the title is supposed to be non-const
  1032. #ifdef UNICODE
  1033.         CHAR aszTitle[80]; // because the title is supposed to be non-const
  1034. #endif
  1035.         HMODULE hmodMail;
  1037.         if (pmf->mm.nFileCount)
  1038.         {
  1039.             StrCpyN(szText, c_szPad, lstrlen(c_szPad) + 1);    // init the buffer with some stuff
  1040.             if (_IsShortcut(pv))
  1041.                 _GetShortcutTarget(pv, szText + ARRAYSIZE(c_szPad) - 1, ARRAYSIZE(szText) - ARRAYSIZE(c_szPad));
  1042.             else
  1043.                 StrCpyN(szText + ARRAYSIZE(c_szPad) - 1, pszTitle, ARRAYSIZE(szText) - ARRAYSIZE(c_szPad));
  1045.             // Don't fill in lpszNoteText if we know we are sending documents because Athena puke on it 
  1046.             if (!(dwFlags & MRPARAM_DOC))
  1047.     {
  1048. #ifndef UNICODE
  1049.                 pmf->mm.lpszNoteText = szText;
  1050. #else
  1051. WideCharToMultiByte(CP_ACP, 0, szText, -1, 
  1052.     aszText, 2148, 
  1053.     NULL, NULL);
  1054.                 pmf->mm.lpszNoteText = aszText;
  1055. #endif
  1056.     }
  1058.             if (pszTitle) {
  1059.                 StrCpyN(szTitle, pszTitle, ARRAYSIZE(szTitle));
  1060. #ifndef UNICODE
  1061.                 pmf->mm.lpszSubject = szTitle;
  1062. #else
  1063. WideCharToMultiByte(CP_ACP, 0, szTitle, -1, 
  1064.     aszTitle, 80, 
  1065.     NULL, NULL);
  1066.                 pmf->mm.lpszSubject = aszTitle;
  1067. #endif
  1068.             } else
  1069. #ifndef UNICODE
  1070.                 pmf->mm.lpszSubject = szText + ARRAYSIZE(c_szPad) - 1;
  1071. #else
  1072.                 pmf->mm.lpszSubject = aszText + ARRAYSIZE(c_szPad) - 1;
  1073. #endif
  1074.         }
  1076.         hmodMail = (HINSTANCE) LoadMailProvider();
  1077.         if (dwFlags & MRPARAM_USECODEPAGE)
  1078.         {
  1079.             // When this flag is set, we know that we have just one file to send and we have a code page
  1080.             // Athena will then look at ulReserved for the code page
  1081.             // BUGBUG: Will the other MAPI handlers puke on this?  -- dli
  1082.             ASSERT(pmf->mm.nFileCount == 1);
  1083.             pmf->mfd[0].ulReserved = ((MRPARAM *)pmp)->uiCodePage;
  1084.         }
  1085.         
  1087.         if (hmodMail)
  1088.         {
  1089.             LPMAPISENDMAIL pfnSendMail = (LPMAPISENDMAIL)GetProcAddress(hmodMail, "MAPISendMail");
  1090.             if (pfnSendMail)
  1091.                 pfnSendMail(0, 0, &pmf->mm, MAPI_LOGON_UI | MAPI_DIALOG, 0);
  1093.             FreeLibrary(hmodMail);
  1094.         }
  1095.         _FreeMapiFiles(pmf);
  1096.     }
  1097.     
  1098.     if (pv && (dwFlags & MRPARAM_DELETEFILE))
  1099.         _DeleteMultipleFiles(pv);
  1100.     
  1101.     if (pmp)
  1102.         CleanupPMP((MRPARAM *)pmp);
  1104.     CoUninitialize();
  1106.     // SetCursor(hcurOld);
  1108.     return 0;
  1109. }
  1111. STDAPI MailRecipientDropHandler(IDataObject *pdtobj, DWORD grfKeyState, DWORD dwEffect)
  1112. {
  1113.     HANDLE hThread;
  1114.     DWORD idThread;
  1115.     MRPARAM * pmp = (MRPARAM *)GlobalAlloc(GPTR, SIZEOF(*pmp));
  1116.     if (pmp)
  1117.     {        
  1118. InitClipboardFormats();
  1120.         if (!pdtobj || SUCCEEDED(_GetFilesFromDataObj(pdtobj, grfKeyState, pmp)))
  1121.         {
  1124.             hThread = CreateThread(NULL, 0, MailRecipientThreadProc, pmp, 0, &idThread);
  1125.             if (hThread)
  1126.             {
  1127.                 CloseHandle(hThread);
  1128.                 return S_OK;
  1129.             }
  1130.         }
  1131.         
  1132.         CleanupPMP(pmp);
  1133.  
  1134. return S_OK;
  1135.     }
  1136.  
  1137.     return E_OUTOFMEMORY;       
  1138. }
  1140. HRESULT _UnixDropOnMailRecipient(IDataObject *pdtobj, DWORD grfKeyState)
  1141. {
  1142.     HRESULT hres = ERROR_SUCCESS;
  1144.     MailRecipientDropHandler(pdtobj, grfKeyState, 0);
  1145.     return hres;
  1146. }
  1147.  
  1149. EXTERN_C HRESULT _UnixSendDocToOE(LPCITEMIDLIST pidl, UINT uiCodePage, DWORD grfKeyState)
  1150. {
  1151.     IDataObject *pdtobj;
  1152.     HRESULT hres;
  1154.     if (!pidl)
  1155.         hres = _UnixDropOnMailRecipient(NULL, grfKeyState);
  1156.     else 
  1157.     {
  1158.         hres = GetDataObjectForPidl(pidl, &pdtobj);
  1159.         if (SUCCEEDED(hres))
  1160.         {
  1161.             IQueryCodePage * pQcp;
  1162.             if (SUCCEEDED(pdtobj->QueryInterface(IID_IQueryCodePage, (LPVOID *)&pQcp)))
  1163.             {
  1164.                 pQcp->SetCodePage(uiCodePage);
  1165.                 pQcp->Release();
  1166.             }
  1167.             hres = _UnixDropOnMailRecipient(pdtobj, grfKeyState);
  1168.             pdtobj->Release();
  1169.         }
  1170.     }
  1172.     return hres;
  1173. }
  1174. // PORT
  1177. EXTERN_C void   UnixAdjustWindowSize( HWND hwnd, IETHREADPARAM* piei )
  1178. {
  1179.         // IEUNIX - Default window size is too small
  1180.         // We come up with this size if there is no saved stream for window
  1181.         // placement, in which case piei->wb.length is zero
  1182.        char szGeometry[MAX_PATH];
  1184.        /* If the geometry was specified on the command line use it */
  1185.        if (MwGetXInvocationParam("-geometry", szGeometry, MAX_PATH)) {
  1186.           int   wMask      = 0;
  1187.           int   wXOffset   = 0;
  1188.           int   wYOffset   = 0;
  1189.           UINT  wHeight    = 0;
  1190.           UINT  wWidth     = 0;
  1191.           RECT  rc;        /* info about browser window */
  1192.           RECT  rcDisplay; /* to get info about desktop */
  1193.          
  1194.           /* Mask is mainwin mask */
  1195.           wMask = MwProtectedParseXGeometry(szGeometry, 
  1196.                                             &wXOffset, &wYOffset,
  1197.                                             &wWidth, &wHeight);
  1198.  
  1199.           GetWindowRect( hwnd, &rc );
  1200.           GetWindowRect( GetDesktopWindow(), &rcDisplay );
  1202.           if (!(wMask & MwHeightValue))
  1203.           {
  1204.              if (!(piei->wp.length))
  1205.              {
  1206.                 wHeight = BROWSER_DEFAULT_HEIGHT;
  1207.              }
  1208.              else
  1209.              {
  1210.                 wHeight = rc.bottom - rc.top;
  1211.              }
  1212.           }
  1214.           if (!(wMask & MwWidthValue))
  1215.           {
  1216.              if (!(piei->wp.length))
  1217.              {
  1218.                 wWidth = BROWSER_DEFAULT_WIDTH;
  1219.              }
  1220.              else
  1221.              {
  1222.                 wWidth = rc.right - rc.left;
  1223.              }
  1224.           }
  1226.           if (!(wMask & MwXValue))
  1227.           {
  1228.              wXOffset = rc.left;
  1229.           }
  1230.           else
  1231.           if (wMask & MwXNegative)
  1232.           {
  1233.              /* wXOffset will be negative */
  1234.              wXOffset = max( 0, rcDisplay.right - rcDisplay.left - wWidth + wXOffset );
  1235.           }
  1237.           if (!(wMask & MwYValue))
  1238.           {
  1239.              wYOffset = rc.top;
  1240.           }
  1241.           else
  1242.           if (wMask & MwYNegative)
  1243.           {
  1244.              /* wYOffset will be negative */
  1245.              wYOffset = max( 0, rcDisplay.bottom - rcDisplay.top - wHeight + wYOffset );
  1246.           }
  1248.           if (!wYOffset)
  1249.           {
  1250.              wYOffset = 1;
  1251.           }
  1253.           if (!wXOffset)
  1254.           {
  1255.              wXOffset = 1;
  1256.           }
  1258.           SetWindowPos(hwnd, 0, 
  1259.                        wXOffset, wYOffset, wWidth, wHeight,
  1260.                        SWP_NOZORDER);
  1261.        }
  1262.        else
  1263.        if (piei->wp.length == 0) {
  1264.            RECT rc;
  1265.            GetWindowRect( hwnd, &rc );
  1266.            SetWindowPos ( hwnd, 0, rc.left, rc.top, BROWSER_DEFAULT_WIDTH, BROWSER_DEFAULT_HEIGHT, SWP_NOZORDER );
  1267.        }
  1268. }
  1270. #if 0 //def NO_MARSHALLING
  1271. void IEFrame_NewWindow_SameThread(IETHREADPARAM* piei)
  1272. {
  1273.     DWORD uFlags = piei->uFlags;
  1274.     
  1275.     LPSTR pszCloseEvent = NULL;
  1276.     if (uFlags & COF_FIREEVENTONCLOSE) {
  1277.         ASSERT(piei->szCloseEvent[0]);
  1278.         pszCloseEvent = StrDup(piei->szCloseEvent);
  1279.     }
  1281.     THREADWINDOWINFO *lpThreadWindowInfo;
  1282.     ASSERT (~0 != g_TLSThreadWindowInfo)
  1283.     lpThreadWindowInfo = (THREADWINDOWINFO *) TlsGetValue(g_TLSThreadWindowInfo);
  1285.     ASSERT (lpThreadWindowInfo); // if we don't have this, then a thread isn't running, and we're hosed.
  1286.     if (!lpThreadWindowInfo)
  1287.     {
  1288.         goto Done;
  1289.     }
  1291. #define DWSTYLE WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN
  1293. #ifdef DEBUG_EXPLORER
  1294.     piei->wv.bTree = TRUE;
  1295.     piei->TreeSplit = 200; // some random default
  1296. #endif
  1298.     TraceMsg(TF_COCREATE, "IEFrame_NewWindow_SameThread calling CreateWindowEx");
  1300.     LPCTSTR pszClass;
  1301.     if (piei->uFlags & COF_EXPLORE) {
  1302.         pszClass = c_szExploreClass;
  1303.     } else if (piei->uFlags & COF_IEXPLORE) {
  1304.         pszClass = c_szIExploreClass;
  1305.     } else {
  1306.         pszClass = c_szCabinetClass;
  1307.     }
  1308.     
  1309.     {
  1310.     HMENU hmenu = g_hmenuFullSB;
  1311.     if (!(g_bBrowserFlags & BROWF_CLASSICMENUS))
  1312.         hmenu = NULL;
  1314.     HWND hwnd = CreateWindowEx(
  1315. #ifdef WIN16
  1316.        0,
  1317. #else
  1318.        WS_EX_WINDOWEDGE,
  1319. #endif
  1320.                                pszClass,
  1321.                                NULL, DWSTYLE,
  1322.                                CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
  1323.                                NULL, 
  1324.                                hmenu, 
  1325.                                HINST_THISDLL, piei);
  1327.     if (hwnd)
  1328.     {
  1329.         // Enable File Manager drag-drop for win16
  1330.         DragAcceptFiles(hwnd, TRUE);
  1332.         CShellBrowser* psb = (CShellBrowser*)SendMessage(hwnd, WMC_GETTHISPTR, 0, 0);
  1334.         if (psb)
  1335.         {
  1336.             psb->_AfterWindowCreated(piei);
  1338.             lpThreadWindowInfo->cWindowCount++;
  1339.             // tack new window on end of list
  1340.             CShellBrowser** rgpsb = (CShellBrowser**)
  1341.                 LocalReAlloc(lpThreadWindowInfo->rgpsb, 
  1342.                              lpThreadWindowInfo->cWindowCount * sizeof(CShellBrowser *),
  1343.                              LMEM_MOVEABLE);
  1344.             ASSERT(rgpsb);
  1345.             if (rgpsb)
  1346.             {
  1347.                 lpThreadWindowInfo->rgpsb = rgpsb;
  1348.                 rgpsb[lpThreadWindowInfo->cWindowCount-1] = psb;
  1349.                 psb->AddRef();
  1350.             }
  1352.             // The message pump would go here.
  1353.             // Let the threadproc handle it.
  1355.             psb->Release();
  1356.         }
  1357.         
  1358.     } else {
  1359.         // Unregister any pending that may be there
  1360.         WinList_Revoke(piei->dwRegister);
  1361.         TraceMsg(DM_ERROR, "IEFrame_NewWindow_SameThread CreateWindow failed");
  1362.     }
  1363.     }
  1365. Done:
  1366.     if (pszCloseEvent)
  1367.     {
  1368.         FireEventSz(pszCloseEvent);
  1369.     }
  1371.     if (piei)
  1372.         delete piei;
  1373. }
  1374. #endif // NO_MARSHALLING
  1376. BOOL CheckForValidSourceFile(HWND hDlg, LPTSTR szPath, LPTSTR szDisplay )
  1377. {
  1378.     BOOL fRet = FALSE, err = FALSE;
  1380.     if(  szPath && *szPath && PathIsFilePath(szPath) && PathFileExists(szPath) )
  1381.     {
  1382.          HANDLE hFile = CreateFile( szPath, GENERIC_READ, 0, NULL, OPEN_EXISTING, 
  1383.                                    FILE_ATTRIBUTE_NORMAL, NULL);
  1384.          if( hFile != INVALID_HANDLE_VALUE ) 
  1385.          {
  1386.              if( GetFileSize( hFile, NULL ) <= (DWORD)0 )
  1387.              {
  1388.                  err = TRUE; 
  1389.              }
  1391.              CloseHandle(hFile);
  1392.          }
  1393.          else
  1394.          {
  1395.              err = TRUE;
  1396.          } 
  1397.     }
  1398.     else
  1399.     {
  1400.         err = TRUE;
  1401.     }
  1403.     if( err )
  1404.     {
  1405.         TCHAR message[ MAX_URL_STRING + MAX_DISPLAY_LEN  + 3];
  1406.         TCHAR title [TITLE_LEN];
  1407.         StrCpyN( message, szDisplay, lstrlen(szDisplay) + 1 );
  1408.         message[ lstrlen( szDisplay ) ] = TEXT('n');
  1409.         message[ lstrlen( szDisplay ) + 1 ] = TEXT('n');
  1410.         MLLoadString(IDS_DOWNLOAD_BADCACHE,
  1411.                       message + lstrlen(szDisplay) + 2,
  1412.                       ARRAYSIZE(message) - lstrlen(szDisplay) - 2);
  1413.         MLLoadString(IDS_DOWNLOADFAILED, title, ARRAYSIZE(title));
  1414.         MessageBox( hDlg, message, title, MB_ICONWARNING|MB_OK);
  1415.         return fRet;
  1416.     }
  1418.     return TRUE;
  1419. }
  1421. STDAPI UnixSendDocToMailRecipient(LPCITEMIDLIST pidl, UINT uiCodePage, DWORD grfKeyState)
  1422. {
  1423.     HRESULT hres;
  1424.     IUniformResourceLocator *purl;
  1425.     IShellLink *psl;
  1426.     LPTSTR lptszURLName;
  1427.     CHAR szTitle[MAX_URL_STRING];
  1428.     IShellFolder *psfParent;
  1429.     LPCITEMIDLIST pidlChild;
  1430.     TCHAR           tszCommandLine[INTERNET_MAX_URL_LENGTH];
  1431.     TCHAR           tszExpandedCommand[INTERNET_MAX_URL_LENGTH];
  1432.     TCHAR tszTempFile1[MAX_PATH];
  1433.     TCHAR tszTempFile2[MAX_PATH];
  1434.     TCHAR tszTempFile[MAX_PATH];
  1435.     UINT            nCommandSize;
  1436.     int             i;
  1437.     HKEY    hkey;
  1438.     DWORD   dw;
  1439.     TCHAR *pchPos;
  1440.     BOOL bMailed;
  1441.     STARTUPINFO stInfo;
  1442.     SYSTEMTIME systemtime;
  1443.     int pid;
  1444.     UINT uUnique;
  1446.     szTitle[0] = '';
  1448.     hres = RegCreateKeyEx(HKEY_CURRENT_USER, REGSTR_PATH_MAILCLIENTS, 0, NULL, 0, 
  1449.                           KEY_READ, NULL, &hkey, &dw);
  1450.     if (hres == ERROR_SUCCESS)
  1451.     {
  1452.         dw = INTERNET_MAX_URL_LENGTH;
  1453.         hres = RegQueryValueEx(hkey, REGSTR_PATH_CURRENT, NULL, NULL, 
  1454.                                (LPBYTE)tszCommandLine, &dw);
  1455.         RegCloseKey(hkey);
  1457.         if (hres == ERROR_SUCCESS)
  1458.         {           
  1459.             dw = SHExpandEnvironmentStrings(tszCommandLine, tszExpandedCommand, 
  1460.                                           INTERNET_MAX_URL_LENGTH);
  1461.              _tcscpy(tszCommandLine, TEXT("X "));
  1462.              _tcscat(tszCommandLine, tszExpandedCommand);
  1463.              memset(&stInfo, 0, sizeof(stInfo));
  1464.              stInfo.cb = sizeof(stInfo);
  1465.              for (i = _tcslen(tszCommandLine); i > 0; i--)
  1466.              {
  1467.                  if (tszCommandLine[i] == '/')
  1468.                  {
  1469.                       tszCommandLine[i] = '';
  1470.                       break;
  1471.                  }
  1472.              }
  1473.              if (!pidl)
  1474.              {
  1475.                  if (grfKeyState == MAIL_ACTION_SEND)
  1476.                  {
  1477.                      _tcscat(tszCommandLine, MAILTO_0_OPTION);
  1478.                  }
  1479.                  else if (grfKeyState == MAIL_ACTION_READ)
  1480.                  {
  1481.                      _tcscat(tszCommandLine, READMAIL_OPTION);
  1482.                  }
  1483.                  bMailed = CreateProcess(tszExpandedCommand, tszCommandLine, NULL, NULL, 
  1484.                                         FALSE, DETACHED_PROCESS, NULL, 
  1485.                                         NULL, &stInfo, NULL);
  1486.                  return hres;
  1487.              }
  1488.          }
  1489.          else
  1490.          {
  1491.              return hres;
  1492.          }
  1493.     }
  1494.     else
  1495.     {
  1496.          return hres;
  1497.     }
  1499.     hres = CoCreateInstance(CLSID_InternetShortcut, NULL, CLSCTX_INPROC_SERVER, 
  1500.                             IID_IUniformResourceLocator, (LPVOID*)&purl);
  1501.     if (SUCCEEDED(hres))
  1502.     {
  1503.         hres = purl->QueryInterface(IID_IShellLink, (LPVOID*)&psl);
  1504.         if (SUCCEEDED(hres))
  1505.         {
  1506.             hres = psl->SetIDList(pidl);
  1507.             psl->Release();
  1508.         }
  1510.         hres = purl->GetURL(&lptszURLName);
  1511.         if (SUCCEEDED(hres))
  1512.         {
  1513.             hres = IEBindToParentFolder(pidl, &psfParent, &pidlChild);
  1514.             if (SUCCEEDED(hres))
  1515.             {
  1516.                 STRRET sr;
  1518.                 hres = psfParent->GetDisplayNameOf(pidlChild, SHGDN_INFOLDER | SHGDN_NORMAL, &sr);
  1519.                 if (SUCCEEDED(hres))
  1520.                     hres = StrRetToBufA(&sr, pidlChild, szTitle, ARRAYSIZE(szTitle));
  1521.                 psfParent->Release();
  1522.             }       
  1524.             tszTempFile[0] = '';
  1525.             GetTempPath(MAX_PATH, tszTempFile);
  1527.             _tcscpy(tszTempFile1, tszTempFile);
  1528.             _tcscpy(tszTempFile2, tszTempFile);
  1529.             
  1530.             if (grfKeyState == FORCE_LINK)
  1531.                 _tcscat(tszCommandLine, MAILLINK_OPTION);
  1532.             else if (grfKeyState == FORCE_COPY)
  1533.                 _tcscat(tszCommandLine, MAILPAGE_OPTION);
  1535.             _tcscat(tszTempFile1, TEXT(".#temp1"));
  1536.             _tcscat(tszTempFile2, TEXT(".#temp2"));
  1538.             pid = _getpid();
  1539.             GetSystemTime(&systemtime);
  1541.             uUnique = systemtime.wMilliseconds + systemtime.wSecond * pid;
  1542.             
  1543.             if (uUnique == GetTempFileName(TEXT("."), NULL, uUnique, tszTempFile))
  1544.             {
  1545.                 HANDLE hTempFile1, hTempFile2;
  1546.                 
  1547.                 _tcscat(tszTempFile1, tszTempFile);
  1548.                 _tcscat(tszTempFile2, tszTempFile);
  1549.                 
  1550.                 hTempFile1 = CreateFile(tszTempFile1, GENERIC_WRITE, FILE_SHARE_READ, 
  1551.                                         NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  1552.                 if (hTempFile1 != INVALID_HANDLE_VALUE)
  1553.                 {
  1554.                     hTempFile2 = CreateFile(tszTempFile2, GENERIC_WRITE, FILE_SHARE_READ, 
  1555.                                             NULL, CREATE_ALWAYS, 
  1556.                                             FILE_ATTRIBUTE_NORMAL, NULL);
  1557.                     if (hTempFile2 != INVALID_HANDLE_VALUE)
  1558.                     {
  1559.                         CHAR szURLName[MAX_URL_STRING];
  1560.                         DWORD dw;
  1562.                         WriteFile(hTempFile1, szTitle, 
  1563.                                   lstrlenA(szTitle) + 1, 
  1564.                                   &dw, NULL);
  1565.                         WideCharToMultiByte(CP_ACP, 0, lptszURLName, -1, 
  1566.                                             szURLName, MAX_URL_STRING, NULL, NULL);
  1567.                         WriteFile(hTempFile2, szURLName, 
  1568.                                   lstrlenA(szURLName) + 1, &dw, NULL);
  1569.                         _tcscat(tszCommandLine, TEXT(" "));
  1570.                         _tcscat(tszCommandLine, tszTempFile1);
  1571.                         _tcscat(tszCommandLine, TEXT(" "));
  1572.                         _tcscat(tszCommandLine, tszTempFile2);
  1573.                         bMailed = CreateProcess(tszExpandedCommand, tszCommandLine, NULL, NULL, 
  1574.                                                 FALSE, DETACHED_PROCESS, NULL, 
  1575.                                                 NULL, &stInfo, NULL);
  1576.                         CloseHandle(hTempFile2);
  1577.                     }
  1578.                     else
  1579.                     {
  1580.                         DeleteFile(tszTempFile1);
  1581.                     }
  1582.                     CloseHandle(hTempFile1);
  1583.                 }
  1584.             }
  1586.             HRESULT hres2;
  1587.             IMalloc *pMalloc;
  1588.             hres2 = SHGetMalloc(&pMalloc);
  1589.             if (SUCCEEDED(hres2))
  1590.             {
  1591.                 pMalloc->Free(lptszURLName);
  1592.                 pMalloc->Release();
  1593.             }
  1594.         }
  1595.         purl->Release();
  1596.     }
  1597.     
  1598.     return hres;
  1599. }
  1602. //////////////////////////////////////////////////////////////////////
  1603. // Importing Bookmarks on startup
  1604. //////////////////////////////////////////////////////////////////////
  1606. extern TCHAR * szIEFavoritesRegSub; 
  1607. extern TCHAR * szIEFavoritesRegKey;
  1609. BOOL ImportBookmarksStartup(HINSTANCE hInstWithStr)
  1610. {
  1611.     TCHAR    szFavoritesDir[MAX_PATH];
  1612.     TCHAR    szBookmarksDir[MAX_PATH];
  1613.     HANDLE  hBookmarksFile        = INVALID_HANDLE_VALUE;
  1614.     BOOL    fSuccess                = FALSE;
  1615.     
  1617.     // Initialize Variables
  1618.     szBookmarksDir[0] = TEXT('');
  1619.     szFavoritesDir[0] = TEXT('');
  1621.     // Get Bookmarks Dir
  1622.     if (TRUE == GetNavBkMkDir( szBookmarksDir, sizeof(szBookmarksDir) ) )
  1623.     {
  1624.         if ((NULL != szBookmarksDir) && (szBookmarksDir[0] != TEXT('')))
  1625.         {
  1626.             hBookmarksFile = CreateFile(szBookmarksDir, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
  1627.             
  1628.             if ( hBookmarksFile != INVALID_HANDLE_VALUE ) 
  1629.             {
  1630.                 // Get Favorites Dir
  1631.                 if (TRUE == GetPathFromRegistry(szFavoritesDir, MAX_PATH, HKEY_CURRENT_USER,
  1632.                     szIEFavoritesRegSub, szIEFavoritesRegKey))
  1633.                 {
  1634.                     if ((NULL != szFavoritesDir) && (szFavoritesDir[0] != TEXT('')))
  1635.                     {
  1636.                         // Verify it's a valid Bookmarks file
  1637.                         if (TRUE == VerifyBookmarksFile( hBookmarksFile ))
  1638.                         {
  1639.                             TCHAR szSubDir[MAX_PATH];
  1640.                             szSubDir[0] = TEXT('');
  1642.                             // Import under a specific folder.
  1643.                             if (0 != MLLoadString(IDS_NS_BOOKMARKS_DIR, szSubDir, ARRAYSIZE(szSubDir)))
  1644.                             {
  1645.                                 StrCatBuff(szFavoritesDir, szSubDir, MAX_PATH);
  1646.                             }
  1647.                       
  1648.                             // Do the importing...
  1649.                             fSuccess = ImportBookmarks(szFavoritesDir, szBookmarksDir, NULL);
  1650.                         }
  1651.                     }
  1652.                 }
  1653.             }
  1654.         }
  1655.     }
  1657.     if (INVALID_HANDLE_VALUE != hBookmarksFile)
  1658.     {
  1659.         CloseHandle(hBookmarksFile);
  1660.     }
  1662.     return(fSuccess);
  1663. }
  1666. STDAPI_(BOOL) IsLocalFolderPidl( LPCITEMIDLIST pidl )
  1667. {
  1668.     BOOL bCheckForFilePath = FALSE;
  1669.  
  1670.     if( IsURLChild( pidl, TRUE ) )
  1671.     {
  1672.              // Get Path from pidl
  1673.          TCHAR szTmpUrl[ MAX_URL_STRING ];
  1674.          LPITEMIDLIST pidlTmp = ILClone( pidl );
  1675.          ::IEGetDisplayName(pidlTmp, szTmpUrl, SHGDN_FORPARSING);
  1676.          if (GetUrlScheme(szTmpUrl) == URL_SCHEME_FILE )
  1677.               bCheckForFilePath = TRUE;
  1678.          ILFree( pidlTmp );
  1679.     }
  1680.     else
  1681.     {
  1682.          bCheckForFilePath = TRUE;
  1683.     }
  1685.     if( bCheckForFilePath )
  1686.     {
  1687.         if( ILIsFileSysFolder(pidl) )
  1688.              return TRUE;
  1690.         // we are not browsing the web
  1691.         LPITEMIDLIST pidlNew;
  1692.         DWORD dwAttrib = SFGAO_FOLDER;
  1694.         if (SUCCEEDED(IEGetAttributesOf(pidl, &dwAttrib)) &&
  1695.            (dwAttrib & SFGAO_FOLDER))
  1696.         {
  1697.             return TRUE;
  1698.         }
  1699.     }
  1701.     return FALSE;
  1702. }
  1705. STDAPI_(LONG) StrLenUnalignedW( UNALIGNED WCHAR * str )
  1706. {
  1707.    LONG count = 0;
  1708.    if( !str ) return 0;
  1710.    while( *str++ ) count++;
  1712.    return count;
  1713. }
  1716. STDAPI_(LONG) StrLenUnalignedA( UNALIGNED CHAR * str )
  1717. {
  1718.    LONG count = 0;
  1719.    if( !str ) return 0;
  1721.    while( *str++ ) count++;
  1723.    return count;
  1724. }
  1726. #ifdef UNIX_FEATURE_ALIAS
  1728. STDAPI_(HDPA) GetGlobalAliasList()
  1729. {
  1730.     static HDPA s_hdpa = NULL;
  1732.     if( !s_hdpa )
  1733.     {
  1734.         HDPA hdpa = DPA_Create(4);
  1736.         if (hdpa)
  1737.         {
  1738.             LoadAliases( hdpa );
  1739.             return hdpa;
  1740.         }
  1741.         else
  1742.             return NULL;
  1744.     }
  1745.     else
  1746.         return s_hdpa;
  1747. }
  1749. STDAPI RefreshGlobalAliasList()
  1750. {
  1751.     HDPA list = GetGlobalAliasList();
  1752.     if( list )
  1753.     {
  1754.         FreeAliases(list);
  1755.         LoadAliases(list);
  1756.     }
  1757. }
  1759. #endif /* UNIX_FEATURE_ALIAS */
  1761. extern "C" 
  1762. BOOL APIENTRY DllMain_Internal(HINSTANCE hDll, DWORD dwReason, void *lpReserved);
  1764. extern "C" 
  1765. BOOL APIENTRY DllMain(HINSTANCE hDll, DWORD dwReason, void *lpReserved)
  1766. {
  1767.     return DllMain_Internal( hDll, dwReason, lpReserved  );
  1768. }
  1770. STDAPI SafeGetItemObject(LPSHELLVIEW psv, UINT uItem, REFIID riid, LPVOID *ppv)
  1771. {
  1772.     return (HRESULT)(psv->GetItemObject(uItem, riid, ppv));
  1773. }
  1775. /* The following is needed so that we will have the latest version number for
  1776.  * the browser under HKLMSoftwareMicrosoftActive SetupInstalled Components
  1777.  */
  1779. #define REGSTRACTIVESETUP TEXT("Software\Microsoft\Active Setup\Installed Components\")
  1781. HRESULT UnixRegisterBrowserInActiveSetup()
  1782. {
  1783.     HRESULT hr = E_FAIL;
  1784.     HKEY    hKey = NULL;
  1785.     HKEY    hKeyOldVer = NULL;
  1786.     DWORD   dw;
  1787.     CLSID   browserClsid = COMPID_IE4;
  1788.     LPOLESTR pszGUID = NULL;
  1789.     TCHAR   szKeyName[MAX_PATH];
  1790.     TCHAR   szVersion[30];
  1791.     TCHAR   szOldVersion[30];
  1792.     DWORD   dwType;
  1793.     DWORD   dwLen;
  1795.     if (FAILED((hr = StringFromCLSID(browserClsid, &pszGUID))))
  1796.        goto Cleanup;
  1798.     StrCpyN(szKeyName, REGSTRACTIVESETUP, ARRAYSIZE(szKeyName));
  1799.     StrCatBuff(szKeyName, pszGUID, ARRAYSIZE(szKeyName));
  1801.     hr = RegCreateKeyEx(
  1802.             HKEY_LOCAL_MACHINE,
  1803.             szKeyName,
  1804.             0,
  1805.             NULL,
  1806.             0,
  1807.             KEY_ALL_ACCESS,
  1808.             NULL,
  1809.             &hKey,
  1810.             &dw);
  1811.  
  1812.     if (hr != ERROR_SUCCESS)
  1813.        goto Cleanup;
  1815.     wnsprintf(szVersion,ARRAYSIZE(szVersion), TEXT("%d,%02d,%04d,%04d"),
  1816.               VER_MAJOR_PRODUCTVER,
  1817.               VER_MINOR_PRODUCTVER,
  1818.               VER_PRODUCTBUILD,
  1819.               VER_PRODUCTBUILD_QFE);
  1821.     hr = RegQueryValueEx(hKey,
  1822.                          TEXT("Version"),
  1823.                          NULL,
  1824.                          &dwType, 
  1825.                          (LPBYTE)szOldVersion,
  1826.                          &dwLen);
  1828.     if (hr == ERROR_SUCCESS)
  1829.     {
  1830.        hr = RegSetValueEx(hKey,
  1831.                           TEXT("OldVersion"),
  1832.                           NULL,
  1833.                           REG_SZ,
  1834.                           (LPBYTE)szVersion,
  1835.                           ((1+lstrlen(szVersion))*sizeof(TCHAR)));
  1836.     }
  1838.     hr = RegSetValueEx(hKey,
  1839.                        TEXT("Version"),
  1840.                        NULL,
  1841.                        REG_SZ,
  1842.                        (LPBYTE)szVersion, ((1+lstrlen(szVersion))*sizeof(TCHAR)));
  1843. Cleanup:
  1845.     if (hKey)
  1846.        RegCloseKey(hKey);
  1848.     CoTaskMemFree(pszGUID);
  1850.     return hr;
  1851. }
  1853. EXTERN_C LPITEMIDLIST UnixUrlToPidl(UINT uiCP, LPCTSTR pszUrl, LPCWSTR pszLocation)
  1854. {
  1855.     LPCITEMIDLIST pidlUrl = UrlToPidl(uiCP, pszUrl, pszLocation);
  1856.     return ILCombine(c_pidlURLRoot, pidlUrl);
  1857. }