1214 lines
35 KiB
C++
1214 lines
35 KiB
C++
// Start.cpp : DirectUI
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
|
|
#ifdef FEATURE_STARTPAGE
|
|
|
|
#include <lmcons.h> // for UNLEN
|
|
#include <shlapip.h>
|
|
#include <DUserCtrl.h>
|
|
|
|
#include "pidlbutton.h"
|
|
|
|
#include "ProgList.h"
|
|
#include "hostutil.h"
|
|
|
|
#include "..\rcids.h"
|
|
|
|
using namespace DirectUI;
|
|
|
|
// Using ALL controls
|
|
UsingDUIClass(Element);
|
|
UsingDUIClass(HWNDElement);
|
|
|
|
UsingDUIClass(Button);
|
|
UsingDUIClass(Edit);
|
|
UsingDUIClass(Progress);
|
|
UsingDUIClass(RefPointElement);
|
|
UsingDUIClass(RepeatButton);
|
|
UsingDUIClass(ScrollBar);
|
|
UsingDUIClass(ScrollViewer);
|
|
UsingDUIClass(Selector);
|
|
UsingDUIClass(Thumb);
|
|
UsingDUIClass(Viewer);
|
|
|
|
|
|
EXTERN_C void Tray_OnStartMenuDismissed();
|
|
EXTERN_C void Tray_OnStartPageDismissed();
|
|
EXTERN_C void Tray_MenuInvoke(int idCmd);
|
|
EXTERN_C void Tray_SetStartPaneActive(BOOL fActive);
|
|
EXTERN_C void Tray_DoProperties(DWORD nStartPage);
|
|
|
|
HBITMAP GetBitmapForIDList(IShellFolder *psf, LPCITEMIDLIST pidlLast, UINT cx, UINT cy)
|
|
{
|
|
HBITMAP hBitmap = NULL;
|
|
IExtractImage *pei;
|
|
HRESULT hr = psf->GetUIObjectOf(NULL, 1, &pidlLast, IID_PPV_ARG_NULL(IExtractImage, &pei));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
DWORD dwPriority;
|
|
DWORD dwFlags = IEIFLAG_SCREEN | IEIFLAG_OFFLINE;
|
|
SIZEL rgSize = {cx, cy};
|
|
|
|
WCHAR szBufferW[MAX_PATH];
|
|
hr = pei->GetLocation(szBufferW, ARRAYSIZE(szBufferW), &dwPriority, &rgSize, SHGetCurColorRes(), &dwFlags);
|
|
if (S_OK == hr)
|
|
{
|
|
hr = pei->Extract(&hBitmap);
|
|
}
|
|
}
|
|
return hBitmap;
|
|
}
|
|
|
|
|
|
HBITMAP GetBitmapForFile(LPCITEMIDLIST pidl, LPWSTR pszFile, UINT cx, UINT cy)
|
|
{
|
|
HBITMAP hbmp = NULL;
|
|
if (pidl)
|
|
{
|
|
IShellFolder *psf;
|
|
HRESULT hr = SHBindToObjectEx(NULL, pidl, NULL, IID_PPV_ARG(IShellFolder, &psf));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPITEMIDLIST pidlChild;
|
|
hr = psf->ParseDisplayName(NULL, NULL, pszFile, NULL, &pidlChild, NULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hbmp = GetBitmapForIDList(psf, pidlChild, cx, cy);
|
|
ILFree(pidlChild);
|
|
}
|
|
psf->Release();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LPITEMIDLIST pidlFull = ILCreateFromPath(pszFile);
|
|
if (pidlFull)
|
|
{
|
|
IShellFolder *psf;
|
|
LPCITEMIDLIST pidlChild;
|
|
HRESULT hr = SHBindToParent(pidlFull, IID_PPV_ARG(IShellFolder, &psf), &pidlChild);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hbmp = GetBitmapForIDList(psf, pidlChild, cx, cy);
|
|
psf->Release();
|
|
}
|
|
|
|
ILFree(pidlFull);
|
|
}
|
|
}
|
|
return hbmp;
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////
|
|
// StartFrame
|
|
////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////
|
|
// Frame declaration
|
|
|
|
class StartFrame : public HWNDElement, public ByUsageDUI
|
|
{
|
|
public:
|
|
static HRESULT Create(OUT Element** ppElement);
|
|
static HRESULT Create(HWND hwnd, HINSTANCE hInst, OUT Element** ppElement);
|
|
|
|
virtual void OnInput(InputEvent* pie);
|
|
virtual void OnEvent(Event* pEvent);
|
|
virtual LRESULT WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
virtual void OnKeyFocusMoved(Element* peFrom, Element* peTo);
|
|
|
|
|
|
HRESULT Populate();
|
|
|
|
static void CALLBACK ParseError(LPCWSTR pszError, LPCWSTR pszToken, int dLine);
|
|
static int CALLBACK _SortItemsAfterEnum(PaneItem *p1, PaneItem *p2, ByUsage *pbu);
|
|
|
|
// ByUsageDUI
|
|
virtual BOOL AddItem(PaneItem *pitem, IShellFolder *psf, LPCITEMIDLIST pidlChild);
|
|
virtual BOOL RegisterNotify(UINT id, LONG lEvents, LPITEMIDLIST pidl, BOOL fRecursive);
|
|
virtual BOOL UnregisterNotify(UINT id);
|
|
virtual HRESULT Register();
|
|
|
|
|
|
enum {TIMER_RECENT, TIMER_PROGRAMS, TIMER_ANIMATE};
|
|
StartFrame();
|
|
|
|
protected:
|
|
virtual ~StartFrame();
|
|
HRESULT Initialize(HWND hwnd) { return HWNDElement::Initialize(hwnd, true /* false */, 0); }
|
|
|
|
IShellFolder *GetRecentFilesFolder(LPITEMIDLIST *ppidl);
|
|
HRESULT InvokePidl(LPITEMIDLIST pidl);
|
|
|
|
LRESULT _OnMenuMessage(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
LRESULT _OnSetMenuForward(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
LRESULT _OnDestroy(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
LRESULT _OnChangeNotify(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
LRESULT _OnTimer(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
LRESULT _OnSize(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
LRESULT _OnActivate(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
void OnChangeNotify(UINT id, LONG lEvent, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2);
|
|
|
|
private:
|
|
|
|
BOOL _IsShortcutToFolder(IShellFolder *psf, LPCITEMIDLIST pidl);
|
|
HRESULT _PopulateSpecialFolders();
|
|
HRESULT _PopulateRecentDocuments();
|
|
HRESULT _PopulateRecentPrograms();
|
|
HRESULT _PopulatePictures();
|
|
|
|
HRESULT _SetPicture(Element *pe);
|
|
|
|
|
|
HINSTANCE _hInstance;
|
|
|
|
LPITEMIDLIST _pidlBrowser;
|
|
LPITEMIDLIST _pidlEmail;
|
|
LPITEMIDLIST _pidlSearch;
|
|
|
|
Element * _peAnimating;
|
|
int _iAnimationColor;
|
|
//
|
|
// Context menu handling
|
|
//
|
|
PIDLButton * _pPidlButtonPop; /* has currently popped-up context menu */
|
|
|
|
// Handler for the recent programs list
|
|
ByUsage * _pByUsage;
|
|
//
|
|
// _dpaEnum is the DPA of enumerated items, sorted in the
|
|
// _SortItemsAfterEnum sense, which prepares them for _RepopulateList.
|
|
// When _dpaEnum is destroyed, its pointers must be delete'd.
|
|
//
|
|
CDPA<PaneItem> _dpaEnum;
|
|
|
|
enum { DUI_MAXNOTIFY = 5 };
|
|
ULONG _rguChangeNotify[DUI_MAXNOTIFY];
|
|
|
|
enum { IDCN_LASTMOD = DUI_MAXNOTIFY -1 };
|
|
|
|
/* Outstanding change notification (if any) */
|
|
enum {
|
|
SPM_CHANGENOTIFY = WM_USER + 2, // WM_USER+1 is already being used by the pidl gadgets, WM_USER is used by DirectUI
|
|
SPM_SET_THUMBNAIL = SPM_CHANGENOTIFY + DUI_MAXNOTIFY
|
|
};
|
|
|
|
enum { SPM_ACTIVATE = WM_USER + 107 }; // Bad HACK to get activation loss info
|
|
|
|
static WCHAR _szParseError[];
|
|
static int _dParseError;
|
|
|
|
int _iMaxShow; // How many items we should show in the recent lists
|
|
|
|
public:
|
|
// ClassInfo accessors (static and virtual instance-based)
|
|
static IClassInfo* Class;
|
|
virtual IClassInfo* GetClassInfo() { return Class; }
|
|
};
|
|
|
|
////////////////////////////////////////////////////////
|
|
// Frame construction
|
|
StartFrame::StartFrame()
|
|
{
|
|
_pidlBrowser = ILCreateFromPath(TEXT("shell:::{2559a1f4-21d7-11d4-bdaf-00c04f60b9f0}"));
|
|
_pidlEmail = ILCreateFromPath(TEXT("shell:::{2559a1f5-21d7-11d4-bdaf-00c04f60b9f0}"));
|
|
_pidlSearch = ILCreateFromPath(TEXT("shell:::{2559a1f0-21d7-11d4-bdaf-00c04f60b9f0}"));
|
|
}
|
|
|
|
StartFrame::~StartFrame()
|
|
{
|
|
ILFree(_pidlBrowser);
|
|
ILFree(_pidlEmail);
|
|
ILFree(_pidlSearch);
|
|
}
|
|
|
|
HRESULT StartFrame::Create(OUT Element** ppElement)
|
|
{
|
|
UNREFERENCED_PARAMETER(ppElement);
|
|
DUIAssertForce("Cannot instantiate an HWND host derived Element via parser. Must use substitution.");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT StartFrame::Create(HWND hwnd, HINSTANCE hInst, OUT Element** ppElement)
|
|
{
|
|
*ppElement = NULL;
|
|
|
|
StartFrame* ppf = HNew<StartFrame>();
|
|
if (!ppf)
|
|
return E_OUTOFMEMORY;
|
|
|
|
HRESULT hr = ppf->Initialize(hwnd);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = ppf->SetActive(AE_MouseAndKeyboard);
|
|
ppf->_hInstance = hInst;
|
|
|
|
*ppElement = ppf;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT AddPidlToList(LPITEMIDLIST pidl, Element *peList, BOOL fInsert)
|
|
{
|
|
Element *pPidlButton;
|
|
HRESULT hr = PIDLButton::Create(pidl, &pPidlButton);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (fInsert)
|
|
hr = peList->Insert(pPidlButton, 0);
|
|
else
|
|
hr = peList->Add(pPidlButton);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
pPidlButton->Destroy();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ILFree(pidl);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT InsertCSIDLIntoList(int csidl, Element *peList)
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
HRESULT hr = SHGetFolderLocation(NULL, csidl, NULL, 0, &pidl);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = AddPidlToList(pidl, peList, TRUE); // Insert
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
BOOL StartFrame::AddItem(PaneItem *pitem, IShellFolder *psf, LPCITEMIDLIST pidlChild)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
if (_dpaEnum.AppendPtr(pitem) < 0)
|
|
{
|
|
fRet = FALSE;
|
|
delete pitem;
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
BOOL StartFrame::_IsShortcutToFolder(IShellFolder *psf, LPCITEMIDLIST pidl)
|
|
{
|
|
BOOL fRc = FALSE; // assume not
|
|
IShellLink *psl;
|
|
HRESULT hr;
|
|
|
|
hr = psf->GetUIObjectOf(GetHWND(), 1, &pidl, IID_PPV_ARG_NULL(IShellLink, &psl));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPITEMIDLIST pidlTarget;
|
|
if (SUCCEEDED(psl->GetIDList(&pidlTarget)))
|
|
{
|
|
DWORD dwAttr = SFGAO_FOLDER | SFGAO_BROWSABLE;
|
|
if (SUCCEEDED(SHGetAttributesOf(pidlTarget, &dwAttr)))
|
|
{
|
|
fRc = dwAttr & SFGAO_FOLDER;
|
|
}
|
|
ILFree(pidlTarget);
|
|
}
|
|
psl->Release();
|
|
}
|
|
return fRc;
|
|
}
|
|
|
|
IShellFolder *StartFrame::GetRecentFilesFolder(LPITEMIDLIST *ppidl)
|
|
{
|
|
HRESULT hr;
|
|
IShellFolder *psf = NULL;
|
|
|
|
hr = SHGetSpecialFolderLocation(GetHWND(), CSIDL_RECENT, ppidl);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SHBindToObjectEx(NULL, *ppidl, NULL, IID_PPV_ARG(IShellFolder, &psf));
|
|
if (FAILED(hr))
|
|
{
|
|
ILFree(*ppidl);
|
|
*ppidl = NULL;
|
|
}
|
|
}
|
|
return psf;
|
|
}
|
|
|
|
|
|
HRESULT StartFrame::_PopulateSpecialFolders()
|
|
{
|
|
Element *peList;
|
|
peList = FindDescendent(StrToID(L"DocList"));
|
|
if (peList)
|
|
{
|
|
PIDLButton::SetImageSize(SHGFI_LARGEICON);
|
|
InsertCSIDLIntoList(CSIDL_BITBUCKET, peList);
|
|
InsertCSIDLIntoList(CSIDL_NETWORK, peList);
|
|
InsertCSIDLIntoList(CSIDL_MYMUSIC, peList);
|
|
InsertCSIDLIntoList(CSIDL_MYPICTURES, peList);
|
|
InsertCSIDLIntoList(CSIDL_PERSONAL, peList);
|
|
}
|
|
|
|
peList = FindDescendent(StrToID(L"SystemDocList"));
|
|
if (peList)
|
|
{
|
|
LPITEMIDLIST pidlHelp = ILCreateFromPath(TEXT("shell:::{2559a1f1-21d7-11d4-bdaf-00c04f60b9f0}")); // Help and support
|
|
if (pidlHelp)
|
|
AddPidlToList(pidlHelp, peList, TRUE); // Insert
|
|
|
|
InsertCSIDLIntoList(CSIDL_CONTROLS, peList);
|
|
InsertCSIDLIntoList(CSIDL_DRIVES, peList);
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT StartFrame::_PopulateRecentDocuments()
|
|
{
|
|
Selector *peList;
|
|
|
|
peList = (Selector*)FindDescendent(StrToID(L"Documents"));
|
|
if (peList)
|
|
{
|
|
PIDLButton::SetImageSize(SHGFI_LARGEICON);
|
|
peList->DestroyAll();
|
|
|
|
IEnumIDList *peidl;
|
|
LPITEMIDLIST pidlRoot;
|
|
|
|
IShellFolder *psfRecentFiles = GetRecentFilesFolder(&pidlRoot);
|
|
|
|
// The CSIDL_RECENT folder is magic: The items are enumerated
|
|
// out of it in MRU order!
|
|
|
|
if (psfRecentFiles)
|
|
{
|
|
if (SUCCEEDED(psfRecentFiles->EnumObjects(GetHWND(), SHCONTF_NONFOLDERS, &peidl)))
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
int cAdded = 0;
|
|
|
|
while (cAdded < _iMaxShow && peidl->Next(1, &pidl, NULL) == S_OK)
|
|
{
|
|
// Filter out shortcuts to folders
|
|
if (!_IsShortcutToFolder(psfRecentFiles, pidl))
|
|
{
|
|
LPITEMIDLIST pidlFull = ILCombine(pidlRoot, pidl);
|
|
if (pidlFull)
|
|
{
|
|
// AddPidlToList takes ownership of the pidl
|
|
AddPidlToList(pidlFull, peList, FALSE);
|
|
cAdded++;
|
|
}
|
|
}
|
|
ILFree(pidl);
|
|
}
|
|
peidl->Release();
|
|
}
|
|
RegisterNotify(IDCN_LASTMOD, SHCNE_DISKEVENTS | SHCNE_UPDATEIMAGE, pidlRoot, FALSE);
|
|
ILFree(pidlRoot);
|
|
psfRecentFiles->Release();
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
int CALLBACK StartFrame::_SortItemsAfterEnum(PaneItem *p1, PaneItem *p2, ByUsage *pbu)
|
|
{
|
|
//
|
|
// Put all pinned items (sorted by pin position) ahead of unpinned items.
|
|
//
|
|
if (p1->IsPinned())
|
|
{
|
|
if (p2->IsPinned())
|
|
{
|
|
return p1->GetPinPos() - p2->GetPinPos();
|
|
}
|
|
return -1;
|
|
}
|
|
else if (p2->IsPinned())
|
|
{
|
|
return +1;
|
|
}
|
|
|
|
//
|
|
// Both unpinned - let the client decide.
|
|
//
|
|
return pbu->CompareItems(p1, p2);
|
|
}
|
|
|
|
HRESULT StartFrame::_PopulateRecentPrograms()
|
|
{
|
|
Element *peList;
|
|
|
|
peList = FindDescendent(StrToID(L"Programs"));
|
|
if (peList)
|
|
{
|
|
PIDLButton::SetImageSize(SHGFI_LARGEICON);
|
|
|
|
peList->DestroyAll();
|
|
|
|
if (!_pByUsage)
|
|
{
|
|
_pByUsage = new ByUsage(NULL, static_cast<ByUsageDUI *>(this));
|
|
if (_pByUsage)
|
|
{
|
|
IPropertyBag *pbag;
|
|
if(SUCCEEDED(CreatePropBagFromReg(TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\StartPage\\Normal\\W32Control1"), &pbag)))
|
|
{
|
|
if (SUCCEEDED(_pByUsage->Initialize()) && _dpaEnum.Create(4))
|
|
{
|
|
}
|
|
else
|
|
{
|
|
delete _pByUsage;
|
|
_pByUsage = NULL;
|
|
}
|
|
|
|
pbag->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (_pByUsage)
|
|
{
|
|
_pByUsage->EnumItems();
|
|
_dpaEnum.SortEx(_SortItemsAfterEnum, _pByUsage);
|
|
|
|
int iPos; // the slot we are trying to fill
|
|
int iEnum; // the item index we will fill it from
|
|
PaneItem *pitem; // the item that will fill it
|
|
|
|
// Note that the loop control must be a _dpaEnum.GetPtr(), not a
|
|
// _dpaEnum.FastGetPtr(), because iEnum can go past the end of the
|
|
// array if we do't have _iMaxShow items in the first place.
|
|
//
|
|
|
|
for (iPos = iEnum = 0;
|
|
iEnum < _iMaxShow && (pitem = _dpaEnum.GetPtr(iEnum)) != NULL;
|
|
iEnum++)
|
|
{
|
|
LPITEMIDLIST pidl = _pByUsage->GetFullPidl(pitem);
|
|
if (pidl)
|
|
{
|
|
AddPidlToList(pidl, peList, FALSE);
|
|
}
|
|
}
|
|
|
|
// Clear out the DPA
|
|
|
|
_dpaEnum.EnumCallbackEx(PaneItem::DPAEnumCallback, (LPVOID)NULL);
|
|
_dpaEnum.DeleteAllPtrs();
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
LPWSTR GetStrPictureFromID(int nImageID)
|
|
{
|
|
LPWSTR pszPic = NULL;
|
|
switch (nImageID)
|
|
{
|
|
case 1: pszPic = L"Picture1";
|
|
break;
|
|
case 2: pszPic = L"Picture2";
|
|
break;
|
|
case 3: pszPic = L"Picture3";
|
|
break;
|
|
}
|
|
return pszPic;
|
|
}
|
|
|
|
BOOL IsValidExtension(LPWSTR pszPath)
|
|
{
|
|
if (pszPath)
|
|
{
|
|
WCHAR *pszExt = PathFindExtension(pszPath);
|
|
if (pszExt && (lstrcmpi(pszExt, TEXT(".bmp")) == 0 || lstrcmpi(pszExt, TEXT(".jpg")) == 0 ||
|
|
lstrcmpi(pszExt, TEXT(".jpeg")) == 0))
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
HRESULT StartFrame::_PopulatePictures()
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
HRESULT hr = SHGetFolderLocation(NULL, CSIDL_MYPICTURES, NULL, 0, &pidl);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WCHAR szPath[MAX_PATH];
|
|
hr = SHGetPathFromIDList(pidl, szPath);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WIN32_FIND_DATA fd;
|
|
HKEY hkey = NULL;
|
|
RegOpenKey(HKEY_CURRENT_USER, TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\StartPage"), &hkey);
|
|
|
|
StrCatBuff(szPath, TEXT("\\*"), ARRAYSIZE(szPath));
|
|
|
|
int nImageID = 1;
|
|
HANDLE hFind = FindFirstFile(szPath, &fd);
|
|
while (nImageID <= 3)
|
|
{
|
|
LPWSTR pszPic = GetStrPictureFromID(nImageID);
|
|
LPWSTR pszPathToImage = NULL;
|
|
LPITEMIDLIST pidlFolder = NULL;
|
|
if (hkey)
|
|
{
|
|
DWORD dwType;
|
|
DWORD cb = sizeof(szPath);
|
|
if (RegQueryValueEx(hkey, pszPic, NULL, &dwType, (LPBYTE)szPath, &cb) == ERROR_SUCCESS
|
|
&& dwType == REG_SZ && PathFileExists(szPath) && IsValidExtension(szPath))
|
|
pszPathToImage = szPath;
|
|
}
|
|
|
|
while (!pszPathToImage && hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
pidlFolder = pidl;
|
|
pszPathToImage = fd.cFileName;
|
|
|
|
if (!FindNextFile(hFind, &fd))
|
|
{
|
|
FindClose(hFind);
|
|
hFind = INVALID_HANDLE_VALUE;
|
|
}
|
|
// Skip the stupid sample
|
|
if (lstrcmpi(pszPathToImage, TEXT("sample.jpg")) == 0 || !IsValidExtension(pszPathToImage))
|
|
pszPathToImage = NULL;
|
|
}
|
|
|
|
if (pszPathToImage)
|
|
{
|
|
HBITMAP hbmp = GetBitmapForFile(pidlFolder, pszPathToImage, 150, 113);
|
|
if (hbmp)
|
|
{
|
|
Element *pe = FindDescendent(StrToID(pszPic));
|
|
if (pe)
|
|
{
|
|
Value *pvalIcon = Value::CreateGraphic(hbmp);
|
|
if (pvalIcon)
|
|
{
|
|
pe->SetValue(ContentProp, PI_Local, pvalIcon);
|
|
pvalIcon->Release();
|
|
}
|
|
else
|
|
{
|
|
DeleteObject(hbmp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
nImageID++;
|
|
}
|
|
if (hFind != INVALID_HANDLE_VALUE)
|
|
FindClose(hFind);
|
|
if (hkey)
|
|
RegCloseKey(hkey);
|
|
}
|
|
}
|
|
ILFree(pidl);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT StartFrame::_SetPicture(Element *pe)
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
HRESULT hr = SHGetFolderLocation(NULL, CSIDL_MYPICTURES, NULL, 0, &pidl);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WCHAR szPath[MAX_PATH];
|
|
hr = SHGetPathFromIDList(pidl, szPath);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
OPENFILENAME ofn; // common dialog box structure
|
|
WCHAR szFile[MAX_PATH]; // buffer for file name
|
|
|
|
*szFile = L'\0';
|
|
|
|
// Initialize OPENFILENAME
|
|
ZeroMemory(&ofn, sizeof(OPENFILENAME));
|
|
ofn.lStructSize = sizeof(OPENFILENAME);
|
|
ofn.hwndOwner = GetHWND();
|
|
ofn.lpstrFile = szFile;
|
|
ofn.nMaxFile = sizeof(szFile);
|
|
ofn.lpstrFilter = TEXT("Pictures\0*.JPG;*.JPEG;*.BMP\0");
|
|
ofn.nFilterIndex = 1;
|
|
ofn.lpstrFileTitle = NULL;
|
|
ofn.nMaxFileTitle = 0;
|
|
ofn.lpstrInitialDir = szPath;
|
|
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_DONTADDTORECENT;
|
|
|
|
// Display the Open dialog box.
|
|
|
|
if (GetOpenFileName(&ofn)==TRUE)
|
|
{
|
|
WCHAR *pszExt = PathFindExtension(ofn.lpstrFile);
|
|
if (pszExt && (lstrcmpi(pszExt, TEXT(".bmp")) == 0 || lstrcmpi(pszExt, TEXT(".jpg")) == 0 ||
|
|
lstrcmpi(pszExt, TEXT(".jpg")) == 0))
|
|
{
|
|
HBITMAP hbmp = GetBitmapForFile(NULL, ofn.lpstrFile, 150, 113);
|
|
if (hbmp)
|
|
{
|
|
Value *pvalIcon = Value::CreateGraphic(hbmp);
|
|
if (pvalIcon)
|
|
{
|
|
pe->SetValue(ContentProp, PI_Local, pvalIcon);
|
|
pvalIcon->Release();
|
|
HKEY hkey = NULL;
|
|
RegOpenKey(HKEY_CURRENT_USER, TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\StartPage"), &hkey);
|
|
if (hkey)
|
|
{
|
|
LPWSTR pszPic;
|
|
for (int i=1; i<=3; i++)
|
|
{
|
|
pszPic = GetStrPictureFromID(i);
|
|
if (FindDescendent(StrToID(pszPic)) == pe)
|
|
break;
|
|
pszPic = NULL;
|
|
}
|
|
if (pszPic)
|
|
RegSetValueEx(hkey, pszPic, NULL, REG_SZ, (LPBYTE)ofn.lpstrFile, (lstrlen(ofn.lpstrFile)+1) * sizeof(TCHAR));
|
|
RegCloseKey(hkey);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
DeleteObject(hbmp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT StartFrame::Populate()
|
|
{
|
|
Element *pe = FindDescendent(StrToID(L"name"));
|
|
|
|
if (pe)
|
|
{
|
|
WCHAR szUserName[UNLEN + 1];
|
|
ULONG uLen = ARRAYSIZE(szUserName);
|
|
*szUserName = _T('\0');
|
|
SHGetUserDisplayName(szUserName, &uLen);
|
|
pe->SetContentString(szUserName);
|
|
}
|
|
|
|
pe = FindDescendent(StrToID(L"UserPicture"));
|
|
if (pe)
|
|
{
|
|
TCHAR szUserPicturePath[MAX_PATH];
|
|
if (SUCCEEDED(SHGetUserPicturePath(NULL, SHGUPP_FLAG_CREATE, szUserPicturePath)))
|
|
{
|
|
HBITMAP hbmUserPicture = (HBITMAP)LoadImage(NULL, szUserPicturePath, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
|
|
if (hbmUserPicture)
|
|
{
|
|
Value *pvalIcon = Value::CreateGraphic(hbmUserPicture);
|
|
if (pvalIcon)
|
|
{
|
|
pe->SetValue(ContentProp, PI_Local, pvalIcon);
|
|
pvalIcon->Release();
|
|
}
|
|
else
|
|
{
|
|
DeleteObject(hbmUserPicture);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
_PopulatePictures();
|
|
|
|
_PopulateSpecialFolders();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
void StartFrame::OnChangeNotify(UINT id, LONG lEvent, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
|
|
{
|
|
if (id == IDCN_LASTMOD) // Change in last documents
|
|
{
|
|
UnregisterNotify(id);
|
|
KillTimer(GetHWND(), TIMER_RECENT);
|
|
SetTimer(GetHWND(), TIMER_RECENT, 2000, NULL);
|
|
}
|
|
else
|
|
{
|
|
ASSERT(_pByUsage);
|
|
if(_pByUsage)
|
|
{
|
|
_pByUsage->GetMenuCache()->OnChangeNotify(id, lEvent, pidl1, pidl2);
|
|
KillTimer(GetHWND(), TIMER_PROGRAMS);
|
|
SetTimer(GetHWND(), TIMER_PROGRAMS, 10 * 1000, NULL);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
LRESULT StartFrame::_OnTimer(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if (wParam == TIMER_RECENT)
|
|
{
|
|
KillTimer(hwnd, wParam);
|
|
StartDefer();
|
|
_PopulateRecentDocuments();
|
|
EndDefer();
|
|
}
|
|
else if (wParam == TIMER_PROGRAMS)
|
|
{
|
|
KillTimer(hwnd, wParam);
|
|
StartDefer();
|
|
_PopulateRecentPrograms();
|
|
EndDefer();
|
|
SetTimer(GetHWND(), TIMER_PROGRAMS, 1 * 60 * 1000, NULL); // 1 minute
|
|
}
|
|
else if (wParam == TIMER_ANIMATE)
|
|
{
|
|
if (_iAnimationColor & 1)
|
|
{
|
|
_iAnimationColor += 16;
|
|
if (_iAnimationColor == 255)
|
|
KillTimer(hwnd, wParam);
|
|
}
|
|
else
|
|
{
|
|
if (_iAnimationColor > 16)
|
|
_iAnimationColor -= 16;
|
|
else
|
|
_iAnimationColor = 15;
|
|
}
|
|
_peAnimating->SetForegroundColor(RGB(_iAnimationColor, _iAnimationColor, (3*_iAnimationColor + 255) /4));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
BOOL StartFrame::RegisterNotify(UINT id, LONG lEvents, LPITEMIDLIST pidl, BOOL fRecursive)
|
|
{
|
|
ASSERT(id < DUI_MAXNOTIFY);
|
|
|
|
if (id < DUI_MAXNOTIFY)
|
|
{
|
|
UnregisterNotify(id);
|
|
|
|
SHChangeNotifyEntry fsne;
|
|
fsne.fRecursive = fRecursive;
|
|
fsne.pidl = pidl;
|
|
|
|
int fSources = SHCNRF_NewDelivery | SHCNRF_ShellLevel | SHCNRF_InterruptLevel;
|
|
_rguChangeNotify[id] = SHChangeNotifyRegister(GetHWND(), fSources, lEvents,
|
|
SPM_CHANGENOTIFY + id, 1, &fsne);
|
|
return _rguChangeNotify[id];
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL StartFrame::UnregisterNotify(UINT id)
|
|
{
|
|
ASSERT(id < DUI_MAXNOTIFY);
|
|
|
|
if (id < DUI_MAXNOTIFY && _rguChangeNotify[id])
|
|
{
|
|
UINT uChangeNotify = _rguChangeNotify[id];
|
|
_rguChangeNotify[id] = 0;
|
|
return SHChangeNotifyDeregister(uChangeNotify);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////
|
|
// System events
|
|
|
|
void StartFrame::OnInput(InputEvent* pie)
|
|
{
|
|
HWNDElement::OnInput(pie);
|
|
}
|
|
|
|
void StartFrame::OnEvent(Event* pEvent)
|
|
{
|
|
if (pEvent->nStage == GMF_BUBBLED)
|
|
{
|
|
if (pEvent->uidType == Button::Click)
|
|
{
|
|
if (pEvent->peTarget->GetID() == StrToID(L"email"))
|
|
{
|
|
InvokePidl(_pidlEmail);
|
|
}
|
|
else if (pEvent->peTarget->GetID() == StrToID(L"internet"))
|
|
{
|
|
InvokePidl(_pidlBrowser);
|
|
}
|
|
else if (pEvent->peTarget->GetID() == StrToID(L"search"))
|
|
{
|
|
InvokePidl(_pidlSearch);
|
|
}
|
|
else if (pEvent->peTarget->GetID() == StrToID(L"MorePrograms"))
|
|
{
|
|
LPITEMIDLIST pidl = ILCreateFromPath(TEXT("shell:::{7be9d83c-a729-4d97-b5a7-1b7313c39e0a}"));
|
|
if (pidl)
|
|
{
|
|
InvokePidl(pidl);
|
|
ILFree(pidl);
|
|
}
|
|
}
|
|
else if (pEvent->peTarget->GetID() == StrToID(L"MoreDocuments"))
|
|
{
|
|
LPITEMIDLIST pidl = ILCreateFromPath(TEXT("shell:::{9387ae38-d19b-4de5-baf5-1f7767a1cf04}"));
|
|
if (pidl)
|
|
{
|
|
InvokePidl(pidl);
|
|
ILFree(pidl);
|
|
}
|
|
}
|
|
else if (pEvent->peTarget->GetID() == StrToID(L"turnoff"))
|
|
{
|
|
Tray_MenuInvoke(IDM_EXITWIN);
|
|
}
|
|
else if (pEvent->peTarget->GetID() == StrToID(L"logoff"))
|
|
{
|
|
Tray_MenuInvoke(IDM_LOGOFF);
|
|
}
|
|
else
|
|
{
|
|
HMENU hmenu = LoadMenu(_hInstance, MAKEINTRESOURCE(IDM_PICTMENU));
|
|
if (hmenu)
|
|
{
|
|
HMENU hMenuTrack = GetSubMenu(hmenu, 0);
|
|
ButtonClickEvent *peButton = reinterpret_cast<ButtonClickEvent *>(pEvent);
|
|
|
|
if (peButton->pt.x == -1) // Keyboard context menu
|
|
{
|
|
Value *pv;
|
|
const SIZE *psize = pEvent->peTarget->GetExtent(&pv);
|
|
peButton->pt.x = psize->cx/2;
|
|
peButton->pt.y = psize->cy/2;
|
|
pv->Release();
|
|
}
|
|
POINT pt;
|
|
MapElementPoint(pEvent->peTarget, &peButton->pt, &pt);
|
|
ClientToScreen(GetHWND(), &pt);
|
|
|
|
int idCmd = TrackPopupMenuEx(hMenuTrack, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTALIGN, pt.x, pt.y, GetHWND(), NULL);
|
|
|
|
DestroyMenu(hmenu);
|
|
|
|
if (idCmd == ID_CMD_CHANGE_PICTURE)
|
|
{
|
|
_SetPicture(pEvent->peTarget);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
HWNDElement::OnEvent(pEvent);
|
|
}
|
|
|
|
HRESULT StartFrame::InvokePidl(LPITEMIDLIST pidl)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
IShellFolder *psf;
|
|
LPCITEMIDLIST pidlShort;
|
|
// Multi-level child pidl
|
|
if (SUCCEEDED(SHBindToFolderIDListParent(NULL, pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlShort)))
|
|
{
|
|
hr = SHInvokeDefaultCommand(GetHWND(), psf, pidlShort);
|
|
psf->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
WCHAR StartFrame::_szParseError[201];
|
|
int StartFrame::_dParseError;
|
|
|
|
void StartFrame::ParseError(LPCWSTR pszError, LPCWSTR pszToken, int dLine)
|
|
{
|
|
if (dLine != -1)
|
|
swprintf(_szParseError, L"%s '%s' at line %d", pszError, pszToken, dLine);
|
|
else
|
|
swprintf(_szParseError, L"%s '%s'", pszError, pszToken);
|
|
|
|
_dParseError = dLine;
|
|
}
|
|
|
|
LRESULT StartFrame::_OnSetMenuForward(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
_pPidlButtonPop = (PIDLButton *)lParam;
|
|
return 0;
|
|
}
|
|
|
|
LRESULT StartFrame::_OnMenuMessage(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if (_pPidlButtonPop)
|
|
return _pPidlButtonPop->OnMenuMessage(hwnd, uMsg, wParam, lParam);
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT StartFrame::_OnChangeNotify(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LPITEMIDLIST *ppidl;
|
|
LONG lEvent;
|
|
LPSHChangeNotificationLock pshcnl;
|
|
pshcnl = SHChangeNotification_Lock((HANDLE)wParam, (DWORD)lParam, &ppidl, &lEvent);
|
|
|
|
if (pshcnl)
|
|
{
|
|
OnChangeNotify(uMsg - SPM_CHANGENOTIFY, lEvent, ppidl[0], ppidl[1]);
|
|
SHChangeNotification_Unlock(pshcnl);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
LRESULT StartFrame::_OnDestroy(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
UINT id;
|
|
for (id = 0; id < DUI_MAXNOTIFY; id++)
|
|
{
|
|
UnregisterNotify(id);
|
|
}
|
|
|
|
delete _pByUsage;
|
|
_pByUsage = NULL;
|
|
|
|
#if 0 // REVIEW fabriced
|
|
if (_hwndList)
|
|
{
|
|
RevokeDragDrop(_hwndList);
|
|
}
|
|
if (_psched)
|
|
{
|
|
_psched->RemoveTasks(TOID_SFTBarHostBackgroundEnum, (DWORD_PTR)this, FALSE);
|
|
}
|
|
#endif
|
|
|
|
return HWNDElement::WndProc(hwnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
LRESULT StartFrame::_OnActivate(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if (WA_ACTIVE == LOWORD(wParam))
|
|
{
|
|
// Run a little animation when we come up
|
|
_peAnimating = FindDescendent(StrToID(L"name"));
|
|
_iAnimationColor = 64;
|
|
SetTimer(GetHWND(), TIMER_ANIMATE, 20, NULL);
|
|
}
|
|
// If we are loosing focus, reset the start button.
|
|
else if (WA_INACTIVE == LOWORD(wParam))
|
|
{
|
|
if (_peAnimating)
|
|
_peAnimating->SetForegroundColor(RGB(255, 255, 255));
|
|
|
|
KillTimer(GetHWND(), TIMER_ANIMATE);
|
|
Tray_SetStartPaneActive(FALSE);
|
|
Tray_OnStartPageDismissed();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT StartFrame::_OnSize(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
Element::StartDefer();
|
|
SetWidth(LOWORD(lParam));
|
|
SetHeight(HIWORD(lParam));
|
|
if (HIWORD(lParam) < 590)
|
|
{
|
|
_iMaxShow = 7;
|
|
Element *pe = FindDescendent(StrToID(L"CurveZone"));
|
|
if (pe)
|
|
pe->SetPadding(0, 0, 0, 74);
|
|
pe = FindDescendent(StrToID(L"LogoffZone"));
|
|
if (pe)
|
|
pe->SetPadding(50, 0, 50, 10);
|
|
}
|
|
else if (HIWORD(lParam) < 700)
|
|
{
|
|
_iMaxShow = 7;
|
|
Element *pe = FindDescendent(StrToID(L"CurveZone"));
|
|
if (pe)
|
|
pe->SetPadding(0, 0, 0, 105);
|
|
pe = FindDescendent(StrToID(L"LogoffZone"));
|
|
if (pe)
|
|
pe->SetPadding(50, 0, 50, 41);
|
|
}
|
|
else if (HIWORD(lParam) < 760)
|
|
{
|
|
_iMaxShow = 10;
|
|
Element *pe = FindDescendent(StrToID(L"CurveZone"));
|
|
if (pe)
|
|
pe->SetPadding(0, 0, 0, 74);
|
|
pe = FindDescendent(StrToID(L"LogoffZone"));
|
|
if (pe)
|
|
pe->SetPadding(50, 0, 50, 10);
|
|
}
|
|
else
|
|
{
|
|
_iMaxShow = 10;
|
|
Element *pe = FindDescendent(StrToID(L"CurveZone"));
|
|
if (pe)
|
|
pe->SetPadding(0, 0, 0, 105);
|
|
pe = FindDescendent(StrToID(L"LogoffZone"));
|
|
if (pe)
|
|
pe->SetPadding(50, 0, 50, 41);
|
|
}
|
|
|
|
_PopulateRecentDocuments();
|
|
_PopulateRecentPrograms();
|
|
|
|
Element::EndDefer();
|
|
return 0;
|
|
}
|
|
|
|
void StartFrame::OnKeyFocusMoved(Element* peFrom, Element* peTo)
|
|
{
|
|
}
|
|
|
|
LRESULT StartFrame::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
#define HANDLE_SF_MESSAGE(wm, fn) case wm: return fn(hWnd, uMsg, wParam, lParam)
|
|
|
|
if (SPM_CHANGENOTIFY <= uMsg && uMsg < SPM_CHANGENOTIFY + DUI_MAXNOTIFY)
|
|
return _OnChangeNotify(hWnd, uMsg, wParam, lParam);
|
|
|
|
switch (uMsg)
|
|
{
|
|
HANDLE_SF_MESSAGE(WM_DESTROY, _OnDestroy);
|
|
HANDLE_SF_MESSAGE(WM_TIMER, _OnTimer);
|
|
HANDLE_SF_MESSAGE(WM_SIZE, _OnSize);
|
|
HANDLE_SF_MESSAGE(SPM_ACTIVATE, _OnActivate);
|
|
|
|
// Context menus handlers
|
|
HANDLE_SF_MESSAGE(WM_INITMENUPOPUP,_OnMenuMessage);
|
|
HANDLE_SF_MESSAGE(WM_DRAWITEM, _OnMenuMessage);
|
|
HANDLE_SF_MESSAGE(WM_MENUCHAR, _OnMenuMessage);
|
|
HANDLE_SF_MESSAGE(WM_MEASUREITEM, _OnMenuMessage);
|
|
HANDLE_SF_MESSAGE(PIDLButton::PBM_SETMENUFORWARD, _OnSetMenuForward);
|
|
}
|
|
|
|
return HWNDElement::WndProc(hWnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////
|
|
// ClassInfo (must appear after property definitions)
|
|
|
|
// Define class info with type and base type, set static class pointer
|
|
|
|
IClassInfo* StartFrame::Class = NULL;
|
|
HRESULT StartFrame::Register()
|
|
{
|
|
return ClassInfo<StartFrame,HWNDElement>::Register(L"StartFrame", NULL, 0);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////
|
|
// Parser
|
|
////////////////////////////////////////////////////////
|
|
|
|
void CALLBACK ParseError(LPCWSTR pszError, LPCWSTR pszToken, int dLine)
|
|
{
|
|
WCHAR buf[201];
|
|
|
|
if (dLine != -1)
|
|
swprintf(buf, L"%s '%s' at line %d", pszError, pszToken, dLine);
|
|
else
|
|
swprintf(buf, L"%s '%s'", pszError, pszToken);
|
|
|
|
MessageBoxW(NULL, buf, L"Parser Message", MB_OK);
|
|
}
|
|
|
|
|
|
// Privates from Shell32.
|
|
STDAPI_(HWND) SetPeekMsgEx(FARPROC fp, HANDLE hDesktop);
|
|
STDAPI_(BOOL) SetStartPageHWND(HANDLE hDesktop, HWND hwnd);
|
|
|
|
typedef HWND (*SetPeek)(FARPROC fp, HANDLE hDesktop);
|
|
|
|
/////////////////////////////////////
|
|
// Creation of the Start Page
|
|
void CreateStartPage(HINSTANCE hInstance, HANDLE hDesktop)
|
|
{
|
|
HWND hwndParent = NULL;
|
|
|
|
CoInitialize(NULL);
|
|
// DirectUI init thread in caller
|
|
InitThread();
|
|
|
|
hwndParent = SetPeekMsgEx((FARPROC)PeekMessageEx, hDesktop);
|
|
|
|
Element::StartDefer();
|
|
|
|
// HWND Root
|
|
StartFrame* psf;
|
|
HRESULT hr = StartFrame::Create(hwndParent, hInstance, (Element**)&psf);
|
|
if (FAILED(hr))
|
|
return;
|
|
|
|
// Fill content of frame (using substitution)
|
|
Parser* pParser;
|
|
Parser::Create(IDR_STARTUI, hInstance, ParseError, &pParser);
|
|
if (!pParser)
|
|
return;
|
|
|
|
if (pParser->WasParseError())
|
|
{
|
|
ASSERTMSG(FALSE, "Parse error!");
|
|
pParser->Destroy();
|
|
return;
|
|
}
|
|
|
|
Element* pe;
|
|
pParser->CreateElement(L"main", psf, &pe);
|
|
|
|
// Done with parser
|
|
pParser->Destroy();
|
|
|
|
// Disable Drag-drop for now.
|
|
BuildDropTarget( psf->GetDisplayNode(), psf->GetHWND());
|
|
|
|
psf->Populate();
|
|
// Set visible and host
|
|
psf->SetVisible(true);
|
|
|
|
RECT rect;
|
|
GetWindowRect(hwndParent, &rect);
|
|
|
|
psf->SetWidth(RECTWIDTH(rect));
|
|
psf->SetHeight(RECTHEIGHT(rect));
|
|
|
|
Element::EndDefer();
|
|
|
|
SetStartPageHWND(hDesktop, psf->GetHWND());
|
|
|
|
SetTimer(psf->GetHWND(), StartFrame::TIMER_PROGRAMS, 1 * 60 * 1000, NULL); // 1 minute
|
|
|
|
HWND hwndDesktop = GetParent(GetParent(hwndParent));
|
|
|
|
ShowWindow(hwndDesktop, SW_SHOW);
|
|
UpdateWindow(hwndDesktop);
|
|
|
|
return;
|
|
}
|
|
|
|
#endif // FEATURE_STARTPAGE
|