系统编程

开发平台：

Visual C++

itbar.cpp：源码内容

#include "priv.h"
#include "sccls.h"
#include "itbdrop.h"
#include <urlhist.h>
#include "autocomp.h"
#include "itbar.h"
#include "address.h"
#include "isfband.h"
#include <winbase.h>
#include "qlink.h"
#include "inpobj.h"
#include "basebar.h"
#include "shbrowse.h"
#include "menuisf.h"
#include "menuband.h"
#include "brand.h"
#include "resource.h"
#include "theater.h"
#include "browmenu.h"
#include "util.h"
#include "tbmenu.h"
#include "apithk.h"
#include "shbrows2.h"
#include "stdenum.h"
#include "iehelpid.h"
#define WANT_CBANDSITE_CLASS
#include "bandsite.h"
#include "schedule.h"
#include "uemapp.h"
#include "mluisupp.h"
#ifdef UNIX
extern "C" const GUID CLSID_MsgBand;
#endif
// The edit button hackery needs to be moved to shdocvw. This define identifies this code.
#define EDIT_HACK
// Offset of the comctl32 default bitmaps
#define OFFSET_HIST (MAX_TB_BUTTONS - 1 + 0) // 15
#define OFFSET_STD (MAX_TB_BUTTONS - 1 + 6) // 21
#define OFFSET_VIEW (MAX_TB_BUTTONS - 1 + 21) // 36
// This is the offset in the toolbar for the Shell glyphs and the Shell toolbar labels
#define SHELLTOOLBAR_OFFSET (MAX_TB_BUTTONS - 1 + 1) // 16
#define FONTGLYPH_OFFSET (MAX_TB_BUTTONS - 1 + 38) // 53
#define BRIEFCASEGLYPH_OFFSET (MAX_TB_BUTTONS - 1 + 34) // 49
#define RNAUIGLYPH_OFFSET (MAX_TB_BUTTONS - 1 + 36) // 51
#define WEBCHECKGLYPH_OFFSET (MAX_TB_BUTTONS - 1 + 42) // 57
#ifdef EDIT_HACK
#define EDITGLYPH_OFFSET (9)
#endif
#define IDT_UPDATETOOLBAR 0x1
#define TIMEOUT_UPDATETOOLBAR 400
const GUID CLSID_Separator = { 0x67077B90L, 0x4F9D, 0x11D0, 0xB8, 0x84, 0x00, 0xAA, 0x00, 0xB6, 0x01, 0x04 };
extern HRESULT VariantClearLazy(VARIANTARG *pvarg);
// How many CT_TABLE structures to allocated at a time.
#define TBBMPLIST_CHUNK 5
#define MAX_EXTERNAL_BAND_NAME_LEN 64
#define MAX_TB_COMPRESSED_WIDTH 42
// 16 is added to the the MAX_TB defines. This is added through the strings
// in the RC file. This is done so that the localization folks can increase
// or decrease the width of the toolbar buttons
#define MAX_TB_WIDTH_LORES 38
#define MAX_TB_WIDTH_HIRES 60
// Dimensions of Coolbar Glyphs ..
#define TB_SMBMP_CX 16
#define TB_SMBMP_CY 16
#define TB_BMP_CX 20
#define TB_BMP_CY 20
#define CX_SEPARATOR 6 // we override toolbar control's default separator width of 8
#define DM_TBSITE 0
#define DM_TBCMD 0
#define DM_TBREF TF_SHDREF
#define DM_LAYOUT 0
#define DM_ITBAR 0
#define TF_TBCUST 0x01000000
#if CBIDX_LAST != 5
#error Expected CBIDX_LAST to have value of 5
#endif
#if (FCIDM_EXTERNALBANDS_LAST - FCIDM_EXTERNALBANDS_FIRST + 1) < MAXEXTERNALBANDS
#error Insufficient range for FCIDM_EXTERNALBANDS_FIRST to FCIDM_EXTERNALBANDS_LAST
#endif
__inline UINT EXTERNALBAND_VBF_BIT(UINT uiBandExt)
{
ASSERT(uiBandExt < MAXEXTERNALBANDS);
// Formula: take 1, shift left by uiBandExt + 16
// => a bit in range (0x80000000, 0x00010000)
UINT uBit = 1 << (uiBandExt + 16);
ASSERT(uBit & VBF_EXTERNALBANDS);
return uBit;
}
__inline BOOL IS_EXTERNALBAND(int idBand)
{
return (InRange(idBand, CBIDX_EXTERNALFIRST, CBIDX_EXTERNALLAST));
}
__inline int MAP_TO_EXTERNAL(int idBand)
{
ASSERT(IS_EXTERNALBAND(idBand));
// CBIDX_LAST is one-based, mapping is zero-based
return (idBand - (1 + CBIDX_LAST));
}
// maximum number of menu items in the context menus for back and forward.
#define MAX_NAV_MENUITEMS 9
#define DEFAULT_SEARCH_GUID SRCID_SFileSearch //SRCID_SWebSearch
#define SZ_PROP_CUSTDLG TEXT("Itbar custom dialog hwnd")
#define REG_KEY_BANDSTATE TEXT("Software\Microsoft\Internet Explorer\Toolbar")
DWORD DoNetConnect(HWND hwnd);
DWORD DoNetDisconnect(HWND hwnd);
void _LoadToolbarGlyphs(HWND hwnd, IMLCACHE *pimlCache, int cx, int idBmp);
BOOL _UseSmallIcons();
typedef struct tagTBBMP_LIST
{
HINSTANCE hInst;
UINT_PTR uiResID;
UINT uiOffset;
BITBOOL fNormal:1;
BITBOOL fHot:1;
BITBOOL fDisabled:1;
} TBBMP_LIST;
typedef struct tagCMDMAP
{
GUID guidButtonGroup;
UINT nCmdID;
LPARAM lParam; // app's data
} CMDMAP;
typedef struct tagCMDMAPCUSTOMIZE
{
TBBUTTON btn;
CMDMAP cm;
} CMDMAPCUSTOMIZE;
typedef struct {
// the IOleCommandTarget info:
GUID guid;
UINT nCmdID;
UINT fButtonState;
} BUTTONSAVEINFO;
#define TBSI_VERSION 7
typedef struct {
int cVersion;
} TOOLBARSAVEINFO;
typedef struct {
HDSA hdsa;
BITBOOL fAdjust:1;
BITBOOL fDirty:1;
} CUSTOMIZEINFO, *LPCUSTOMIZEINFO;
//Current latest version.
#define CBS_VERSION 17
// NOTE: Be very careful changing COOLBARSAVE because _LoadUpgradeSettings makes
// assumptions about the layout of the structure. To avoid breaking that
// upgrade code, be sure you:
//
// - don't change the order of existing members
// - always add new members to the end of the structure.
// - update _LoadUpgradeSettings if appropriate
//
typedef struct tagCOOLBARSAVE
{
UINT cbVer;
UINT uiMaxTBWidth;
UINT uiMaxQLWidth;
#ifdef UNIX
BITBOOL fUnUsed : 28; // unused
#endif
BITBOOL fVertical : 1; // The bar is oriented vertically
BITBOOL fNoText :1; // "NoText"
BITBOOL fList : 1; // toolbar is TBSTYLE_LIST (text on right) + TBSTYLE_EX_MIXEDBUTTONS
BITBOOL fAutoHide : 1; // Auto hide toolbar in theater mode
BITBOOL fStatusBar : 1; // Status bar in theater mode
BITBOOL fSaveInShellIntegrationMode : 1; // Did we save in shell integration mode?
UINT uiVisible; // "Visible bands"
UINT cyRebar;
BANDSAVE bs[CBANDSMAX];
CLSID aclsidExternalBands[ MAXEXTERNALBANDS ]; // Check classid
CLSID clsidVerticalBar; //clsid of bar persisted within vertical band
CLSID clsidHorizontalBar;
} COOLBARSAVE, *LPCOOLBARSAVE;
//Flags for dwFlags passed to UpdateToolbarDisplay()
#define UTD_TEXTLABEL 0x00000001
#define UTD_VISIBLE 0x00000002
static const TCHAR c_szRegKeyCoolbar[] = TSZIEPATH TEXT("\Toolbar");
static const TCHAR c_szValueTheater[] = TEXT("Theater");
typedef struct tagFOLDERSEARCHITEM
{
UINT idCmd;
GUID guidSearch;
int iIcon;
WCHAR wszUrl[MAX_URL_STRING];
WCHAR wszName[80]; // friendly name
}FOLDERSEARCHITEM, *LPFOLDERSEARCHITEM;
BOOL NavigateSearchBar(IWebBrowser2 *pwb2, LPCWSTR pwszUrl);
BOOL _GetSearchHKEY(LPGUID lpguidSearch, HKEY *phkey);
#define REG_SZ_STATIC TEXT("Software\Microsoft\Windows\CurrentVersion\Explorer\FindExtensions\Static")
#define REG_SZ_SEARCH_GUID TEXT("SearchGUID")
#define REG_SZ_SEARCH_URL TEXT("SearchGUID\Url")
#define VIEW_OFFSET (SHELLGLYPHS_OFFSET + HIST_MAX + STD_MAX)
#define VIEW_ALLFOLDERS (VIEW_NETCONNECT + 14)
static const TBBUTTON c_tbExplorer[] =
{
// override default toolbar width for separators; iBitmap member of
// TBBUTTON struct is a union of bitmap index & separator width
{ 0, TBIDM_BACK , 0, BTNS_DROPDOWN | BTNS_SHOWTEXT, {0,0}, 0, 0 },
{ 1, TBIDM_FORWARD, 0, BTNS_DROPDOWN, {0,0}, 0, 1 },
{ 2, TBIDM_STOPDOWNLOAD, TBSTATE_ENABLED, BTNS_BUTTON, {0,0}, 0, 2 },
{ 3, TBIDM_REFRESH, TBSTATE_ENABLED, BTNS_BUTTON, {0,0}, 0, 3 },
{ 4, TBIDM_HOME, TBSTATE_ENABLED, BTNS_BUTTON, {0,0}, 0, 4 },
{ VIEW_PARENTFOLDER + VIEW_OFFSET, TBIDM_PREVIOUSFOLDER, TBSTATE_ENABLED, BTNS_BUTTON, {0,0}, 0, VIEW_PARENTFOLDER + VIEW_OFFSET },
{ VIEW_NETCONNECT + VIEW_OFFSET, TBIDM_CONNECT, TBSTATE_ENABLED, BTNS_BUTTON, {0,0}, 0, VIEW_NETCONNECT + VIEW_OFFSET },
{ VIEW_NETDISCONNECT + VIEW_OFFSET, TBIDM_DISCONNECT, TBSTATE_ENABLED, BTNS_BUTTON, {0,0}, 0, VIEW_NETDISCONNECT + VIEW_OFFSET },
{ CX_SEPARATOR, 0, TBSTATE_ENABLED, BTNS_SEP, {0,0}, 0, -1 },
{ 5, TBIDM_SEARCH, TBSTATE_ENABLED, BTNS_SHOWTEXT, {0,0}, 0, 5 },
{ VIEW_ALLFOLDERS + VIEW_OFFSET, TBIDM_ALLFOLDERS, TBSTATE_ENABLED, BTNS_SHOWTEXT, {0,0}, 0, VIEW_ALLFOLDERS + VIEW_OFFSET },
{ 6, TBIDM_FAVORITES, TBSTATE_ENABLED, BTNS_SHOWTEXT, {0,0}, 0, 6 },
{ 12, TBIDM_HISTORY, TBSTATE_ENABLED, BTNS_SHOWTEXT, {0,0}, 0, 12},
{ CX_SEPARATOR, 0, TBSTATE_ENABLED, BTNS_SEP, {0,0}, 0, -1 },
#ifndef DISABLE_FULLSCREEN
// IE UNIX : No theater mode for beta1
{ 14, TBIDM_THEATER, TBSTATE_ENABLED, BTNS_BUTTON, {0,0}, 0, 14 },
#endif
};
static const BROWSER_RESTRICTIONS c_rest[] = {
REST_BTN_BACK,
REST_BTN_FORWARD,
REST_BTN_STOPDOWNLOAD,
REST_BTN_REFRESH,
REST_BTN_HOME,
REST_BROWSER_NONE, // no policy for up
REST_BROWSER_NONE, // no policy for map drive
REST_BROWSER_NONE, // no policy for disconnect drive
REST_BROWSER_NONE, // separator
REST_BTN_SEARCH,
REST_BTN_ALLFOLDERS,
REST_BTN_FAVORITES,
REST_BTN_HISTORY,
REST_BROWSER_NONE, // separator
#ifndef DISABLE_FULLSCREEN
REST_BTN_THEATER,
#endif
};
#define SUPERCLASS CBaseBar
class CInternetToolbar :
public CBaseBar,
public IDockingWindow,
public IObjectWithSite, // *not* CObjectWithSite (want _ptbSite)
public IExplorerToolbar,
public DWebBrowserEvents,
public IPersistStreamInit,
public IShellChangeNotify,
public ISearchItems
{
public:
// *** IUnknown ***
virtual STDMETHODIMP QueryInterface(REFIID riid, void ** ppvObj);
virtual STDMETHODIMP_(ULONG) AddRef(void) { return SUPERCLASS::AddRef(); };
virtual STDMETHODIMP_(ULONG) Release(void){ return SUPERCLASS::Release(); };
// *** IOleWindow methods ***
virtual STDMETHODIMP GetWindow(HWND * lphwnd) { return SUPERCLASS::GetWindow(lphwnd);};
virtual STDMETHODIMP ContextSensitiveHelp(BOOL fEnterMode) {return SUPERCLASS::ContextSensitiveHelp(fEnterMode);};
// *** IDockingWindow methods ***
virtual STDMETHODIMP ShowDW(BOOL fShow);
virtual STDMETHODIMP CloseDW(DWORD dwReserved);
virtual STDMETHODIMP ResizeBorderDW(LPCRECT prcBorder, IUnknown* punkToolbarSite, BOOL fReserved);
// *** IObjectWithSite methods ***
virtual STDMETHODIMP SetSite(IUnknown* punkSite);
// BUGBUG is E_NOTIMPL ok?
virtual STDMETHODIMP GetSite(REFIID riid, void** ppvSite) { ASSERT(0); return E_NOTIMPL; };
// *** IInputObjectSite methods ***
virtual STDMETHODIMP OnFocusChangeIS(IUnknown *punk, BOOL fSetFocus);
// *** IInputObject methods ***
virtual STDMETHODIMP TranslateAcceleratorIO(LPMSG lpMsg);
// *** IServiceProvider methods ***
virtual STDMETHODIMP QueryService(REFGUID guidService, REFIID riid, LPVOID* ppvObj);
// *** IExplorerToolbar method ***
virtual STDMETHODIMP SetCommandTarget(IUnknown* punkCmdTarget, const GUID* pguidButtonGroup, DWORD dwFlags);
virtual STDMETHODIMP AddStdBrowserButtons(void);
virtual STDMETHODIMP AddButtons(const GUID* pguidButtonGroup, UINT nButtons, const TBBUTTON * lpButtons);
virtual STDMETHODIMP AddString(const GUID * pguidButtonGroup, HINSTANCE hInst, UINT_PTR uiResID, LONG_PTR *pOffset);
virtual STDMETHODIMP GetButton(const GUID* pguidButtonGroup, UINT uiCommand, LPTBBUTTON lpButton);
virtual STDMETHODIMP GetState(const GUID* pguidButtonGroup, UINT uiCommand, UINT * pfState);
virtual STDMETHODIMP SetState(const GUID* pguidButtonGroup, UINT uiCommand, UINT fState);
virtual STDMETHODIMP AddBitmap(const GUID * pguidButtonGroup, UINT uiBMPType, UINT uiCount, TBADDBITMAP * ptb,
LRESULT * pOffset, COLORREF rgbMask);
virtual STDMETHODIMP GetBitmapSize(UINT * uiID);
virtual STDMETHODIMP SendToolbarMsg(const GUID * pguidButtonGroup, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT * plRes);
virtual STDMETHODIMP SetImageList( const GUID* pguidCmdGroup, HIMAGELIST himlNormal, HIMAGELIST himlHot, HIMAGELIST himlDisabled);
virtual STDMETHODIMP ModifyButton( const GUID * pguidButtonGroup, UINT uiCommand, LPTBBUTTON lpButton);
// IOleCommandTarget
virtual STDMETHODIMP QueryStatus(const GUID *pguidCmdGroup,
ULONG cCmds, OLECMD rgCmds[], OLECMDTEXT *pcmdtext);
virtual STDMETHODIMP Exec(const GUID *pguidCmdGroup,
DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn,
VARIANTARG *pvarargOut);
// IPersistStreamInit
STDMETHOD(GetClassID)(GUID *pguid);
STDMETHOD(Load)(IStream *pStm);
STDMETHOD(Save)(IStream *pStm, BOOL fClearDirty);
STDMETHOD(InitNew)(void);
STDMETHOD(IsDirty)(void);
STDMETHOD(GetSizeMax)(ULARGE_INTEGER *pcbSize);
/* IDispatch methods */
virtual STDMETHODIMP GetTypeInfoCount(UINT *pctinfo);
virtual STDMETHODIMP GetTypeInfo(UINT itinfo,LCID lcid,ITypeInfo **pptinfo);
virtual STDMETHODIMP GetIDsOfNames(REFIID riid,OLECHAR **rgszNames,UINT cNames,
LCID lcid, DISPID * rgdispid);
virtual STDMETHODIMP Invoke(DISPID dispidMember,REFIID riid,LCID lcid,WORD wFlags,
DISPPARAMS * pdispparams, VARIANT * pvarResult,
EXCEPINFO * pexcepinfo,UINT * puArgErr);
// IShellChangeNotify
virtual STDMETHODIMP OnChange(LONG lEvent, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2);
// CBaseBar overrides
virtual LRESULT v_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
// *** ISearchItems methods ***
virtual STDMETHODIMP GetDefaultSearchUrl(LPWSTR pwzUrl, UINT cch);
CInternetToolbar();
protected:
virtual ~CInternetToolbar();
static LRESULT CALLBACK SizableWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
void _OnCommand(WPARAM wParam, LPARAM lParam);
BOOL _SendToToolband(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT* plres);
LRESULT _OnNotify(LPNMHDR pnmh);
void _OnTooltipNeeded(LPTOOLTIPTEXT pnmTT);
void _QueryStatusTip(IOleCommandTarget *pct, LPTOOLTIPTEXT pnmTT, UINT uiCmd, const GUID* pguid);
BOOL _UpEnabled();
void _UpdateCommonButton(int iCmd, UINT nCmdID);
void _UpdateToolbar(BOOL fForce);
void _UpdateToolbarNow();
void _UpdateGroup(const GUID *pguidCmdGroup, int cnt, OLECMD rgcmds[], const GUID* pguidButton, const int buttonsInternal[]);
void _CSHSetStatusBar(BOOL fOn);
void _StartDownload();
void _StopDownload(BOOL fClosing);
void _SendDocCommand(UINT idCmd);
BOOL _CompressBands(BOOL fCompress, UINT uRowsNew, BOOL fForceUpdate);
void _TrackSliding(int x, int y);
HRESULT _DoNavigateA(LPSTR pszURL,int iNewSelection);
HRESULT _DoNavigateW(LPWSTR pwzURL,int iNewSelection);
HRESULT _DoNavigate(BSTR bstrURL,int iNewSelection);
void _Unadvise(void);
LRESULT _OnBeginDrag(NMREBAR* pnm);
void _InsertURL(LPTSTR pszURL);
void _ShowContextMenu(HWND hwnd, LPARAM lParam, LPRECT prcExclude);
BOOL _ShowBackForwardMenu(BOOL fForward, POINT pt, LPRECT prcExclude);
// search helper methods
BOOL _GetFolderSearchData();
void _SetSearchStuff();
BOOL _GetSearchUrl(LPWSTR pwszUrl, DWORD cch);
HRESULT _GetFolderSearches(IFolderSearches **ppfs);
void _ReloadButtons();
void _UpdateToolsStyle(BOOL fList);
void _InitBitmapDSA();
void _InitForScreenSize();
void _InitToolbar();
BOOL _FoldersButtonAvailable();
void _AdminMarkDefaultButtons(PTBBUTTON ptbb, UINT cButtons);
void _MarkDefaultButtons(PTBBUTTON ptbb, UINT cButtons);
void _AddCommonButtons();
HRESULT _CreateBands();
BOOL _ShowBands(UINT fVisible);
HRESULT _ShowTools(PBANDSAVE pbs);
HRESULT _ShowAddressBand(PBANDSAVE pbs);
HRESULT _ShowExternalBand(PBANDSAVE pbs, int idBand );
HRESULT _ShowLinks(PBANDSAVE pbs);
HRESULT _ShowBrand(PBANDSAVE pbs);
HRESULT _ShowMenu(PBANDSAVE pbs);
void _ShowBandCommon(PBANDSAVE pbs, LPBANDITEMDATA pbid, BOOL fShow);
void _EnsureAllBandsShown();
HRESULT _GetMinRowHeight();
HBITMAP _LoadBackBmp(LPTSTR * ppszBitmap, BMPCACHE * pbmpCache, BOOL fInternet);
HBITMAP _LoadBackBitmap();
void _SetBackground();
void _CommonHandleFileSysChange(LONG lEvent, LPITEMIDLIST* ppidl);
LPITEMIDLIST _GetCurrentPidl(void);
int _ConvertHwndToID(HWND hwnd);
HRESULT _GetPersistedBand(const CLSID clsid, REFIID riid, void ** ppiface);
// Multiple command target
LRESULT _AddBitmapFromForeignModule(UINT uiGetMSG, UINT uiSetMSG, UINT uiCount, HINSTANCE hinst,
UINT_PTR nID, COLORREF rgbMask);
HRESULT _LoadDefaultSettings(void);
HRESULT _LoadUpgradeSettings(ULONG cbRead);
HRESULT _LoadDefaultWidths(void);
void _TryLoadIE3Settings();
HRESULT _UpdateToolbarDisplay(DWORD dwFlags, UINT uVisibleBands, BOOL fNoText, BOOL fPersist);
void _UpdateBrandSize();
void _ShowVisible(DWORD dwVisible, BOOL fPersist);
void _BuildSaveStruct(COOLBARSAVE* pcs);
void _RestoreSaveStruct(COOLBARSAVE* pcs);
void _GetVisibleBrowserBar(UINT idBar, CLSID *pclsidOut);
LPBANDITEMDATA _AddNewBand(IDeskBand* pdb, DWORD dwID);
void _TheaterModeLayout(BOOL fEnter);
HBITMAP _bmpBack; // this is the state we think the itbar is in
static BMPCACHE s_bmpBackShell; // this is the state of the shell bmp cache
static BMPCACHE s_bmpBackInternet; // this is the state of the internet bmp cache
static IMLCACHE s_imlTBGlyphs;
HWND _hwndMenu;
HWND _hwndAddressBand;
IDockingWindowSite* _ptbsite;
IOleCommandTarget* _ptbsitect;
IBrowserService2* _pbs2;
IServiceProvider* _psp;
IBandProxy * _pbp;
BITBOOL _fCreatedBandProxy:1;
BITBOOL _fBackEnabled:1;
BITBOOL _fForwardEnabled:1;
BITBOOL _fEditEnabled:1;
BITBOOL _fShow:1;
BITBOOL _fAnimating:1;
BITBOOL _fCompressed:1;
BITBOOL _fUserNavigated :1;
BITBOOL _fAutoCompInitialized :1;
BITBOOL _fDirty:1;
BITBOOL _fUsingDefaultBands:1;
BITBOOL _fTransitionToHTML:1;
BITBOOL _fInitialPidlIsWeb:1;
BITBOOL _fTheater: 1; // are we in theater mode? claim no border space
BITBOOL _fAutoHide :1;
BITBOOL _fRebarDragging :1;
BITBOOL _fShellView:1; // are we in shell view or web view?
BITBOOL _fNoShowMenu:1; // can show menu band?
BITBOOL _fUpdateToolbarTimer:1;
BITBOOL _fNeedUpdateToolbar:1;
BITBOOL _fNavigateComplete:1;
BITBOOL _fLoading:1; // are we still loading the bar?
BITBOOL _fDestroyed:1; // Did we destroy our member varibles and are shutting down? If so, don't use the varibles. (Stress bug w/messages coming in)
UINT _nVisibleBands; // bitmask of which bands are visible: VBF_*
IWebBrowser2* _pdie;
DWORD _dwcpCookie; // DIID_DWebBrowserEvents2
int _xCapture;
int _yCapture;
// for multiple command target support
HDSA _hdsaTBBMPs;
UINT _uiMaxTBWidth;
UINT _uiTBTextRows;
UINT _uiTBDefaultTextRows;
// search stuff
HDPA _hdpaFSI; // folder search items
GUID _guidCurrentSearch;
GUID _guidDefaultSearch;
COOLBARSAVE _cs; //Coolbar layout info from registry!
struct EXTERNALBANDINFO {
CLSID clsid; // CLSID of the band
LPWSTR pwszName; // Band name
LPWSTR pwszHelp; // Band help text
};
EXTERNALBANDINFO _rgebi[ MAXEXTERNALBANDS ];
void _LoadExternalBandInfo();
TBBUTTON _tbExplorer[ARRAYSIZE(c_tbExplorer)];
int _iButtons;
#ifdef EDIT_HACK
// Variables for customizing the edit button glyph
HIMAGELIST _himlEdit; // Monochrome Image list for the edit button
HIMAGELIST _himlEditHot; // Hot image list for edit button
int _iEditIcon; // index of current edit icon
// Functions for managing a custom edit glyph
void _InitEditButtonStyle();
void _SetEditGlyph(int iIcon);
void _RefreshEditGlyph();
void _UpdateEditButton();
static HIMAGELIST _CreateGrayScaleImagelist(HBITMAP hbmpImage, HBITMAP hbmpMask);
static BSTR _GetEditProgID(IHTMLDocument2* pHTMLDocument);
//
// We can have multiple edit verbs associated with a document. The following class
// maintains a list of verbs.
//
#define FCIDM_EDITFIRST 2000
#define FCIDM_EDITLAST 2100
#define SZ_EDITVERB_PROP TEXT("CEditVerb_This")
#define IL_EDITBUTTON 2 // Index of image list used for the edit button
#define IL_SEARCHBUTTON 3 // || search button
// MSAA Menu Info declarations.
// These will eventually be incorporated into oleacc.h - but for the
// moment, we declare them privately...
#define MSAA_MENU_SIG 0xAA0DF00DL
class CEditVerb
{
public:
CEditVerb();
~CEditVerb();
// Functions for managing the verbs
BOOL Add(LPTSTR pszProgID);
UINT GetSize() { return _nElements; }
void RemoveAll();
// Functions to access the default edit verb
int GetIcon() { return (_nElements && _pVerb[_nDefault].fShowIcon) ? _GetVerb(_nDefault).iIcon : -1; }
BOOL GetToolTip(LPTSTR pszToolTip, UINT cchMax, BOOL fStripAmpersands = TRUE);
BOOL GetMenuText(LPTSTR pszText, UINT cchMax) { return GetToolTip(pszText, cchMax, FALSE); }
void Edit(LPCTSTR pszUrl) { _Edit(pszUrl, _nDefault); }
// Pop-up menu
BOOL ShowEditMenu(POINT pt, HWND hwnd, LPTSTR pszUrl);
// Get default editor from the registry
void InitDefaultEditor(HKEY hkey = NULL);
protected:
struct MSAAMenuInfo
{
DWORD m_MSAASig; // Must be MSAA_MENU_SIG
DWORD m_CharLen; // Length in characters of text, excluding terminating NUL
LPWSTR m_pWStr; // Menu text, in UNICODE, with terminating UNICODE-NUL.
};
struct EDITVERB
{
MSAAMenuInfo m_MSAA; // MSAA info - must be first element.
HKEY hkeyProgID; // Key the we shellexec
BITBOOL fUseOpenVerb:1; // use open verb instead of edit
BITBOOL fInit:1; // true if the data below has beed initialized
BITBOOL fShowIcon:1; // true if icon should show up on button
int iIcon; // cached icon index
UINT idCmd; // menu id
LPTSTR pszDesc; // executable name or document name
LPTSTR pszMenuText; // Menu text
LPTSTR pszExe; // Path of the exe used to edit
};
EDITVERB* _Add(HKEY hkeyProgID, BOOL fPermitOpenVerb, BOOL fCheckForOfficeApp, BOOL fShowIcon);
EDITVERB& _GetVerb(UINT nIndex);
void _FetchInfo(UINT nIndex);
void _Edit(LPCTSTR pszUrl, UINT nIndex);
LPCTSTR _GetDescription(EDITVERB& rVerb);
void _SetMSAAMenuInfo(EDITVERB& rVerb);
void _ClearMSAAMenuInfo(EDITVERB& rVerb);
void _FormatMenuText(UINT nIndex);
BOOL _IsUnique(EDITVERB& rNewVerb);
BOOL _IsHtmlStub(LPCWSTR pszPath);
LPCTSTR _GetExePath(EDITVERB& rVerb);
LPCTSTR _GetDefaultEditor();
static LRESULT CALLBACK _WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
// Member data
UINT _nElements; // number of edit verbs
UINT _nDefault; // Default edit verb
EDITVERB* _pVerb; // array of edit verbs
WNDPROC _lpfnOldWndProc; // former wndProc
LPWSTR _pszDefaultEditor; // Friendly name of default HTML editor
BOOL _fInitEditor; // if we checked for a default editor
};
CEditVerb _aEditVerb;
#endif
// internal bandsite class
class CBrowserToolsBand;
class CITBandSite : public CBandSite
{
CITBandSite();
virtual STDMETHODIMP Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut);
virtual STDMETHODIMP AddBand(IUnknown *punk);
virtual STDMETHODIMP HasFocusIO();
protected:
virtual void v_SetTabstop(LPREBARBANDINFO prbbi);
BOOL _SetMinDimensions();
friend class CInternetToolbar;
friend class CBrowserToolsBand;
virtual HRESULT _OnContextMenu(WPARAM wParm, LPARAM lParam);
virtual HRESULT _Initialize(HWND hwndParent);
};
CITBandSite _bs;
#define TOOLSBANDCLASS CInternetToolbar::CBrowserToolsBand
class CBrowserToolsBand : public CToolbarBand
{
CMDMAP* _GetCmdMapByIndex(int nIndex) { return _GetCmdMap(nIndex, TRUE);};
CMDMAP* _GetCmdMapByID(int id) { return _GetCmdMap(id, FALSE);};
LRESULT _ToolsCustNotify (LPNMHDR pnmh); // Handle TBCustomization Notify
BOOL _SaveRestoreToolbar(BOOL fSave);
void _FreeCustomizeInfo();
void _FreeCmdMap(CMDMAP*);
BOOL _RemoveAllButtons();
int _CommandFromIndex(UINT uIndex);
HRESULT _ConvertCmd(const GUID* pguidButtonGroup, UINT id, GUID* pguidOut, UINT * pid);
void _OnDeletingButton(TBNOTIFY* ptbn);
LONG_PTR _AddString(LPWSTR pwstr);
void _PreProcessButtonString(TBBUTTON *ptbn, DWORD dwFlags);
void _PreProcessExternalTBButton(TBBUTTON *ptbn);
UINT _ProcessExternalButtons(PTBBUTTON ptbb, UINT cButtons);
void _GetButtons(IOleCommandTarget* pct, const GUID* pguid, HDSA hdsa);
void _RecalcButtonWidths();
void _UpdateTextSettings(INT_PTR ids);
static BOOL_PTR CALLBACK _BtnAttrDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
static void _PopulateComboBox(HWND hwnd, const int iResource[], UINT cResources);
static void _SetComboSelection(HWND hwnd, int iCurOption);
void _SetDialogSelections(HWND hDlg, BOOL fSmallIcons);
static void _PopulateDialog(HWND hDlg);
void _OnBeginCustomize(LPNMTBCUSTOMIZEDLG pnm);
BOOL _BuildButtonDSA();
CMDMAPCUSTOMIZE* _GetCmdMapCustomize(GUID* guid, UINT nCmdID);
virtual STDMETHODIMP Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut);
virtual STDMETHODIMP GetClassID(CLSID *pClassID) {return E_NOTIMPL;};
virtual STDMETHODIMP Load(IStream *pStm) {return E_NOTIMPL;};
virtual STDMETHODIMP Save(IStream *pStm, BOOL fClearDirty) {return E_NOTIMPL;};
// *** IUnknown ***
virtual STDMETHODIMP_(ULONG) AddRef(void) { return CToolBand::AddRef(); };
virtual STDMETHODIMP_(ULONG) Release(void){ return CToolBand::Release(); };
virtual STDMETHODIMP QueryInterface(REFIID riid, LPVOID * ppvObj);
// *** IDeskBand methods ***
virtual STDMETHODIMP GetBandInfo(DWORD dwBandID, DWORD fViewMode, DESKBANDINFO* pdbi);
// *** IWinEventHandler methods ***
virtual STDMETHODIMP OnWinEvent(HWND hwnd, UINT dwMsg, WPARAM wParam, LPARAM lParam, LRESULT* plres);
// *** IDockingWindow methods ***
virtual STDMETHODIMP CloseDW(DWORD dwReserved) { return S_OK;};
// *** IInputObject methods ***
virtual STDMETHODIMP TranslateAcceleratorIO(LPMSG lpMsg);
protected:
IOleCommandTarget* _CommandTargetFromCmdMap(CMDMAP* pcm);
LRESULT _OnToolbarDropDown(TBNOTIFY *ptbn);
virtual LRESULT _OnNotify(LPNMHDR pnmh);
LRESULT _OnContextMenu(LPARAM lParam, WPARAM wParam);
CMDMAP* _GetCmdMap(int i, BOOL fByIndex);
void _OnEndCustomize();
LRESULT _TryShowBackForwardMenu(DWORD dwItemSpec, LPPOINT ppt, LPRECT prcExclude);
CBrowserToolsBand();
void _FreeBtnsAdded();
friend class CInternetToolbar;
friend class CITBandSite;
GUID _guidCurrentButtonGroup;
IOleCommandTarget* _pctCurrentButtonGroup;
LPTBBUTTON _pbtnsAdded;
int _cBtnsAdded;
DWORD _nNextCommandID;
CUSTOMIZEINFO *_pcinfo;
BITBOOL _fCustomize :1;
BITBOOL _fNeedFreeCmdMapsAdded :1;
};
CBrowserToolsBand _btb;
friend class CBrowserToolsBand;
friend class CITBandSite;
friend void CInternetToolbar_CleanUp();
friend void CInternetToolbar_Preload();
friend void ITBar_LoadToolbarGlyphs(HWND hwnd);
};
//
// Gets the stream corresponding to the type of the given pidl
// If the stream already doesn't exist, then it returns NULL.
HRESULT _GetStreamName(DWORD dwITBS, LPTSTR pszName, DWORD cchSize)
{
HRESULT hr = S_OK;
ASSERT(pszName);
switch (dwITBS)
{
case ITBS_WEB:
StrCpyN(pszName, TEXT("WebBrowser"), cchSize);
break;
case ITBS_SHELL:
StrCpyN(pszName, TEXT("ShellBrowser"), cchSize);
break;
case ITBS_EXPLORER:
StrCpyN(pszName, TEXT("Explorer"), cchSize);
break;
default:
hr = E_FAIL;
break;
}
if (FAILED(hr))
pszName[0] = '';
return hr;
}
//
// Gets the stream corresponding to the type of the given pidl
// If the stream already doesn't exist, then it returns NULL.
IStream *GetRegStream(BOOL fInternet, LPCTSTR pszValue, DWORD grfMode)
{
IStream *pstm = NULL;
HKEY hkToolbar;
if (RegCreateKey(HKEY_CURRENT_USER, c_szRegKeyCoolbar, &hkToolbar) == ERROR_SUCCESS)
{
TCHAR szStreamName[MAX_PATH];
if (SUCCEEDED(_GetStreamName(fInternet, szStreamName, ARRAYSIZE(szStreamName))))
pstm = OpenRegStream(hkToolbar, szStreamName, pszValue, grfMode);
RegCloseKey(hkToolbar);
}
return(pstm);
}
//
// Gets the stream corresponding to the type of the given pidl
// If the stream already doesn't exist, then it returns NULL.
IStream *GetITBarStream(BOOL fInternet, DWORD grfMode)
{
return GetRegStream(fInternet, TEXT("ITBarLayout"), grfMode);
}
IMLCACHE CInternetToolbar::s_imlTBGlyphs = {NULL};
BMPCACHE CInternetToolbar::s_bmpBackShell = {NULL};
BMPCACHE CInternetToolbar::s_bmpBackInternet = {NULL};
BOOL g_fSmallIcons = FALSE;
void IMLCACHE_CleanUp(IMLCACHE * pimlCache, DWORD dwFlags)
{
for (int i = 0; i < CIMLISTS; i++)
{
if (pimlCache->arhimlPendingDelete[i])
ImageList_Destroy(pimlCache->arhimlPendingDelete[i]);
if ((dwFlags & IML_DESTROY) && pimlCache->arhiml[i])
ImageList_Destroy(pimlCache->arhiml[i]);
}
}
void ITBar_LoadToolbarGlyphs(HWND hwnd)
{
int cx, idBmp;
g_fSmallIcons = _UseSmallIcons();
if (g_fSmallIcons) {
cx = TB_SMBMP_CX;
idBmp = IDB_IETOOLBAR16;
} else {
cx = TB_BMP_CX;
idBmp = IDB_IETOOLBAR;
}
if (SHGetCurColorRes() > 8)
idBmp += DELTA_HICOLOR;
_LoadToolbarGlyphs(hwnd, &CInternetToolbar::s_imlTBGlyphs, cx, idBmp);
}
void CInternetToolbar_Preload()
{
ENTERCRITICAL;
ITBar_LoadToolbarGlyphs(NULL);
Brand_InitBrandContexts();
LEAVECRITICAL;
}
void CInternetToolbar_CleanUp()
{
TraceMsg(DM_ITBAR, "CInternetToolbar: Destroying shared GDI objects");
if (CInternetToolbar::s_bmpBackInternet.hbmp)
DeleteObject(CInternetToolbar::s_bmpBackInternet.hbmp);
if (CInternetToolbar::s_bmpBackShell.hbmp)
DeleteObject(CInternetToolbar::s_bmpBackShell.hbmp);
IMLCACHE_CleanUp(&CInternetToolbar::s_imlTBGlyphs, IML_DESTROY);
}
STDAPI CInternetToolbar_CreateInstance(IUnknown* pUnkOuter, IUnknown** ppunk, LPCOBJECTINFO poi)
{
// aggregation checking is handled in class factory
CInternetToolbar *pitbar = new CInternetToolbar();
if (pitbar)
{
*ppunk = SAFECAST(pitbar, IDockingWindow *);
return S_OK;
}
return E_OUTOFMEMORY;
}
LRESULT CInternetToolbar::v_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if ( uMsg == WM_SYSCOLORCHANGE )
{
// refresh the back drop incase the colours have changed
_SetBackground();
}
return SUPERCLASS::v_WndProc( hwnd, uMsg, wParam, lParam );
}
void CInternetToolbar::_LoadExternalBandInfo()
{
#ifdef DEBUG
int i;
// Should have been zero-initialized
for (i = 0; i < ARRAYSIZE(_rgebi); i++)
{
ASSERT(IsEqualGUID(_rgebi[i].clsid, GUID_NULL));
ASSERT(_rgebi[i].pwszName == NULL);
ASSERT(_rgebi[i].pwszHelp == NULL);
}
#endif
HKEY hkey;
DWORD dwClsidIndex = 0;
if (RegOpenKeyEx( HKEY_LOCAL_MACHINE, REG_KEY_BANDSTATE, 0, KEY_READ, &hkey) == ERROR_SUCCESS)
{
TCHAR tszReg[MAX_PATH];
StrCpy(tszReg, TEXT("CLSID\"));
const int cchClsidPrefix = 6; // 6 = strlen("CLSID\")
LPTSTR ptszClsid = tszReg + cchClsidPrefix;
DWORD cchClsid;
for (DWORD dwIndex = 0;
cchClsid = ARRAYSIZE(tszReg) - cchClsidPrefix,
dwClsidIndex < ARRAYSIZE(_rgebi) &&
RegEnumValue( hkey, dwIndex, ptszClsid, &cchClsid, NULL, NULL, NULL, NULL ) == ERROR_SUCCESS;
dwIndex++)
{
CLSID clsid;
if (GUIDFromString( ptszClsid, &clsid ))
{
// Don't save the CLSID until we're sure it worked
_rgebi[dwClsidIndex].clsid = clsid;
HKEY hkeyClsid;
if (RegOpenKeyEx(HKEY_CLASSES_ROOT, tszReg, 0, KEY_READ, &hkeyClsid) == ERROR_SUCCESS)
{
WCHAR wszBuf[MAX_PATH];
// Get the name; use SHLoadRegUIString so the app can localize
SHLoadRegUIStringW( hkeyClsid, L"", wszBuf, ARRAYSIZE(wszBuf) );
Str_SetPtrW( &_rgebi[dwClsidIndex].pwszName, wszBuf);
// Get the help; use SHLoadRegUIString so the app can localize
SHLoadRegUIStringW( hkeyClsid, L"HelpText", wszBuf, ARRAYSIZE(wszBuf) );
Str_SetPtrW( &_rgebi[dwClsidIndex].pwszHelp, wszBuf);
RegCloseKey(hkeyClsid);
}
dwClsidIndex++;
}
}
RegCloseKey( hkey );
}
}
CInternetToolbar::CInternetToolbar() : CBaseBar(), _yCapture(-1), _iButtons(-1)
#ifdef EDIT_HACK
, _iEditIcon(-1)
#endif
{
DllAddRef();
if (GetSystemMetrics(SM_CXSCREEN) < 650)
_uiMaxTBWidth = MAX_TB_WIDTH_LORES;
else
_uiMaxTBWidth = MAX_TB_WIDTH_HIRES;
ASSERT(_fLoading == FALSE);
ASSERT(_btb._guidCurrentButtonGroup == CLSID_NULL);
_btb._nNextCommandID = 1000;
_LoadExternalBandInfo();
}
void CInternetToolbar::_Unadvise(void)
{
if(_dwcpCookie)
{
ConnectToConnectionPoint(NULL, DIID_DWebBrowserEvents2, FALSE, _pdie, &_dwcpCookie, NULL);
}
}
int CALLBACK DeleteDPAPtrCB(void *pItem, void *pData)
{
LocalFree(pItem);
return TRUE;
}
CInternetToolbar::~CInternetToolbar()
{
ATOMICRELEASE(_pdie);
if(_pbp && _fCreatedBandProxy)
_pbp->SetSite(NULL);
ATOMICRELEASE(_pbp);
ASSERT(!_ptbsite && !_ptbsitect && !_psp && !_pbs2);
SetSite(NULL);
DPA_DestroyCallback(_hdpaFSI, DeleteDPAPtrCB, NULL);
for (int i = 0; i < ARRAYSIZE(_rgebi); i++)
{
Str_SetPtrW( &_rgebi[i].pwszName, NULL);
Str_SetPtrW( &_rgebi[i].pwszHelp, NULL);
}
TraceMsg(TF_SHDLIFE, "dtor CInternetToolbar %x", this);
DllRelease();
}
#define IID_DWebBrowserEvents DIID_DWebBrowserEvents
HRESULT CInternetToolbar::QueryInterface(REFIID riid, void ** ppvObj)
{
static const QITAB qit[] = {
// perf: last tuned 980728
QITABENTMULTI(CInternetToolbar, IDispatch, DWebBrowserEvents), // IID_IDispatch
QITABENT(CInternetToolbar, IExplorerToolbar), // IID_IDispatch
QITABENT(CInternetToolbar, IObjectWithSite), // IID_IObjectWithSite
QITABENT(CInternetToolbar, IPersistStreamInit), // IID_IPersistStreamInit
QITABENT(CInternetToolbar, IDockingWindow), // IID_IDockingWindow
QITABENT(CInternetToolbar, DWebBrowserEvents), // IID_DWebBrowserEvents
QITABENT(CInternetToolbar, IShellChangeNotify), // rare IID_IShellChangeNotify
QITABENT(CInternetToolbar, ISearchItems), // rare IID_ISearchItems
{ 0 },
};
HRESULT hres = QISearch(this, qit, riid, ppvObj);
if (FAILED(hres))
hres = SUPERCLASS::QueryInterface(riid, ppvObj);
return hres;
}
/* IDispatch methods */
HRESULT CInternetToolbar::GetTypeInfoCount(UINT *pctinfo)
{
return(E_NOTIMPL);
}
HRESULT CInternetToolbar::GetTypeInfo(UINT itinfo,LCID lcid,ITypeInfo **pptinfo)
{
return(E_NOTIMPL);
}
HRESULT CInternetToolbar::GetIDsOfNames(REFIID riid,OLECHAR **rgszNames,UINT cNames,
LCID lcid, DISPID * rgdispid)
{
return(E_NOTIMPL);
}
#if 0
// BUGBUG - StevePro changed it so this code isnt called
// this is a goodness, because it calls SHVerbExists() which
// is a TCHAR API, that is actually compiled as an ANSI API
// and since we are UNICODE it just always fails.
// leaving this in so that we know about the issue of
// frontpad.exe possibly needing to be disabled.
BOOL _ShowEditForExtension(LPCTSTR pszExtension)
{
TCHAR szBuf[MAX_PATH];
if (SHVerbExists(pszExtension, TEXT("edit"), szBuf)) {
// don't show it if it's just our own
if (StrStrI(szBuf, TEXT("frontpad.exe"))) {
return FALSE;
}
return TRUE;
}
return FALSE;
}
#endif
#ifdef EDIT_HACK
//+-------------------------------------------------------------------------
// This function scans the html document for META tags that indicate the
// program that was used to create the HTML page. Examples are:
//
// <meta name="ProgID" content="word.document" >
// <meta name="ProgID" content="excel.sheet" >
//
// If a match is found, the content of the first match is returned. This
// progid is used to edit the document.
//--------------------------------------------------------------------------
BSTR CInternetToolbar::_GetEditProgID
(
IHTMLDocument2* pHTMLDocument
)
{
BSTR bstrProgID = NULL;
//
// First get all document elements. Note that this is very fast in
// ie5 because the collection directly accesses the internal tree.
//
IHTMLElementCollection * pAllCollection;
if (SUCCEEDED(pHTMLDocument->get_all(&pAllCollection)))
{
IHTMLMetaElement* pMetaElement;
IHTMLBodyElement* pBodyElement;
IHTMLFrameSetElement* pFrameSetElement;
IDispatch* pDispItem;
//
// Now we scan the document for meta tags. Since these must reside in
// in the head, and since Trident always creates a body tag, we can
// stop looking when we hit the body.
//
// Note, the alternative of using pAllCollection->tags to return the
// collection of meta tags is likely more expensive because it will
// walk the whole tree (unless Trident optimizes this).
//
long lItemCnt;
VARIANT vEmpty;
V_VT(&vEmpty) = VT_EMPTY;
VARIANT vIndex;
V_VT(&vIndex) = VT_I4;
EVAL(SUCCEEDED(pAllCollection->get_length(&lItemCnt)));
for (long lItem = 0; lItem < lItemCnt; lItem++)
{
V_I4(&vIndex) = lItem;
if (S_OK == pAllCollection->item(vIndex, vEmpty, &pDispItem))
{
//
// First see if it's a meta tag
//
if (SUCCEEDED(pDispItem->QueryInterface(IID_IHTMLMetaElement,
(void **)&pMetaElement)))
{
BSTR bstrName = NULL;
//
// We have a META element, check its NAME and CONTENT
//
if ( SUCCEEDED(pMetaElement->get_name(&bstrName)) && (bstrName != NULL) &&
(StrCmpIW(bstrName, OLESTR("ProgId")) == 0) &&
SUCCEEDED(pMetaElement->get_content(&bstrProgID)) && (bstrProgID != NULL)
)
{
// We got the ProgID, so terminate the search;
lItem = lItemCnt;
}
if (bstrName != NULL)
SysFreeString(bstrName);
pMetaElement->Release();
}
//
// Next check for the body tag
//
else if (SUCCEEDED(pDispItem->QueryInterface(IID_IHTMLBodyElement,
(void **)&pBodyElement)) )
{
// Found the body tag, so terminate the search
lItem = lItemCnt;
pBodyElement->Release();
}
//
// Finally, check for a frameset tag
//
else if (SUCCEEDED(pDispItem->QueryInterface(IID_IHTMLFrameSetElement,
(void **)&pFrameSetElement)) )
{
// Found a frameset tag, so terminate the search
lItem = lItemCnt;
pFrameSetElement->Release();
}
pDispItem->Release();
}
}
// Make sure that these don't have to be cleared (should not have been modified)
ASSERT(vEmpty.vt == VT_EMPTY);
ASSERT(vIndex.vt == VT_I4);
pAllCollection->Release();
}
return bstrProgID;
}
//+-------------------------------------------------------------------------
// Returns grey-scale image from the icon passed in.
//--------------------------------------------------------------------------
HIMAGELIST CInternetToolbar::_CreateGrayScaleImagelist(HBITMAP hbmpImage, HBITMAP hbmpMask)
{
// Determine the button dimensions
int cx = g_fSmallIcons ? TB_SMBMP_CX : TB_BMP_CX;
int cy = g_fSmallIcons ? TB_SMBMP_CY : TB_BMP_CY;
// Start with a 24 bit color image list
HIMAGELIST himlEdit = ImageList_Create(cx, cy, ILC_COLOR24 | ILC_MASK, 1, 1);
if (NULL == himlEdit)
{
return NULL;
}
ImageList_Add(himlEdit, hbmpImage, hbmpMask);
// Get the dib section from the image list
IMAGEINFO ii;
if (ImageList_GetImageInfo(himlEdit, 0, &ii))
{
DIBSECTION ds = {0};
if (GetObject(ii.hbmImage, sizeof(ds), &ds))
{
//
// Map each pixel to a monochrome equivalent.
//
BYTE* pBits = (BYTE*)ds.dsBm.bmBits;
BYTE* pScan = pBits;
int xWid = ds.dsBm.bmWidth;
int yHei = ds.dsBm.bmHeight;
long cbScan = ((xWid * 24 + 31) & ~31) / 8;
for (int y=0; y < yHei; ++y)
{
for (int x=0; x < xWid; ++x)
{
//
// Map to equivalent gray color by setting r,g,b to the same value.
// Using the average of r,g,b can be too dark, and using the max
// of r,g,b can be too bright. So, as a simple algorithm we use
// the average of the two schemes. This is cheaper than using true
// intensity matching.
//
BYTE nMax = max(max(pScan[0], pScan[1]), pScan[2]);
BYTE nAve = ((UINT)pScan[0] + pScan[1] + pScan[2])/3;
pScan[0] = pScan[1] = pScan[2] = ((UINT)nMax + nAve)/2;
// Increment to next pixel
pScan += 3;
}
// Increment to the next scan line
pBits += cbScan;
pScan = pBits;
}
}
}
return himlEdit;
}
//+-------------------------------------------------------------------------
// Returns image and mask bitmaps for the desired image list item
//--------------------------------------------------------------------------
BOOL MyImageList_GetBitmaps
(
HIMAGELIST himl, // image list to use
int iImage, // image to copy
int x, // x-offset to draw in bitmap
int y, // x-offset to draw in bitmap
int cx, // width of bitmap
int cy, // height of bitmap
HBITMAP* phbmpImage, // returned color bitmap
HBITMAP* phbmpMask // returned mask bitmap
)
{
ASSERT(phbmpImage);
ASSERT(phbmpMask);
BOOL fRet = FALSE;
HDC hdc = GetDC(NULL);
HDC hdcDst = CreateCompatibleDC(hdc);
if (hdcDst)
{
HBITMAP hbmpImage = CreateCompatibleBitmap(hdc, cx, cy);
if (hbmpImage)
{
HBITMAP hbmpMask = CreateBitmap(cx, cy, 1, 1, NULL);
if (hbmpMask)
{
// Draw mask bitmap
HBITMAP hbmpOld = (HBITMAP)SelectObject(hdcDst, hbmpMask);
PatBlt(hdcDst, 0, 0, cx, cy, WHITENESS);
ImageList_Draw(himl, iImage, hdcDst, x, y, ILD_MASK);
// Draw image bitmap
SelectObject(hdcDst, hbmpImage);
ImageList_Draw(himl, iImage, hdcDst, x, y, ILD_NORMAL);
SelectObject(hdcDst, hbmpOld);
*phbmpImage = hbmpImage;
*phbmpMask = hbmpMask;
fRet = TRUE;
}
else
{
DeleteObject(hbmpImage);
}
}
DeleteDC(hdcDst);
}
ReleaseDC(NULL, hdc);
return fRet;
}
extern HBITMAP CreateMirroredBitmap( HBITMAP hbmOrig);
//+-------------------------------------------------------------------------
// Creates a special image list for the edit button and configures the edit
// button to use it. If the hIcon is -1, the edit button is reset to use
// it's default glyph.
//--------------------------------------------------------------------------
void CInternetToolbar::_SetEditGlyph
(
int iIcon // new edit button glyph, index into shell image cache
)
{
// If no toolbar, we just need to see if we need to free the old image lists.
if (_btb._hwnd == NULL)
{
if (iIcon == -1)
{
if (_himlEdit)
{
ImageList_Destroy(_himlEdit);
_himlEdit = NULL;
}
if (_himlEditHot)
{
ImageList_Destroy(_himlEditHot);
_himlEditHot = NULL;
}
}
else
{
// Can't set the glyph if no toolbar!
ASSERT(FALSE);
}
return;
}
UINT uiCmd = -1;
// Dochost merges under one of two clsids, so have to check both
if (FAILED(_btb._ConvertCmd(&CLSID_InternetButtons, DVIDM_EDITPAGE, NULL, &uiCmd)) &&
FAILED(_btb._ConvertCmd(&CLSID_MSOButtons, DVIDM_EDITPAGE, NULL, &uiCmd)))
{
// The edit button is not on toolbar, so free the edit glyphs
iIcon = -1;
}
// If the current icon is already set, we are done
if (_iEditIcon == iIcon)
{
if (_himlEdit)
{
// Set up the new image lists
SendMessage(_btb._hwnd, TB_SETIMAGELIST, IL_EDITBUTTON, (LPARAM)_himlEdit);
if (_himlEditHot)
{
SendMessage(_btb._hwnd, TB_SETHOTIMAGELIST, IL_EDITBUTTON, (LPARAM)_himlEditHot);
}
// Redirect the edit button to the new image list
TBBUTTONINFO tbi = {0};
tbi.cbSize = sizeof(tbi);
tbi.dwMask = TBIF_IMAGE;
tbi.iImage = MAKELONG(0, IL_EDITBUTTON);
SendMessage(_btb._hwnd, TB_SETBUTTONINFO, uiCmd, (LPARAM)&tbi);
}
return;
}
_iEditIcon = iIcon;
if (-1 == iIcon)
{
if (_himlEdit)
{
if (uiCmd != -1)
{
// Reset to the original edit glyph
TBBUTTONINFO tbi = {0};
tbi.cbSize = sizeof(tbi);
tbi.dwMask = TBIF_IMAGE;
tbi.iImage = EDITGLYPH_OFFSET;
SendMessage(_btb._hwnd, TB_SETBUTTONINFO, uiCmd, (LPARAM)&tbi);
}
// Destroy the custom edit glyphs. Note that we have to reset the primary image list
// or the image sizes are screwed up.
SendMessage(_btb._hwnd, TB_SETIMAGELIST, IL_EDITBUTTON, (LPARAM)NULL);
ImageList_Destroy(_himlEdit);
_himlEdit = NULL;
}
if (_himlEditHot)
{
SendMessage(_btb._hwnd, TB_SETHOTIMAGELIST, IL_EDITBUTTON, (LPARAM)NULL);
ImageList_Destroy(_himlEditHot);
_himlEditHot = NULL;
}
}
else
{
// Determine the button dimensions
int cx = g_fSmallIcons ? TB_SMBMP_CX : TB_BMP_CX;
int cy = g_fSmallIcons ? TB_SMBMP_CY : TB_BMP_CY;
// Get the image bitmaps
HBITMAP hbmpImage = NULL;
HBITMAP hbmpMask = NULL;
BOOL bMirrored = IS_WINDOW_RTL_MIRRORED(_btb._hwnd);
HIMAGELIST himlSmall;
int cxSmall;
int cySmall;
if (Shell_GetImageLists(NULL, &himlSmall) &&
ImageList_GetIconSize(himlSmall, &cxSmall, &cySmall) &&
MyImageList_GetBitmaps(himlSmall, iIcon, (cx - cxSmall)/2, (cy - cySmall)/2,
cx, cy, &hbmpImage, &hbmpMask))
{
if (bMirrored)
{
HBITMAP hbmpTemp;
hbmpTemp = CreateMirroredBitmap(hbmpImage);
if (hbmpTemp)
{
DeleteObject(hbmpImage);
hbmpImage = hbmpTemp;
}
hbmpTemp = CreateMirroredBitmap(hbmpMask);
if (hbmpTemp)
{
DeleteObject(hbmpMask);
hbmpMask = hbmpTemp;
}
}
// Create a monochrome glyph for the edit button
HIMAGELIST himlEdit = _CreateGrayScaleImagelist(hbmpImage, hbmpMask);
SendMessage(_btb._hwnd, TB_SETIMAGELIST, IL_EDITBUTTON, (LPARAM)himlEdit);
if (_himlEdit)
{
ImageList_Destroy(_himlEdit);
}
_himlEdit = himlEdit;
// Create a hot glyph for the edit button
HIMAGELIST himlEditHot = ImageList_Create(cx, cy, ILC_COLORDDB | ILC_MASK, 1, 1);
int nIndex = ImageList_Add(himlEditHot, hbmpImage, hbmpMask);
SendMessage(_btb._hwnd, TB_SETHOTIMAGELIST, IL_EDITBUTTON, (LPARAM)himlEditHot);
if (_himlEditHot)
{
ImageList_Destroy(_himlEditHot);
}
_himlEditHot = himlEditHot;
// Redirect the edit button to the new image list
if (_himlEdit)
{
TBBUTTONINFO tbi = {0};
tbi.cbSize = sizeof(tbi);
tbi.dwMask = TBIF_IMAGE;
tbi.iImage = MAKELONG(nIndex, IL_EDITBUTTON);
SendMessage(_btb._hwnd, TB_SETBUTTONINFO, uiCmd, (LPARAM)&tbi);
}
DeleteObject(hbmpImage);
DeleteObject(hbmpMask);
}
else
{
// Couldn't create images so use the default edit glyph
_SetEditGlyph(-1);
}
}
}
//+-------------------------------------------------------------------------
// Initializes the edit button to display a drop-down menu if there are
// multiple verbs. Also optionally displays a custion glyph.
//--------------------------------------------------------------------------
void CInternetToolbar::_InitEditButtonStyle()
{
// If we have or want a custon edit glyph, load it
_SetEditGlyph(_aEditVerb.GetIcon());
UINT uiCmd;
// Dochost merges under one of two clsids, so have to check both
if (SUCCEEDED(_btb._ConvertCmd(&CLSID_InternetButtons, DVIDM_EDITPAGE, NULL, &uiCmd)) ||
SUCCEEDED(_btb._ConvertCmd(&CLSID_MSOButtons, DVIDM_EDITPAGE, NULL, &uiCmd)))
{
ASSERT(uiCmd != -1);
// If multiple verbs, make the button a split button
TBBUTTONINFO tbi = {0};
tbi.cbSize = sizeof(tbi);
tbi.dwMask = TBIF_STYLE | TBIF_STATE;
tbi.fsState = 0;
if (_aEditVerb.GetSize() > 1)
{
tbi.fsStyle |= BTNS_DROPDOWN;
}
if (_aEditVerb.GetSize() > 0)
{
tbi.fsState = TBSTATE_ENABLED;
}
SendMessage(_btb._hwnd, TB_SETBUTTONINFO, uiCmd, (LPARAM)&tbi);
}
}
//+-------------------------------------------------------------------------
// If the edit button is displaying a custon glyph, this function reloads
// the glyph.
//--------------------------------------------------------------------------
void CInternetToolbar::_RefreshEditGlyph()
{
// If we have a custon edit glyph, reload it
if (_himlEdit)
{
// Refresh the edit glyph
_iEditIcon = -1;
_InitEditButtonStyle();
}
}
//+-------------------------------------------------------------------------
// Updates the edit button based on the document type currently loaded
//--------------------------------------------------------------------------
void CInternetToolbar::_UpdateEditButton()
{
_aEditVerb.RemoveAll();
_fEditEnabled = FALSE;
//
// First add editors associated with the url
//
BSTR bstrUrl = NULL;
_pdie->get_LocationURL(&bstrUrl);
if (bstrUrl)
{
LPTSTR pszExt;
//
// Find the cache file associated with the url. The file extension for this entry
// is based off of the mime type. (Note that get_mimeType on the document
// returns a frindly name that is hard to translate back to an actual mimetype.
// So we use the file extension instead.)
//
WCHAR szCacheFileName[MAX_PATH];
*szCacheFileName = 0;
if (FAILED(URLToCacheFile(bstrUrl, szCacheFileName, ARRAYSIZE(szCacheFileName))))
{
// If we can't get a file associated with the url, probably want to disable the edit button
// because most apps need a file to edit.
SysFreeString(bstrUrl);
return;
}
pszExt = PathFindExtension(szCacheFileName);
// bug 79055 - The cache has a bug where some html entries are not
// given a file extension. Too risky to fix for 5.x, so we'll just
// assume .htm for http if no extension is present.
if (L'' == *pszExt && GetUrlScheme(bstrUrl) == URL_SCHEME_HTTP)
{
StrCpyN(szCacheFileName, L".htm", ARRAYSIZE(szCacheFileName));
pszExt = szCacheFileName;
}
if (*pszExt)
{
_aEditVerb.Add(pszExt);
// If ".html", use the ".htm" editors too
if (StrCmpI(pszExt, L".html") == 0 )
{
// This is an html document, so add the .htm editors
if (!_aEditVerb.Add(TEXT(".htm")) && StrCmpI(pszExt, L".html") != 0)
{
_aEditVerb.Add(TEXT(".html"));
}
}
}
SysFreeString(bstrUrl);
}
//
// See if the feature to search the doc for the progid is enabled
//
static int fCheckDocForProgID = -1;
if (fCheckDocForProgID == -1)
{
fCheckDocForProgID = SHRegGetBoolUSValue(REGSTR_PATH_MAIN,
TEXT("CheckDocumentForProgID"), FALSE, TRUE) ? 1 : 0;
}
// Check for a meta tag that specifies a progid for editing this document
if (fCheckDocForProgID)
{
//
// Next see if this is an html document with a progid
//
IWebBrowser2* pWB2 = NULL;
IDispatch * pDispatch = NULL;
IHTMLDocument2 * pHTMLDocument = NULL;
// Get the html document currently loaded
if (_psp &&
SUCCEEDED(_psp->QueryService(SID_SWebBrowserApp, IID_IWebBrowser2, (void **)&pWB2)) &&
SUCCEEDED(pWB2->get_Document(&pDispatch)) &&
SUCCEEDED(pDispatch->QueryInterface(IID_IHTMLDocument2, (void **)&pHTMLDocument)))
{
//
// Check the current document for a META tag specifying the program to use to
// edit this file.
//
BSTR bstrProgID = _GetEditProgID(pHTMLDocument);
if (bstrProgID)
{
USES_CONVERSION;
_aEditVerb.Add(W2T(bstrProgID));
SysFreeString(bstrProgID);
}
}
SAFERELEASE(pWB2);
SAFERELEASE(pDispatch);
SAFERELEASE(pHTMLDocument);
}
_fEditEnabled = (_aEditVerb.GetSize() > 0);
// Update edit glyph, drop-down style, & enabled state
_InitEditButtonStyle();
}
#endif //EDIT_HACK
HRESULT CInternetToolbar::Invoke(DISPID dispidMember,REFIID riid,LCID lcid,WORD wFlags,
DISPPARAMS * pdispparams, VARIANT * pvarResult,
EXCEPINFO * pexcepinfo,UINT * puArgErr)
{
ASSERT(pdispparams);
if(!pdispparams)
return E_INVALIDARG;
switch(dispidMember)
{
case DISPID_NAVIGATECOMPLETE2:
{
//
// Notify the brand and theater mode objects about whether we're in shell or
// web mode. Wait til now to do it (rather than doing it in SetCommandTarget)
// because they might want to ask the browser about the new pidl, which isn't
// yet filled in at SetCommandTarget time.
//
DWORD nCmdexecopt = _fShellView ? CITE_SHELL : CITE_INTERNET;
LPBANDITEMDATA pbid = _bs._GetBandItemDataStructByID(CBIDX_BRAND);
if (pbid)
{
IUnknown_Exec(pbid->pdb, &CGID_PrivCITCommands, CITIDM_ONINTERNET, nCmdexecopt, NULL, NULL);
}
if (_fTheater)
{
IUnknown_Exec(_ptbsite, &CGID_Theater, THID_ONINTERNET, nCmdexecopt, NULL, NULL);
}
_fNavigateComplete = TRUE;
}
break;
case DISPID_BEFORENAVIGATE:
{
BOOL fWeb = FALSE;
ASSERT((pdispparams->rgvarg[5].vt == VT_BSTR) &&
(pdispparams->rgvarg[5].bstrVal != NULL));
PARSEDURL pu = { 0 };
USES_CONVERSION;
pu.cbSize = SIZEOF(pu);
ParseURL(W2T(pdispparams->rgvarg[5].bstrVal), &pu);
if ((URL_SCHEME_UNKNOWN != pu.nScheme) && (URL_SCHEME_FILE != pu.nScheme))
fWeb = TRUE;
UINT uiState = 0;
GetState(&CLSID_CommonButtons, TBIDM_STOPDOWNLOAD, &uiState);
if ((uiState & TBSTATE_HIDDEN) && fWeb)
{
_fTransitionToHTML = TRUE;
uiState &= ~TBSTATE_HIDDEN;
SetState(&CLSID_CommonButtons, TBIDM_STOPDOWNLOAD, uiState);
}
// Default to the edit button hidden
_fEditEnabled = FALSE;
}
break;
case DISPID_DOWNLOADBEGIN:// This is when we just started to navigate? No bits?
_StartDownload();
break;
case DISPID_DOWNLOADCOMPLETE: // we be done
_fTransitionToHTML = FALSE;
_StopDownload(FALSE);
break;
case DISPID_DOCUMENTCOMPLETE: // This is where we have all the bits
{
//
// Sometimes we get a premature document complete. We can catch this
// by checking to see if we have received a DISPID_NAVIGATECOMPLETE2 event.
//
if (_fNavigateComplete)
{
_fNavigateComplete = FALSE;
_UpdateEditButton();
}
break;
}
case DISPID_COMMANDSTATECHANGE:
BOOL fEnable;
if(!pdispparams || (pdispparams->cArgs != 2) ||
(pdispparams->rgvarg[0].vt != VT_BOOL) ||
(pdispparams->rgvarg[1].vt != VT_I4))
return E_INVALIDARG;
fEnable = (BOOL) pdispparams->rgvarg[0].boolVal;
UINT uiCmd;
switch (pdispparams->rgvarg[1].lVal)
{
case CSC_UPDATECOMMANDS:
// corresponds to OLECMDID_UPDATECOMMANDS from Exec()
_UpdateToolbar(FALSE);
break;
case CSC_NAVIGATEBACK:
_fBackEnabled = fEnable;
_btb._ConvertCmd(&CLSID_CommonButtons, TBIDM_BACK, NULL, &uiCmd);
SendMessage(_btb._hwnd, TB_ENABLEBUTTON, uiCmd, MAKELONG(fEnable, 0));
break;
case CSC_NAVIGATEFORWARD:
_fForwardEnabled = fEnable;
_btb._ConvertCmd(&CLSID_CommonButtons, TBIDM_FORWARD, NULL, &uiCmd);
SendMessage(_btb._hwnd, TB_ENABLEBUTTON, uiCmd, MAKELONG(fEnable, 0));
break;
default:
return(E_INVALIDARG);
}
// BUGBUG need to handle the case of navigation failure and
// do some cleanup
}
return S_OK;
}
//*** CInternetToolbar::IInputObjectSite::* {
HRESULT CInternetToolbar::OnFocusChangeIS(IUnknown *punk, BOOL fSetFocus)
{
return UnkOnFocusChangeIS(_ptbsite, SAFECAST(this, IInputObject*), fSetFocus);
}
// }
//*** CInternetToolbar::IInputObject::* {
HRESULT CInternetToolbar::TranslateAcceleratorIO(LPMSG lpMsg)
{
LPBANDITEMDATA pbid;
if (_fShow)
{
if (lpMsg->message == WM_KEYDOWN)
{
switch (lpMsg->wParam)
{
case VK_F4:
Laddrband:
if (_nVisibleBands & VBF_ADDRESS)
{
pbid = _bs._GetBandItemDataStructByID(CBIDX_ADDRESS);
if (EVAL(pbid))
{
HRESULT hrT;
hrT = UnkTranslateAcceleratorIO(pbid->pdb, lpMsg);
ASSERT(hrT == S_OK);
}
}
return S_OK; // (even if we just eat it)
}
}
else if(lpMsg->message == WM_SYSCHAR)
{
static CHAR szAccel[2] = "";
CHAR szChar [2] = "";
if ('' == szAccel[0])
MLLoadStringA(IDS_ADDRBAND_ACCELLERATOR, szAccel, ARRAYSIZE(szAccel));
szChar[0] = (CHAR)lpMsg->wParam;
if (lstrcmpiA(szChar,szAccel) == 0)
{
goto Laddrband;
}
}
return _bs.TranslateAcceleratorIO(lpMsg);
}
return S_FALSE;
}
// }
HRESULT CInternetToolbar::SetSite(IUnknown* punkSite)
{
ATOMICRELEASE(_ptbsite);
ATOMICRELEASE(_ptbsitect);
ATOMICRELEASE(_pbs2);
ATOMICRELEASE(_psp);
_Unadvise();
ATOMICRELEASE(_pdie);
ASSERT(_ptbsite==NULL);
ASSERT(_ptbsitect==NULL);
ASSERT(_pbs2==NULL);
ASSERT(_pdie==NULL);
if (_pbp && _fCreatedBandProxy)
_pbp->SetSite(punkSite);
if (punkSite)
{
punkSite->QueryInterface(IID_IDockingWindowSite, (void **)&_ptbsite);
punkSite->QueryInterface(IID_IOleCommandTarget, (void **)&_ptbsitect);
punkSite->QueryInterface(IID_IBrowserService2, (void **)&_pbs2);
punkSite->QueryInterface(IID_IServiceProvider, (void **)&_psp);
if (_psp)
{
_psp->QueryService(SID_SWebBrowserApp, IID_IWebBrowser2, (void **)&_pdie);
ASSERT(_pdie);
}
else
{
ASSERT(0);
}
}
else
{
SetClient(NULL);
}
return S_OK;
}
//***
//
void CInternetToolbar::_UpdateGroup(const GUID *pguidCmdGroup, int cnt,
OLECMD rgcmds[], const GUID* pguidButton, const int buttonsInternal[])
{
if (!IsEqualGUID(*pguidButton, CLSID_CommonButtons) &&
!IsEqualGUID(*pguidButton, _btb._guidCurrentButtonGroup))
return; // we don't have any buttons at this time, so no use checking
if (_ptbsitect) {
_ptbsitect->QueryStatus(pguidCmdGroup, cnt, rgcmds, NULL);
// make sure stop is enabled while we are animating
if (_fAnimating && pguidCmdGroup == NULL && rgcmds[0].cmdID == OLECMDID_STOP) {
rgcmds[0].cmdf = OLECMDF_ENABLED;
}
}
for (int i = 0; i < cnt; i++)
{
// do nothing if command is not available or not in our table
if (rgcmds[i].cmdf & OLECMDF_SUPPORTED)
{
UINT idBut;
if (SUCCEEDED(_btb._ConvertCmd(pguidButton, buttonsInternal[i], NULL, (UINT*)&idBut)))
{
SendMessage(_btb._hwnd, TB_ENABLEBUTTON, idBut,
(rgcmds[i].cmdf & OLECMDF_ENABLED) ? TRUE : FALSE);
SendMessage(_btb._hwnd, TB_CHECKBUTTON, idBut,
(rgcmds[i].cmdf & OLECMDF_LATCHED) ? TRUE : FALSE);
}
}
}
return;
}
void CInternetToolbar::_UpdateToolbar(BOOL fForce)
{
if (fForce || SHIsChildOrSelf(GetForegroundWindow(), _hwnd) == S_OK)
{
if (!_fUpdateToolbarTimer)
{
SetTimer(_hwnd, IDT_UPDATETOOLBAR, TIMEOUT_UPDATETOOLBAR, NULL);
_fUpdateToolbarTimer = TRUE;
_UpdateToolbarNow();
}
else
{
_fNeedUpdateToolbar = TRUE;
}
}
}
BOOL CInternetToolbar::_UpEnabled()
{
OLECMD rgcmd = { FCIDM_PREVIOUSFOLDER, 0 };
_ptbsitect->QueryStatus(&CGID_ShellBrowser, 1, &rgcmd, NULL);
return (rgcmd.cmdf & OLECMDF_ENABLED);
}
void CInternetToolbar::_UpdateCommonButton(int iCmd, UINT nCmdID)
{
switch (nCmdID) {
case TBIDM_THEATER:
SendMessage(_btb._hwnd, TB_CHECKBUTTON, iCmd, _fTheater);
break;
case TBIDM_PREVIOUSFOLDER:
case TBIDM_BACK:
case TBIDM_FORWARD:
{
BOOL fEnabled;
switch (nCmdID) {
case TBIDM_PREVIOUSFOLDER: fEnabled = _UpEnabled(); break;
case TBIDM_BACK: fEnabled = _fBackEnabled; break;
case TBIDM_FORWARD: fEnabled = _fForwardEnabled; break;
}
SendMessage(_btb._hwnd, TB_ENABLEBUTTON, iCmd, MAKELONG(fEnabled, 0));
}
break;
}
}
void CInternetToolbar::_UpdateToolbarNow()
{
_fNeedUpdateToolbar = FALSE;
{
// MUST not be static (due to ConvertCmd overwrite)
OLECMD rgcmds[] = {
{ OLECMDID_STOP, 0 }, // NOTE: must be first
{ OLECMDID_REFRESH, 0 },
};
static const int buttonsInternal[] = { // MUST be in same order as above array
TBIDM_STOPDOWNLOAD,
TBIDM_REFRESH,
};
_UpdateGroup(NULL, ARRAYSIZE(buttonsInternal), rgcmds, &CLSID_CommonButtons, buttonsInternal);
}
{
OLECMD rgcmds[] = {
{ SBCMDID_SEARCHBAR, 0 },
{ SBCMDID_FAVORITESBAR, 0 },
{ SBCMDID_HISTORYBAR, 0 },
#ifdef ENABLE_CHANNELPANE
{ SBCMDID_CHANNELSBAR, 0 },
#endif
{ SBCMDID_EXPLORERBAR, 0 },
};
static const int buttonsInternal[] = { // MUST be in same order as above array
TBIDM_SEARCH,
TBIDM_FAVORITES,
TBIDM_HISTORY,
#ifdef ENABLE_CHANNELPANE
TBIDM_CHANNELS,
#endif
TBIDM_ALLFOLDERS,
};
_UpdateGroup(&CGID_Explorer, ARRAYSIZE(buttonsInternal), rgcmds, &CLSID_CommonButtons, buttonsInternal);
}
int nButtons = (int) SendMessage(_btb._hwnd, TB_BUTTONCOUNT, 0, 0L);
for (int nIndex = 0; nIndex < nButtons; nIndex++)
{
CMDMAP* pcm = _btb._GetCmdMapByIndex(nIndex);
if (pcm)
{
int iCmd = _btb._CommandFromIndex(nIndex);
if (IsEqualGUID(pcm->guidButtonGroup, CLSID_CommonButtons))
{
_UpdateCommonButton(iCmd, pcm->nCmdID);
}
else
{
// If either of these rip, the button is stale
ASSERT(IsEqualGUID(pcm->guidButtonGroup, _btb._guidCurrentButtonGroup));
ASSERT(_btb._pctCurrentButtonGroup);
OLECMD ocButton;
ocButton.cmdID = pcm->nCmdID;
ocButton.cmdf = 0;
if (SUCCEEDED(_btb._pctCurrentButtonGroup->QueryStatus(&pcm->guidButtonGroup, 1, &ocButton, NULL)))
{
SendMessage(_btb._hwnd, TB_ENABLEBUTTON, iCmd,
(ocButton.cmdf & OLECMDF_ENABLED) ? TRUE : FALSE);
SendMessage(_btb._hwnd, TB_CHECKBUTTON, iCmd,
(ocButton.cmdf & OLECMDF_LATCHED) ? TRUE : FALSE);
}
}
}
}
_btb._BandInfoChanged();
}
void CInternetToolbar::_StartDownload()
{
UINT uiCmd;
if (SUCCEEDED(_btb._ConvertCmd(&CLSID_CommonButtons, TBIDM_STOPDOWNLOAD, NULL, &uiCmd)))
{
SendMessage(_btb._hwnd, TB_ENABLEBUTTON, uiCmd, MAKELONG(TRUE, 0));
_fAnimating = TRUE;
}
}
//
// Parameters:
// fClosing -- TRUE only if we are calling this from CloseDW member.
// In that case, we can skip all UI-update code.
//
void CInternetToolbar::_StopDownload(BOOL fClosing)
{
_fAnimating = FALSE;
}
HRESULT CInternetToolbar::CloseDW(DWORD dwReserved)
{
_fDestroyed = TRUE; // Stop using the member variables, they are invalid.
_StopDownload(TRUE);
ASSERT(!_btb._pcinfo);
ATOMICRELEASE(_btb._pctCurrentButtonGroup);
_btb._FreeBtnsAdded();
if (_btb._hwnd)
{
_btb._RemoveAllButtons();
SendMessage(_btb._hwnd, TB_SETIMAGELIST, 0, NULL);
SendMessage(_btb._hwnd, TB_SETHOTIMAGELIST, 0, NULL);
DSA_Destroy(_hdsaTBBMPs);
_hdsaTBBMPs = NULL; // So we don't try to re-destroy in _InitBitmapDSA()
_hdsaTBBMPs = NULL;
}
#ifdef EDIT_HACK
_SetEditGlyph(-1);
#endif
_bs._Close();
SUPERCLASS::CloseDW(dwReserved);
_btb._hwnd = NULL;
// We advise during ShowDW, so unadvise here. Also, we hit a stress
// case where it seems that an event came in after closedw but before
// one of the other _Unadvise calls. This event percolated down to
// a reference to _hdsaCT which we freed above, causing a GPF.
//
_Unadvise();
return S_OK;
}
void CInternetToolbar::CITBandSite::v_SetTabstop(LPREBARBANDINFO prbbi)
{
// Don't set tabstops for all bands in the browser case. A band
// can still make itself a tabstop by setting WS_TABSTOP.
return;
}
BOOL CInternetToolbar::CITBandSite::_SetMinDimensions()
{
INT_PTR fRedraw = SendMessage(_hwnd, WM_SETREDRAW, FALSE, 0);
int icBands = (int) SendMessage( _hwnd, RB_GETBANDCOUNT, 0, 0 );
for (int i = 0; i < icBands; i++)
{
REBARBANDINFO rbbi;
rbbi.cbSize = sizeof(REBARBANDINFO);
rbbi.fMask = RBBIM_ID | RBBIM_CHILDSIZE;
if (SendMessage(_hwnd, RB_GETBANDINFO, i, (LPARAM) &rbbi))
{
LPBANDITEMDATA pbid = (LPBANDITEMDATA)_GetBandItemDataStructByID(rbbi.wID);
if (EVAL(pbid) && IS_VALID_HANDLE(pbid->hwnd, WND))
{
rbbi.cxMinChild = pbid->ptMinSize.x;
rbbi.cyMinChild = pbid->ptMinSize.y;
}
else
{
rbbi.cxMinChild = 0;
rbbi.cyMinChild = 0;
}
SendMessage(_hwnd, RB_SETBANDINFO, i, (LPARAM) &rbbi);
}
}
SendMessage(_hwnd, WM_SETREDRAW, fRedraw, 0);
return TRUE;
}
BOOL HimlCacheDirty(IMLCACHE* pimlCache, BOOL fSmallIcons)
{
if (fSmallIcons != pimlCache->fSmallIcons)
return TRUE;
COLORREF cr3D = GetSysColor(COLOR_3DFACE);
if (cr3D != pimlCache->cr3D)
return TRUE;
for (int i = 0; i < CIMLISTS; i++)
if (!pimlCache->arhiml[i])
return TRUE;
return FALSE;
}
#define SZ_REGKEY_SMALLICONS REGSTR_PATH_EXPLORER TEXT("\SmallIcons")
#define SZ_REGVALUE_SMALLICONS TEXT("SmallIcons")
BOOL _DefaultToSmallIcons()
{
// On NT5, we want to default to small icons.
return (GetUIVersion() >= 5) || SHRestricted2(REST_SMALLICONS, NULL, 0);
}
BOOL _UseSmallIcons()
{
BOOL fDefaultToSmall = _DefaultToSmallIcons();
return SHRegGetBoolUSValue(SZ_REGKEY_SMALLICONS, SZ_REGVALUE_SMALLICONS,
FALSE, fDefaultToSmall);
}
BOOL _UseMapNetDrvBtns()
{
#define SZ_REGKEY_ADVFOLDER TEXT("Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced")
#define SZ_REGVALUE_MAPNETDRV TEXT("MapNetDrvBtn")
DWORD dwData = 0;
if (GetUIVersion() >= 4)
{
DWORD cbData = SIZEOF(dwData);
DWORD dwDefault = 0;
DWORD cbDefault = SIZEOF(dwDefault);
SHRegGetUSValue(SZ_REGKEY_ADVFOLDER, SZ_REGVALUE_MAPNETDRV, NULL,
&dwData, &cbData, FALSE, &dwDefault, cbDefault);
}
return dwData;
}
void _LoadToolbarGlyphs(HWND hwnd, IMLCACHE *pimlCache, int cx, int idBmp)
{
// set uMsg and uFlags for first iteration of loop (default state)
UINT uMsg = TB_SETIMAGELIST;
UINT uFlags = LR_CREATEDIBSECTION;
int i;
HBITMAP hBMP;
BOOL fSmallIcons = g_fSmallIcons;
if (HimlCacheDirty(pimlCache, fSmallIcons))
{
COLORREF cr3D = GetSysColor(COLOR_3DFACE);
COLORREF crMask = RGB( 255, 0, 255 );
#ifdef UNIX
if (SHGetCurColorRes() < 2 )
{
crMask = CLR_NONE;
}
#endif
ENTERCRITICAL;
if (!HimlCacheDirty(pimlCache, fSmallIcons) )
goto DontReload;
for (i = 0; i < CIMLISTS; i++)
{
if ((!pimlCache->arhiml[i]) || (cr3D != pimlCache->cr3D) || fSmallIcons != pimlCache->fSmallIcons)
{
TraceMsg(DM_ITBAR, "CInternetToolbar: Loading New Images");
if (pimlCache->arhimlPendingDelete[i])
ImageList_Destroy(pimlCache->arhimlPendingDelete[i]);
pimlCache->arhimlPendingDelete[i] = pimlCache->arhiml[i];
pimlCache->arhiml[i] = ImageList_LoadImage(HINST_THISDLL,
MAKEINTRESOURCE(idBmp + i), cx, 0, crMask,
IMAGE_BITMAP, uFlags);
if (pimlCache->arhiml[i])
{
// add shell glyphs
int idShellBmp = IDB_SHSTD;
int iDelta = idBmp - IDB_IETOOLBAR;
idShellBmp += iDelta;
hBMP = LoadBitmap(HINST_THISDLL, MAKEINTRESOURCE(idShellBmp + i));
ImageList_AddMasked(pimlCache->arhiml[i], (HBITMAP)hBMP, crMask);
DeleteObject(hBMP);
}
}
}
pimlCache->cr3D = cr3D;
pimlCache->fSmallIcons = fSmallIcons;
DontReload:
LEAVECRITICAL;
}
if (hwnd) {
ASSERT(IS_VALID_HANDLE(hwnd, WND));
for (i = 0; i < CIMLISTS; i++)
{
SendMessage(hwnd, uMsg, 0, (LPARAM) pimlCache->arhiml[i]);
// set uMsg and uFlags for last iteration of loop (hot state)
uMsg = TB_SETHOTIMAGELIST;
uFlags = 0;
}
}
}
void CInternetToolbar::_InitBitmapDSA()
{
DSA_Destroy(_hdsaTBBMPs);
_hdsaTBBMPs = DSA_Create(SIZEOF(TBBMP_LIST), TBBMPLIST_CHUNK);
if (_hdsaTBBMPs) {
TBBMP_LIST tbl = { HINST_COMMCTRL, 0, 0, TRUE, TRUE, FALSE };
tbl.uiResID = IDB_STD_SMALL_COLOR;
tbl.uiOffset = OFFSET_STD;
DSA_AppendItem(_hdsaTBBMPs, &tbl);
tbl.uiResID = IDB_STD_LARGE_COLOR;
DSA_AppendItem(_hdsaTBBMPs, &tbl);
tbl.uiResID = IDB_VIEW_SMALL_COLOR;
tbl.uiOffset = OFFSET_VIEW;
DSA_AppendItem(_hdsaTBBMPs, &tbl);
tbl.uiResID = IDB_VIEW_LARGE_COLOR;
DSA_AppendItem(_hdsaTBBMPs, &tbl);
tbl.uiResID = IDB_HIST_SMALL_COLOR;
tbl.uiOffset = OFFSET_HIST;
DSA_AppendItem(_hdsaTBBMPs, &tbl);
tbl.uiResID = IDB_HIST_LARGE_COLOR;
DSA_AppendItem(_hdsaTBBMPs, &tbl);
}
}
void CInternetToolbar::_InitForScreenSize()
{
TCHAR szScratch[16];
if (GetSystemMetrics(SM_CXSCREEN) < 650)
{
MLLoadString(IDS_TB_WIDTH_EXTRA_LORES, szScratch, ARRAYSIZE(szScratch));
_uiMaxTBWidth = MAX_TB_WIDTH_LORES;
}
else
{
MLLoadString(IDS_TB_WIDTH_EXTRA_HIRES, szScratch, ARRAYSIZE(szScratch));
_uiMaxTBWidth = MAX_TB_WIDTH_HIRES;
}
_uiMaxTBWidth += StrToInt(szScratch) * WIDTH_FACTOR;
}
// removes all buttons marked hidden. returns the number
// of buttons left
int RemoveHiddenButtons(TBBUTTON* ptbn, int iCount)
{
int i;
int iTotal = 0;
TBBUTTON* ptbn1 = ptbn;
for (i = 0; i < iCount; i++, ptbn1++)
{
if (!(ptbn1->fsState & TBSTATE_HIDDEN))
{
if (ptbn1 != ptbn)
{
*ptbn = *ptbn1;
}
ptbn++;
iTotal++;
}
}
return iTotal;
}
#ifdef DEBUG
void _AssertRestrictionOrderIsCorrect()
{
COMPILETIME_ASSERT(ARRAYSIZE(c_tbExplorer) == ARRAYSIZE(c_rest));
for (UINT i = 0; i < ARRAYSIZE(c_tbExplorer); i++)
{
// If any of these rip, it means that c_rest and c_tbExplorer have
// gotten out of sync. Need to fix up c_rest to match c_tbExplorer.
switch (c_tbExplorer[i].idCommand)
{
case TBIDM_BACK: ASSERT(c_rest[i] == REST_BTN_BACK); break;
case TBIDM_FORWARD: ASSERT(c_rest[i] == REST_BTN_FORWARD); break;
case TBIDM_STOPDOWNLOAD: ASSERT(c_rest[i] == REST_BTN_STOPDOWNLOAD); break;
case TBIDM_REFRESH: ASSERT(c_rest[i] == REST_BTN_REFRESH); break;
case TBIDM_HOME: ASSERT(c_rest[i] == REST_BTN_HOME); break;
case TBIDM_SEARCH: ASSERT(c_rest[i] == REST_BTN_SEARCH); break;
case TBIDM_HISTORY: ASSERT(c_rest[i] == REST_BTN_HISTORY); break;
case TBIDM_FAVORITES: ASSERT(c_rest[i] == REST_BTN_FAVORITES); break;
case TBIDM_ALLFOLDERS: ASSERT(c_rest[i] == REST_BTN_ALLFOLDERS); break;
case TBIDM_THEATER: ASSERT(c_rest[i] == REST_BTN_THEATER); break;
default: ASSERT(c_rest[i] == REST_BROWSER_NONE); break;
}
}
}
#endif
__inline BOOL CInternetToolbar::_FoldersButtonAvailable()
{
return (GetUIVersion() >= 4);
}
void CInternetToolbar::_AdminMarkDefaultButtons(PTBBUTTON ptbb, UINT cButtons)
{
// We only have policies for web buttons.
ASSERT(!_fShellView);
// Caller should have checked this.
ASSERT(SHRestricted2(REST_SPECIFYDEFAULTBUTTONS, NULL, 0));
// SHRestricted2 returns 0 if it can't find the policy. Assert that
// this lines up with RESTOPT_BTN_STATE_DEFAULT.
COMPILETIME_ASSERT(RESTOPT_BTN_STATE_DEFAULT == 0);
for (UINT i = 0; i < cButtons; i++)
{
if (c_rest[i] != 0) {
DWORD dwRest = SHRestricted2(c_rest[i], NULL, 0);
ptbb[i].fsState = SHBtnStateFromRestriction(dwRest, ptbb[i].fsState);
}
}
// Folders button is not available on non-integrated platforms, so
// set state to hidden even if policy specifies that it should be shown.
ASSERT(c_tbExplorer[10].idCommand == TBIDM_ALLFOLDERS);
if (!_FoldersButtonAvailable())
ptbb[10].fsState |= TBSTATE_HIDDEN;
}
void CInternetToolbar::_MarkDefaultButtons(PTBBUTTON ptbb, UINT cButtons)
{
if (_fShellView)
{
ASSERT(c_tbExplorer[2].idCommand == TBIDM_STOPDOWNLOAD);
ptbb[2].fsState |= TBSTATE_HIDDEN;
ASSERT(c_tbExplorer[3].idCommand == TBIDM_REFRESH);
ptbb[3].fsState |= TBSTATE_HIDDEN;
ASSERT(c_tbExplorer[4].idCommand == TBIDM_HOME);
ptbb[4].fsState |= TBSTATE_HIDDEN;
ASSERT(c_tbExplorer[9].idCommand == TBIDM_SEARCH);
ASSERT(c_tbExplorer[12].idCommand == TBIDM_HISTORY);
ASSERT(c_tbExplorer[13].idCommand == 0); // (a separator)
if (GetUIVersion() < 5)
{
ptbb[9].fsState |= TBSTATE_HIDDEN;
ptbb[12].fsState |= TBSTATE_HIDDEN;
ptbb[13].fsState |= TBSTATE_HIDDEN;
}
else
{
if (SHRestricted(REST_NOSHELLSEARCHBUTTON))
{
ptbb[9].fsState |= TBSTATE_HIDDEN;
}
ASSERT(c_tbExplorer[6].idCommand == TBIDM_CONNECT);
ASSERT(c_tbExplorer[7].idCommand == TBIDM_DISCONNECT);
if (SHRestricted(REST_NONETCONNECTDISCONNECT))
{
ptbb[6].fsState |= TBSTATE_HIDDEN;
ptbb[7].fsState |= TBSTATE_HIDDEN;
}
}
ASSERT(c_tbExplorer[11].idCommand == TBIDM_FAVORITES);
ptbb[11].fsState |= TBSTATE_HIDDEN;
}
ASSERT(c_tbExplorer[5].idCommand == TBIDM_PREVIOUSFOLDER);
if (!_fShellView)
ptbb[5].fsState |= TBSTATE_HIDDEN;
ASSERT(c_tbExplorer[6].idCommand == TBIDM_CONNECT);
ASSERT(c_tbExplorer[7].idCommand == TBIDM_DISCONNECT);
if (!_fShellView || !_UseMapNetDrvBtns())
{
ptbb[6].fsState |= TBSTATE_HIDDEN;
ptbb[7].fsState |= TBSTATE_HIDDEN;
}
// If this TBIDM_ALLFOLDERS assertion rips, remember to fix up _AdminMarkDefaultButtons too.
ASSERT(c_tbExplorer[10].idCommand == TBIDM_ALLFOLDERS);
if (!_fShellView || GetUIVersion() < 5)
ptbb[10].fsState |= TBSTATE_HIDDEN;
ASSERT(c_tbExplorer[14].idCommand == TBIDM_THEATER);
ptbb[14].fsState |= TBSTATE_HIDDEN;
}
void CInternetToolbar::_AddCommonButtons()
{
TBBUTTON tbExplorer[ARRAYSIZE(c_tbExplorer)];
memcpy(tbExplorer, c_tbExplorer, SIZEOF(TBBUTTON) * ARRAYSIZE(c_tbExplorer));
_MarkDefaultButtons(tbExplorer, ARRAYSIZE(c_tbExplorer));
#ifdef DEBUG
_AssertRestrictionOrderIsCorrect();
#endif
if (!_fShellView && SHRestricted2(REST_SPECIFYDEFAULTBUTTONS, NULL, 0))
_AdminMarkDefaultButtons(tbExplorer, ARRAYSIZE(c_tbExplorer));
int iButtons = RemoveHiddenButtons(tbExplorer, ARRAYSIZE(tbExplorer));
for (int i = 0; i < iButtons; i++)
{
if (!(tbExplorer[i].fsStyle & BTNS_SEP))
{
CMDMAP* pcm = (CMDMAP*)LocalAlloc(LPTR, SIZEOF(CMDMAP));
if (pcm)
{
pcm->guidButtonGroup = CLSID_CommonButtons;
pcm->nCmdID = tbExplorer[i].idCommand;
tbExplorer[i].idCommand = _btb._nNextCommandID++;
tbExplorer[i].dwData = (LPARAM)pcm;
}
}
}
SendMessage(_btb._hwnd, TB_ADDBUTTONS, iButtons, (LPARAM) tbExplorer);
_btb._RecalcButtonWidths();
}
#define IS_LIST_STYLE(hwnd) (BOOLIFY(GetWindowLong(hwnd, GWL_STYLE) & TBSTYLE_LIST))
void CInternetToolbar::_UpdateToolsStyle(BOOL fList)
{
if (BOOLIFY(fList) != IS_LIST_STYLE(_btb._hwnd))
{
_fDirty = TRUE;
// toggle TBSTYLE_LIST
SHSetWindowBits(_btb._hwnd, GWL_STYLE, TBSTYLE_LIST, fList ? TBSTYLE_LIST : 0);
// toggle TBSTYLE_EX_MIXEDBUTTONS
SendMessage(_btb._hwnd, TB_SETEXTENDEDSTYLE, TBSTYLE_EX_MIXEDBUTTONS, fList ? TBSTYLE_EX_MIXEDBUTTONS : 0);
}
}
void CInternetToolbar::_InitToolbar()
{
TCHAR szShellTBText[1024]; // This should be enough
ZeroMemory(szShellTBText, sizeof(szShellTBText));
int nRows = _fCompressed ? 0 : _uiTBTextRows;
// this tells the toolbar what version we are
SendMessage(_btb._hwnd, TB_BUTTONSTRUCTSIZE, SIZEOF(TBBUTTON), 0);
SendMessage(_btb._hwnd, TB_SETEXTENDEDSTYLE, 0,
TBSTYLE_EX_DRAWDDARROWS | TBSTYLE_EX_HIDECLIPPEDBUTTONS);
SendMessage(_btb._hwnd, TB_SETMAXTEXTROWS, nRows, 0L);
SendMessage(_btb._hwnd, TB_SETDROPDOWNGAP, GetSystemMetrics(SM_CXEDGE) / 2, 0);
SendMessage(_btb._hwnd, CCM_SETVERSION, COMCTL32_VERSION, 0);
_UpdateToolsStyle(_cs.fList);
ITBar_LoadToolbarGlyphs(_btb._hwnd);
_InitBitmapDSA();
_InitForScreenSize();
SendMessage(_btb._hwnd, TB_ADDSTRING, (WPARAM)MLGetHinst(), IDS_IE_TB_LABELS);
_AddCommonButtons();
INT_PTR nRet = SendMessage(_btb._hwnd, TB_ADDSTRING, (WPARAM)MLGetHinst(), IDS_SHELL_TB_LABELS);
ASSERT(nRet == SHELLTOOLBAR_OFFSET);
}
HRESULT CInternetToolbar::_ShowTools(PBANDSAVE pbs)
{
HRESULT hr = S_OK;
LPBANDITEMDATA pbid = _bs._GetBandItemDataStructByID(CBIDX_TOOLS);
if (!pbid) {
ASSERT(!_btb._hwnd);
_btb._hwnd = CreateWindowEx(WS_EX_TOOLWINDOW, TOOLBARCLASSNAME, NULL,
WS_CHILD | TBSTYLE_FLAT |
TBSTYLE_TOOLTIPS |
WS_CLIPCHILDREN |
WS_CLIPSIBLINGS | CCS_NODIVIDER | CCS_NOPARENTALIGN |
CCS_NORESIZE,
0, 0, 0, 0, _bs._hwnd, (HMENU) FCIDM_TOOLBAR, HINST_THISDLL, NULL);
if (_btb._hwnd) {
_btb._hwnd = _btb._hwnd;
_InitToolbar();
pbid = _AddNewBand((IDeskBand*)&_btb, CBIDX_TOOLS);
}
if (!pbid)
return E_OUTOFMEMORY;
} else {
pbs = NULL;
}
_ShowBandCommon(pbs, pbid, _nVisibleBands & VBF_TOOLS);
return hr;
}
void CInternetToolbar::_ShowBandCommon(PBANDSAVE pbs, LPBANDITEMDATA pbid, BOOL fShow)
{
REBARBANDINFO rbbi;
pbid->fShow = BOOLIFY(fShow);
pbid->pdb->ShowDW(pbid->fShow);
INT_PTR i = BandIDtoIndex(_bs._hwnd, pbid->dwBandID);
if (pbs)
{
rbbi.cbSize = sizeof(REBARBANDINFO);
rbbi.fMask = RBBIM_SIZE | RBBIM_STYLE;
// we just want to change the RBBS_BREAK bit
// assert that our caller doesn't expect to set any other bits
// ASSERT(!(pbs->fStyle & ~RBBS_BREAK)); <--- I hit this assert all the time
// get old style
SendMessage(_bs._hwnd, RB_GETBANDINFO, i, (LPARAM)&rbbi);
rbbi.fStyle = (rbbi.fStyle & ~RBBS_BREAK) | (pbs->fStyle & RBBS_BREAK);
rbbi.cx = pbs->cx;
SendMessage(_bs._hwnd, RB_SETBANDINFO, i, (LPARAM)&rbbi);
}
if ( pbid->dwModeFlags & DBIMF_BREAK )
{
rbbi.cbSize = sizeof(REBARBANDINFO);
rbbi.fMask = RBBIM_STYLE;
if (SendMessage(_bs._hwnd, RB_GETBANDINFO, i, (LPARAM) &rbbi))
{
// in theater mode we don't allow bands to have breaks
if ((rbbi.fStyle & RBBS_BREAK ) && _fTheater)
{
rbbi.fStyle &= ~RBBS_BREAK;
SendMessage(_bs._hwnd, RB_SETBANDINFO, i, (LPARAM) &rbbi);
}
}
}
SendMessage(_bs._hwnd, RB_SHOWBAND, i, pbid->fShow);
}
HRESULT CInternetToolbar::_GetPersistedBand(const CLSID clsid, REFIID riid, void ** ppiface)
{
HRESULT hr = E_FAIL;
TCHAR szStreamName[MAX_PATH];
if (SUCCEEDED(_GetStreamName(_fInitialPidlIsWeb, szStreamName, ARRAYSIZE(szStreamName))))
{
static BOOL fBrowserOnly = (WhichPlatform() != PLATFORM_INTEGRATED);
TCHAR szKey[MAX_PATH];
TCHAR szGUID[MAX_PATH];
wnsprintf(szKey, ARRAYSIZE(szKey), TEXT("Software\Microsoft\Internet Explorer\Toolbar\%s"), szStreamName);
SHStringFromGUID(clsid, szGUID, ARRAYSIZE(szGUID));
if (ERROR_SUCCESS == SHGetValue(HKEY_CURRENT_USER, szKey, szGUID, NULL, NULL, NULL))
{
// Was the stream saved by an Integrated shell and we are in browser only mode?
if ((_cs.fSaveInShellIntegrationMode) && fBrowserOnly)
{
// Yes, so we need to ignore the stream.
}
else
{
IStream * pstm = GetRegStream(_fInitialPidlIsWeb, szGUID, STGM_READ);
if (pstm)
{
hr = _bs.LoadFromStreamBS(pstm, riid, ppiface);
pstm->Release();
}
}
}
}
if (FAILED(hr))
{
hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, riid, ppiface);
if (SUCCEEDED(hr))
{
IPersistStreamInit * ppsi;
((IUnknown *) *ppiface)->QueryInterface(IID_IPersistStreamInit, (void **) &ppsi);
if (ppsi)
{
ppsi->InitNew();
ppsi->Release();
}
}
}
return hr;
}
HRESULT CInternetToolbar::_ShowExternalBand( PBANDSAVE pbs, int idBand )
{
HRESULT hr;
if (IS_EXTERNALBAND(idBand))
{
int idBandExt = MAP_TO_EXTERNAL(idBand);
if (!IsEqualCLSID(_rgebi[idBandExt].clsid, GUID_NULL))
{
LPBANDITEMDATA pbid = _bs._GetBandItemDataStructByID( idBand );
BOOL fIsVisible = _nVisibleBands & EXTERNALBAND_VBF_BIT(idBandExt);
if (!pbid && fIsVisible)
{
IDeskBand *pitbBand;
hr = _GetPersistedBand(_rgebi[idBandExt].clsid, IID_IDeskBand, (void **) &pitbBand);
if (SUCCEEDED(hr))
{
pbid = _AddNewBand( pitbBand, idBand );
pitbBand->Release();
}
if (!pbid)
return E_OUTOFMEMORY;
} else {
pbs = NULL;
if (!pbid)
return S_OK;
}
_ShowBandCommon(pbs, pbid, fIsVisible );
}
}
return S_OK;
}
HRESULT CInternetToolbar::_ShowAddressBand(PBANDSAVE pbs)
{
HRESULT hr = S_OK;
LPBANDITEMDATA pbid = _bs._GetBandItemDataStructByID(CBIDX_ADDRESS);
if (!pbid)
{
IDeskBand *pitbAddressBand;
hr = _GetPersistedBand(CLSID_AddressBand, IID_IDeskBand, (void **)&pitbAddressBand);
if (SUCCEEDED(hr))
{
pbid = _AddNewBand(pitbAddressBand, CBIDX_ADDRESS);
if (pbid)
_hwndAddressBand = pbid->hwnd;
pitbAddressBand->Release();
}
ASSERT(IS_VALID_HANDLE(_hwndAddressBand, WND));
if (!pbid)
return E_OUTOFMEMORY;
} else
pbs = NULL;
_ShowBandCommon(pbs, pbid, _nVisibleBands & VBF_ADDRESS);
return S_OK;
}
LPBANDITEMDATA CInternetToolbar::_AddNewBand(IDeskBand* pdb, DWORD dwID)
{
if (SUCCEEDED(_bs._AddBandByID(pdb, dwID)))
{
return _bs._GetBandItemDataStructByID(dwID);
}
return NULL;
}
HRESULT CInternetToolbar::_ShowLinks(PBANDSAVE pbs)
{
HRESULT hr = S_OK;
LPBANDITEMDATA pbid = _bs._GetBandItemDataStructByID(CBIDX_LINKS);
if (!pbid)
{
IDeskBand* pdbLinks = NULL;
// Check if custom link band GUID is present in the registry,
// and if so, do a full CoCreateInstance using this GUID.
// Otherwise, just do the normal internal call to the link's band factory.
if (!_fInitialPidlIsWeb ||
FAILED(CreateFromRegKey(c_szRegKeyCoolbar, TEXT("QuickLinksCLSID"), IID_IDeskBand, (void **)&pdbLinks)))
{
hr = _GetPersistedBand(CLSID_QuickLinks, IID_IDeskBand, (void **)&pdbLinks);
IUnknown_Exec(pdbLinks, &CLSID_QuickLinks, QLCMD_SINGLELINE, 1, NULL, NULL);
}
if (pdbLinks)
{
// mark it so ISFBand knows it's qlinks (for UAssist)
VARIANTARG v;
#ifdef DEBUG
{
// n.b. we overwrite old persisted guys (which should be -1)
IUnknown_Exec(pdbLinks, &CGID_ISFBand, ISFBID_PRIVATEID, 0, NULL, &v);
ASSERT(v.lVal == -1 || v.lVal == CSIDL_FAVORITES);
}
#endif
v.vt = VT_I4;
v.lVal = CSIDL_FAVORITES; // close enough for our purposes...
IUnknown_Exec(pdbLinks, &CGID_ISFBand, ISFBID_PRIVATEID, 0, &v, NULL);
pbid = _AddNewBand(pdbLinks, CBIDX_LINKS);
pdbLinks->Release();
}
if (!pbid)
return E_OUTOFMEMORY;
} else
pbs = NULL;
_ShowBandCommon(pbs, pbid, _nVisibleBands & VBF_LINKS);
return hr;
}
HRESULT CInternetToolbar::_ShowMenu(PBANDSAVE pbs)
{
LPBANDITEMDATA pbid = _bs._GetBandItemDataStructByID(CBIDX_MENU);
if (!pbid)
{
CFavoritesCallback* pfcb = new CFavoritesCallback();
if (pfcb)
{
IShellMenu* psm = (IShellMenu*)new CMenuBand();
if (psm)
{
VARIANTARG var;
if (SUCCEEDED(IUnknown_Exec(_pbs2, &CGID_Explorer, SBCMDID_GETCURRENTMENU, 0, NULL, &var)) &&
var.vt == VT_INT_PTR && var.byref)
{
IDeskBand* pdbMenu;
psm->Initialize(pfcb, -1, ANCESTORDEFAULT, SMINIT_HORIZONTAL | SMINIT_TOPLEVEL);
if (SUCCEEDED(psm->SetMenu((HMENU)var.byref, GetParent(_hwnd), SMSET_DONTOWN)))
{
if (SUCCEEDED(psm->QueryInterface(IID_IDeskBand, (void**)&pdbMenu)))
{
pbid = _AddNewBand(pdbMenu, CBIDX_MENU);
if (pbid)
{
// Tell the menuband we're not a real bar/bandsite/band
IUnknown_Exec(pbid->pdb, &CGID_MenuBand, MBANDCID_NOTAREALSITE, TRUE, NULL, NULL);
_bs.SetBandState(CBIDX_MENU, BSSF_NOTITLE, BSSF_NOTITLE);
_hwndMenu = pbid->hwnd;
}
ASSERT(IS_VALID_HANDLE(_hwndMenu, WND));
pdbMenu->Release();
}
}
}
psm->Release();
}
pfcb->Release();
}
if (!pbid)
return E_OUTOFMEMORY;
} else
pbs = NULL;
_ShowBandCommon(pbs, pbid, _nVisibleBands & VBF_MENU);
return S_OK;
}
HRESULT _GetBackBitmapLocation(LPTSTR psz, BOOL fInternet)
{
HRESULT hres = E_FAIL;
DWORD dwType;
DWORD dwcbData;
// IE4 shipped back bitmap customization affecting both browser and shell.
// IE5 wants these to be separate customizations. But in the roaming
// case a customized IE4 customer shouldn't lose customization when going
// to the IE5 machine. So we might need to check twice:
//
if (fInternet)
{
// Try the IE5 internet location.
dwcbData = MAX_PATH * SIZEOF(TCHAR);
hres = SHGetValue(HKEY_CURRENT_USER, c_szRegKeyCoolbar, TEXT("BackBitmapIE5"), &dwType, psz, &dwcbData);
}
else
{
// Try the NT5 shell location.
dwcbData = MAX_PATH * SIZEOF(TCHAR);
hres = SHGetValue(HKEY_CURRENT_USER, c_szRegKeyCoolbar, TEXT("BackBitmapShell"), &dwType, psz, &dwcbData);
}
if (ERROR_SUCCESS != hres)
{
// Try the old combined internet/shell location
dwcbData = MAX_PATH * SIZEOF(TCHAR);
hres = SHGetValue(HKEY_CURRENT_USER, c_szRegKeyCoolbar, TEXT("BackBitmap"), &dwType, psz, &dwcbData);
}
if (ERROR_SUCCESS != hres)
{
*psz = '';
}
return hres;
}
HBITMAP CInternetToolbar::_LoadBackBmp(LPTSTR * ppszBitmap, BMPCACHE * pbmpCache, BOOL fInternet)
{
HIGHCONTRAST hc;
HBITMAP hbmp = pbmpCache->hbmp;
COLORREF cr3D = GetSysColor(COLOR_3DFACE);
TCHAR szScratch[MAX_PATH];
LPTSTR pszBitmap = NULL;
BOOL fBitmapInvalid = FALSE;
ENTERCRITICAL;
// If the stashed hbmp's cr3D color changed, we need to mark invalid
if (pbmpCache->hbmp && pbmpCache->cr3D != cr3D)
fBitmapInvalid = TRUE;
// get the location spec for the bitmap
hc.cbSize = sizeof(HIGHCONTRAST);
if ((SystemParametersInfoA(SPI_GETHIGHCONTRAST, hc.cbSize, (LPVOID) &hc, FALSE)) &&
(hc.dwFlags & HCF_HIGHCONTRASTON))
{
// we have no bitmap in high contrast
}
else if (SUCCEEDED(_GetBackBitmapLocation(szScratch, fInternet)))
{
pszBitmap = szScratch;
}
// if they are removing the bitmap, we need to mark invalid
if (!pszBitmap && *ppszBitmap)
fBitmapInvalid = TRUE;
// or it's location has been changed, we need to mark invalid
if (pszBitmap && (!*ppszBitmap || lstrcmpi(pszBitmap, *ppszBitmap)))
fBitmapInvalid = TRUE;
if (fBitmapInvalid)
{
TraceMsg(DM_ITBAR, "CInternetToolbar: Loading Background Bitmap");
Str_SetPtr(ppszBitmap, pszBitmap);
hbmp=NULL;
if (*ppszBitmap)
{
if ((*ppszBitmap)[0])
hbmp = (HBITMAP) LoadImage(NULL, szScratch, IMAGE_BITMAP, 0, 0, LR_DEFAULTSIZE | LR_CREATEDIBSECTION | LR_LOADFROMFILE | LR_LOADMAP3DCOLORS );
if (!hbmp)
{
#ifdef OLD_SWIRLY_BACKDROP
if (SHGetCurColorRes() <= 8)
hbmp = (HBITMAP) LoadImage(HINST_THISDLL, MAKEINTRESOURCE(IDB_BACK), IMAGE_BITMAP, 0, 0, LR_DEFAULTSIZE | LR_CREATEDIBSECTION | LR_LOADMAP3DCOLORS );
#endif
}
}
#ifdef OLD_LEGACY_BAD_COLOUR_CODE
if (hbmp)
{
// mapping needed ?
// BUGBUG: this will be removed as soon as I get the new backdrop....
if ( /* cr3D != RGB(192,192,192) */ FALSE)
{
RGBQUAD rgbTable[256];
RGBQUAD rgbFace;
HDC dc;
HBITMAP hbmSave;
UINT i;
UINT n;
dc = CreateCompatibleDC(NULL);
hbmSave = (HBITMAP)SelectObject(dc, hbmp);
n = GetDIBColorTable(dc, 0, 256, rgbTable);
rgbFace.rgbRed = GetRValue(cr3D);
rgbFace.rgbGreen = GetGValue(cr3D);
rgbFace.rgbBlue = GetBValue(cr3D);
for (i = 0; i < n; i++)
{
if ( rgbTable[i].rgbRed == 192 && rgbTable[i].rgbGreen == 192 && rgbTable[i].rgbBlue == 192 )
{
rgbTable[i] = rgbFace;
}
else
{
rgbTable[i].rgbRed = (rgbTable[i].rgbRed * rgbFace.rgbRed ) / 192;
rgbTable[i].rgbGreen = (rgbTable[i].rgbGreen * rgbFace.rgbGreen) / 192;
rgbTable[i].rgbBlue = (rgbTable[i].rgbBlue * rgbFace.rgbBlue ) / 192;
}
}
SetDIBColorTable(dc, 0, n, rgbTable);
SelectObject(dc, hbmSave);
DeleteDC(dc);
}
}
#endif
if (pbmpCache->hbmp)
DeleteObject(pbmpCache->hbmp);
pbmpCache->hbmp = hbmp;
pbmpCache->cr3D = cr3D;
}
LEAVECRITICAL;
return hbmp;
}
HBITMAP CInternetToolbar::_LoadBackBitmap()
{
if (SHIsLowMemoryMachine(ILMM_IE4))
return NULL;
if (_fInitialPidlIsWeb)
{
static LPTSTR s_pszBitmapInternet = NULL;
return _LoadBackBmp(&s_pszBitmapInternet, &s_bmpBackInternet, _fInitialPidlIsWeb);
}
else
{
static LPTSTR s_pszBitmapShell = NULL;
return _LoadBackBmp(&s_pszBitmapShell, &s_bmpBackShell, _fInitialPidlIsWeb);
}
}
void CInternetToolbar::_SetBackground()
{
REBARBANDINFO rbbi;
HBITMAP hbmp;
// Theater mode doesn't allow bitmap customization, so don't bother loading one from the cache
if (_fTheater)
hbmp = NULL;
else
hbmp = _LoadBackBitmap();
// don't bother updating the bkcolor if we know we'll just set it to CLR_NONE below (otherwise rebar invalidates)
if (!hbmp)
SendMessage(_bs._hwnd, RB_SETBKCOLOR, 0, (LPARAM)GetSysColor(COLOR_BTNFACE));
// If we think we have a bitmap, or the cache thinks we have a bitmap, we have some work to do
if (_bmpBack || hbmp)
{
BOOL fRemove = (NULL!=_bmpBack && NULL==hbmp);
if (hbmp)
SendMessage(_bs._hwnd, RB_SETBKCOLOR, 0, (LPARAM)CLR_NONE);
_bmpBack = hbmp;
rbbi.cbSize = sizeof(REBARBANDINFO);
INT_PTR fRedraw = SendMessage(_bs._hwnd, WM_SETREDRAW, FALSE, 0);
INT icBands = (INT) SendMessage( _bs._hwnd, RB_GETBANDCOUNT, 0, 0 );
for (int i = 0; i < icBands; i++)
{
rbbi.fMask = RBBIM_ID | RBBIM_CHILD | RBBIM_BACKGROUND;
if (SendMessage(_bs._hwnd, RB_GETBANDINFO, i, (LPARAM) &rbbi))
{
if (rbbi.wID != CBIDX_BRAND && rbbi.hbmBack != hbmp)
{
rbbi.fMask = RBBIM_BACKGROUND;
rbbi.hbmBack = hbmp;
SendMessage(_bs._hwnd, RB_SETBANDINFO, i, (LPARAM) &rbbi);
InvalidateRect(rbbi.hwndChild, NULL, TRUE);
}
}
}
SendMessage(_bs._hwnd, WM_SETREDRAW, fRedraw, 0);
// When removing the background bitmap, we need to invalidate *outside*
// of the WM_SETREDRAW so we actually erase the background properly
//
if (fRemove)
InvalidateRect(_bs._hwnd, NULL, TRUE);
}
}
HRESULT CInternetToolbar::_ShowBrand(PBANDSAVE pbs)
{
REBARBANDINFO rbbi;
LPBANDITEMDATA pbid;
INT_PTR i;
HRESULT hr = S_OK;
BOOL fCreated = FALSE;
pbid = _bs._GetBandItemDataStructByID(CBIDX_BRAND);
if (!pbid)
{
IDeskBand *pdbBrandBand;
hr = CBrandBand_CreateInstance(NULL, (IUnknown **)&pdbBrandBand, NULL);
if (SUCCEEDED(hr))
{
pbid = _AddNewBand(pdbBrandBand, CBIDX_BRAND);
fCreated = TRUE;
pdbBrandBand->Release();
}
else
return hr;
}
if (!pbid)
return E_OUTOFMEMORY;
pbid->pdb->ShowDW(TRUE);
i = BandIDtoIndex(_bs._hwnd, CBIDX_BRAND);
if (fCreated)
{
// add these to ::IDeskBand::GetBandInfo()
rbbi.cbSize = sizeof(REBARBANDINFO);
rbbi.fMask = RBBIM_STYLE;
rbbi.fStyle = RBBS_FIXEDSIZE | RBBS_VARIABLEHEIGHT;
if (pbs)
{
rbbi.fMask |= RBBIM_SIZE;
rbbi.fStyle |= pbs->fStyle;
rbbi.cx = pbs->cx;
}
SendMessage(_bs._hwnd, RB_SETBANDINFO, i, (LPARAM)&rbbi);
// this can cause the band to move because a fixed size band
// is forced in a particular location.
// so we need to re-fetch the index
i = BandIDtoIndex(_bs._hwnd, CBIDX_BRAND);
}
SendMessage(_bs._hwnd, RB_SHOWBAND, i, _nVisibleBands & VBF_BRAND);
return S_OK;
}
void CInternetToolbar::_EnsureAllBandsShown()
{
if (_hwnd) {
INT_PTR fRedraw = SendMessage(_bs._hwnd, WM_SETREDRAW, FALSE, 0);
_ShowMenu(NULL);
_ShowTools(NULL);
_ShowAddressBand(NULL);
_ShowLinks(NULL);
_ShowBrand(NULL);
for (int i = CBIDX_EXTERNALFIRST; i <= CBIDX_EXTERNALLAST; i++) {
_ShowExternalBand( NULL, i );
}
_SetBackground();
_bs._SetMinDimensions();
SendMessage(_bs._hwnd, WM_SETREDRAW, fRedraw, 0);
}
}
BOOL CInternetToolbar::_ShowBands(UINT fVisible)
{
fVisible &= VBF_VALID;
if (fVisible == _nVisibleBands)
return(TRUE);
_nVisibleBands = fVisible;
_EnsureAllBandsShown();
ShowDW(_fShow);
return(TRUE);
}
HRESULT CInternetToolbar::_CreateBands()
{
HRESULT hres = S_OK;
if (!_hwnd && _ptbsite)
{
HWND hwndParent;
hres= _ptbsite->GetWindow(&hwndParent);
if (SUCCEEDED(hres))
{
TCHAR szScratch[16];
int i;
// Check if coolbar layout had already been loaded from the registry
if(_cs.cbVer != CBS_VERSION)
{
TraceMsg(DM_ITBAR, "CInternetToolbar:ShowDW failed. Bad Version");
ASSERT(0);
return(S_FALSE);
}
_nVisibleBands = _cs.uiVisible;
_InitComCtl32(); // don't check result, if this fails our CreateWindows will fail
MLLoadString(IDS_WEB_TB_TEXTROWS, szScratch, ARRAYSIZE(szScratch));
_uiTBTextRows = _uiTBDefaultTextRows = StrToInt(szScratch);
_fCompressed = (_cs.fNoText != FALSE);
_hwnd = SHCreateWorkerWindow(SizableWndProc, hwndParent, 0, WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
(HMENU)FCIDM_REBAR, this);
if (!IS_VALID_HANDLE(_hwnd, WND))
{
TraceMsg(TF_ERROR, "_hwnd failed");
return E_OUTOFMEMORY;
}
// delay until now
// this sets up the parent child chain so that these children can
// queryservice through us
SetClient(SAFECAST(&_bs, IInputObjectSite*));