634 lines
25 KiB
C++
634 lines
25 KiB
C++
#include "stdafx.h"
|
|
#pragma hdrstop
|
|
|
|
// 98/10/02 vtan: Multiple monitor bug fixes.
|
|
|
|
// Given an old monitor layout, a new monitor layout and a component
|
|
// this function makes sure that it is in the new layout using a
|
|
// monitor relative scheme. It tries to preserve the position
|
|
// relatively within a given monitor. If the resolution of the monitor
|
|
// changes then this needs to be accounted for also.
|
|
|
|
// Preserve the component within a given monitor if the monitor is the
|
|
// same HMONITOR but the GDI co-ordinates change.
|
|
|
|
// If the same monitor cannot be located then move the component to the
|
|
// nearest monitor and position it as best on that monitor.
|
|
|
|
// If all else fails then use the default component positioning
|
|
// algorithm. This should never happen.
|
|
|
|
// Preserve the component within a given monitor if the resolution
|
|
// changes. Preserve the size of the component by MOVING the component
|
|
// in the X and Y axis until the left or the top of the monitor is
|
|
// reached. When either axis reaches 0 then reduce the size of the
|
|
// component until it fits within the given new resolution.
|
|
|
|
static const int kNameSize = 16;
|
|
|
|
typedef struct
|
|
{
|
|
HMONITOR miHMONITOR;
|
|
RECT miDisplayAreaRect,
|
|
miWorkAreaRect;
|
|
} tMonitorInfoRec, *tMonitorInfoPtr;
|
|
|
|
typedef struct
|
|
{
|
|
int miaCount, miaIndex;
|
|
RECT miaVirtualScreen;
|
|
tMonitorInfoRec miaMonitors[1];
|
|
} tMonitorInfoArrayRec, *tMonitorInfoArrayPtr;
|
|
|
|
typedef struct
|
|
{
|
|
bool ciValidData, ciVisible, ciRepositioned;
|
|
TCHAR ciName[kNameSize]; // this is not excessive but limited
|
|
DWORD ciItemState;
|
|
int ciType;
|
|
COMPPOS ciPosition;
|
|
COMPSTATEINFO ciStateInfo;
|
|
} tComponentInfoRec, *tComponentInfoPtr;
|
|
|
|
static tMonitorInfoArrayPtr gOldMonitorArray = NULL;
|
|
static tMonitorInfoArrayPtr gNewMonitorArray = NULL;
|
|
|
|
// Functions located in Dutil.cpp used for co-ordinate mapping.
|
|
|
|
void SetPt (POINT& pt, LONG x, LONG y);
|
|
void OffsetPt (POINT& pt, LONG dh, LONG dv);
|
|
void CalculateVirtualScreen (RECT& virtualScreen);
|
|
|
|
// Local function prototypes.
|
|
|
|
BOOL CALLBACK MonitorCountEnumProc (HMONITOR hMonitor, HDC dc, RECT *rc, LPARAM data);
|
|
BOOL CALLBACK MonitorCalculateEnumProc (HMONITOR hMonitor, HDC dc, RECT *rc, LPARAM data);
|
|
HRESULT CalculateCurrentMonitorArray(void);
|
|
void ApplyCurrentMonitorArray (void);
|
|
bool EqualMonitorArray (tMonitorInfoArrayPtr oldMonitorArray, tMonitorInfoArrayPtr newMonitorArray);
|
|
int IndexOfMonitor (tMonitorInfoArrayPtr pMIA, HMONITOR hMonitor);
|
|
int IndexOfMonitor (tMonitorInfoArrayPtr pMIA, POINT& pt);
|
|
int IndexOfMonitor (tMonitorInfoArrayPtr pMIA, RECT& rc);
|
|
bool RepositionDesktopRect (RECT& rcComponent, tMonitorInfoArrayPtr oldMonitorArray, tMonitorInfoArrayPtr newMonitorArray);
|
|
bool RepositionDesktopComponent (COMPPOS& componentPosition, COMPSTATEINFO& componentStateInfo, DWORD dwItemState);
|
|
bool ReadAllComponents (HKEY hKeyDesktop, tComponentInfoPtr& pComponentInfo, DWORD& dwComponentCount);
|
|
void WriteAllComponents (HKEY hKeyDesktop, tComponentInfoPtr pComponentInfo, DWORD dwComponentCount);
|
|
|
|
BOOL CALLBACK MonitorCountEnumProc (HMONITOR hMonitor, HDC dc, RECT *rc, LPARAM data)
|
|
|
|
// Count the number of monitors attached to the system.
|
|
|
|
{
|
|
int *iCounter;
|
|
|
|
iCounter = reinterpret_cast<int*>(data);
|
|
++(*iCounter);
|
|
return(TRUE);
|
|
}
|
|
|
|
BOOL CALLBACK MonitorCalculateEnumProc (HMONITOR hMonitor, HDC dc, RECT *rc, LPARAM data)
|
|
|
|
// Store each monitor HMONITOR and dimensions in the array.
|
|
|
|
{
|
|
tMonitorInfoArrayPtr monitorArray;
|
|
MONITORINFO monitorInfo;
|
|
|
|
monitorArray = reinterpret_cast<tMonitorInfoArrayPtr>(data);
|
|
monitorInfo.cbSize = sizeof(monitorInfo);
|
|
if (GetMonitorInfo(hMonitor, &monitorInfo) != 0)
|
|
{
|
|
tMonitorInfoPtr pMI;
|
|
|
|
pMI = &monitorArray->miaMonitors[monitorArray->miaIndex++];
|
|
pMI->miHMONITOR = hMonitor;
|
|
TBOOL(CopyRect(&pMI->miDisplayAreaRect, &monitorInfo.rcMonitor));
|
|
TBOOL(CopyRect(&pMI->miWorkAreaRect, &monitorInfo.rcWork));
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
HRESULT CalculateCurrentMonitorArray(void)
|
|
|
|
// Allocate and fill the monitor rectangle array.
|
|
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
int iCount;
|
|
|
|
iCount = 0;
|
|
TBOOL(EnumDisplayMonitors(NULL, NULL, MonitorCountEnumProc, reinterpret_cast<LPARAM>(&iCount)));
|
|
gNewMonitorArray = reinterpret_cast<tMonitorInfoArrayPtr>(LocalAlloc(LMEM_FIXED, sizeof(tMonitorInfoArrayRec) + ((iCount - 1) * sizeof(tMonitorInfoRec))));
|
|
|
|
if (gNewMonitorArray)
|
|
{
|
|
gNewMonitorArray->miaCount = iCount;
|
|
gNewMonitorArray->miaIndex = 0;
|
|
CalculateVirtualScreen(gNewMonitorArray->miaVirtualScreen);
|
|
TBOOL(EnumDisplayMonitors(NULL, NULL, MonitorCalculateEnumProc, reinterpret_cast<LPARAM>(gNewMonitorArray)));
|
|
|
|
hr = S_OK;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
void ApplyCurrentMonitorArray (void)
|
|
|
|
// Discard the old and save the new as current monitor
|
|
// rectangle array for the next time the function is called.
|
|
|
|
{
|
|
if (gOldMonitorArray != NULL)
|
|
(HLOCAL)LocalFree(gOldMonitorArray);
|
|
gOldMonitorArray = gNewMonitorArray;
|
|
gNewMonitorArray = NULL;
|
|
}
|
|
|
|
bool EqualMonitorArray (tMonitorInfoArrayPtr oldMonitorArray, tMonitorInfoArrayPtr newMonitorArray)
|
|
|
|
{
|
|
bool bResult;
|
|
|
|
if (oldMonitorArray->miaCount == newMonitorArray->miaCount)
|
|
{
|
|
int i, iLimit;
|
|
|
|
bResult = true;
|
|
for (i = 0, iLimit = oldMonitorArray->miaCount; bResult && (i < iLimit); ++i)
|
|
bResult &= (EqualRect(&oldMonitorArray->miaMonitors[i].miWorkAreaRect, &newMonitorArray->miaMonitors[i].miWorkAreaRect) != 0);
|
|
}
|
|
else
|
|
bResult = false;
|
|
return(bResult);
|
|
}
|
|
|
|
// These functions determine the index into the monitor
|
|
// rectangle array of a given HMONITOR, POINT or RECT.
|
|
|
|
int IndexOfMonitor (tMonitorInfoArrayPtr pMIA, HMONITOR hMonitor)
|
|
|
|
{
|
|
int i, iLimit, iResult;
|
|
tMonitorInfoPtr pMI;
|
|
|
|
iResult = -1;
|
|
for (i = 0, iLimit = pMIA->miaCount, pMI = pMIA->miaMonitors; i < iLimit; ++i, ++pMI)
|
|
{
|
|
if (pMI->miHMONITOR == hMonitor)
|
|
{
|
|
iResult = i;
|
|
break;
|
|
}
|
|
}
|
|
return(iResult);
|
|
}
|
|
|
|
// Note that the functions that take a POINT or RECT
|
|
// require the co-ordinates to be in TRIDENT co-ordinates.
|
|
|
|
int IndexOfMonitor (tMonitorInfoArrayPtr pMIA, POINT& pt)
|
|
|
|
{
|
|
int i, iLimit, iResult;
|
|
tMonitorInfoPtr pMI;
|
|
POINT ptLocal;
|
|
|
|
ptLocal = pt;
|
|
OffsetPt(ptLocal, +pMIA->miaVirtualScreen.left, +pMIA->miaVirtualScreen.top);
|
|
iResult = -1;
|
|
for (i = 0, iLimit = pMIA->miaCount, pMI = pMIA->miaMonitors; i < iLimit; ++i, ++pMI)
|
|
{
|
|
if (PtInRect(&pMI->miDisplayAreaRect, ptLocal) != 0)
|
|
{
|
|
iResult = i;
|
|
break;
|
|
}
|
|
}
|
|
return(iResult);
|
|
}
|
|
|
|
int IndexOfMonitor (tMonitorInfoArrayPtr pMIA, RECT& rc)
|
|
|
|
{
|
|
int iResult;
|
|
POINT pt;
|
|
|
|
// 99/05/12 #338446 vtan: Try all four corners of the rectangle
|
|
// to find a match.
|
|
|
|
pt.x = rc.left;
|
|
pt.y = rc.top;
|
|
iResult = IndexOfMonitor(pMIA, pt);
|
|
if (iResult < 0)
|
|
{
|
|
pt.x = rc.left;
|
|
pt.y = rc.bottom;
|
|
iResult = IndexOfMonitor(pMIA, pt);
|
|
if (iResult < 0)
|
|
{
|
|
pt.x = rc.right;
|
|
pt.y = rc.top;
|
|
iResult = IndexOfMonitor(pMIA, pt);
|
|
if (iResult < 0)
|
|
{
|
|
pt.x = rc.right;
|
|
pt.y = rc.bottom;
|
|
iResult = IndexOfMonitor(pMIA, pt);
|
|
}
|
|
}
|
|
}
|
|
return(iResult);
|
|
}
|
|
|
|
int IndexOfMonitor (tMonitorInfoArrayPtr pMIA, COMPPOS& componentPosition)
|
|
|
|
{
|
|
RECT rcComponent;
|
|
|
|
TBOOL(SetRect(&rcComponent, componentPosition.iLeft, componentPosition.iTop, componentPosition.iLeft + componentPosition.dwWidth, componentPosition.iTop + componentPosition.dwHeight));
|
|
return(IndexOfMonitor(pMIA, rcComponent));
|
|
}
|
|
|
|
bool RepositionDesktopRect (RECT& rcComponent, tMonitorInfoArrayPtr oldMonitorArray, tMonitorInfoArrayPtr newMonitorArray)
|
|
|
|
// Reposition the component's RECT based on the logic at the
|
|
// top of the source file. Used for both the component's
|
|
// current position and the restored position.
|
|
|
|
{
|
|
bool bRepositionedComponent;
|
|
int iOldMonitorIndex, iNewMonitorIndex;
|
|
|
|
// This is for future expansion. The components are always
|
|
// deemed to be repositioned if this function is called.
|
|
|
|
bRepositionedComponent = true;
|
|
|
|
// Find out if the monitor which the component was on is still
|
|
// present. To do this find the index of the component in the
|
|
// old monitor array, get the HMONITOR and find that in the new
|
|
// monitor array.
|
|
|
|
iOldMonitorIndex = IndexOfMonitor(oldMonitorArray, rcComponent);
|
|
if (iOldMonitorIndex >= 0)
|
|
{
|
|
RECT *prcOldMonitor, *prcNewMonitor;
|
|
|
|
iNewMonitorIndex = IndexOfMonitor(newMonitorArray, oldMonitorArray->miaMonitors[iOldMonitorIndex].miHMONITOR);
|
|
if (iNewMonitorIndex < 0)
|
|
{
|
|
HMONITOR hMonitor;
|
|
|
|
// The component is on a monitor that no longer exists. The only
|
|
// thing to do in this case is to find the nearest monitor based
|
|
// on the GDI co-ordinates and position it on that monitor.
|
|
|
|
hMonitor = MonitorFromRect(&rcComponent, MONITOR_DEFAULTTONEAREST);
|
|
iNewMonitorIndex = IndexOfMonitor(newMonitorArray, hMonitor);
|
|
ASSERT(iNewMonitorIndex >= 0);
|
|
}
|
|
|
|
// If iNewMonitorIndex was already positive then the monitor which
|
|
// the component was on still exists and simply mapping GDI
|
|
// co-ordinates will work. Otherwise we found the nearest monitor
|
|
// and mapping GDI co-ordinates also works!
|
|
|
|
// This maps from the component's OLD co-ordinates in trident
|
|
// co-ordinates to GDI co-ordinates. Then it maps from the GDI
|
|
// co-ordinates to an OLD monitor relative co-ordinate. Then it
|
|
// maps from the OLD monitor relative co-ordinates to the NEW
|
|
// monitor GDI co-ordinates.
|
|
|
|
prcOldMonitor = &oldMonitorArray->miaMonitors[iOldMonitorIndex].miDisplayAreaRect;
|
|
prcNewMonitor = &newMonitorArray->miaMonitors[iNewMonitorIndex].miDisplayAreaRect;
|
|
TBOOL(OffsetRect(&rcComponent, +oldMonitorArray->miaVirtualScreen.left, +oldMonitorArray->miaVirtualScreen.top));
|
|
TBOOL(OffsetRect(&rcComponent, -prcOldMonitor->left, -prcOldMonitor->top));
|
|
TBOOL(OffsetRect(&rcComponent, +prcNewMonitor->left, +prcNewMonitor->top));
|
|
}
|
|
else
|
|
{
|
|
|
|
// Component exists at an invalid location in the old monitor
|
|
// layout. It may be valid in the new layout. Try this. If that
|
|
// doesn't work then it doesn't exist in the old nor the new
|
|
// layout. It was in no-man's land. Position it using the default
|
|
// positioning system.
|
|
|
|
iNewMonitorIndex = IndexOfMonitor(newMonitorArray, rcComponent);
|
|
if (iNewMonitorIndex < 0)
|
|
{
|
|
POINT ptOrigin;
|
|
COMPPOS componentPosition;
|
|
|
|
GetNextComponentPosition(&componentPosition);
|
|
IncrementComponentsPositioned();
|
|
TBOOL(SetRect(&rcComponent, componentPosition.iLeft, componentPosition.iTop, componentPosition.iLeft + componentPosition.dwWidth, componentPosition.iTop + componentPosition.dwHeight));
|
|
|
|
// Get the primary monitor index in our monitor rectangle array.
|
|
|
|
SetPt(ptOrigin, 0, 0);
|
|
iNewMonitorIndex = IndexOfMonitor(newMonitorArray, MonitorFromPoint(ptOrigin, MONITOR_DEFAULTTOPRIMARY));
|
|
ASSERT(iNewMonitorIndex >= 0);
|
|
}
|
|
}
|
|
|
|
// At this stage the component position is in GDI co-ordinates.
|
|
// Convert from GDI co-ordinates back to trident co-ordinates.
|
|
|
|
TBOOL(OffsetRect(&rcComponent, -newMonitorArray->miaVirtualScreen.left, -newMonitorArray->miaVirtualScreen.top));
|
|
|
|
return(bRepositionedComponent);
|
|
}
|
|
|
|
bool RepositionDesktopComponent (COMPPOS& componentPosition, COMPSTATEINFO& componentStateInfo, DWORD dwItemState, int iComponentType)
|
|
|
|
{
|
|
bool bRepositionedComponent;
|
|
tMonitorInfoArrayPtr oldMonitorArray, newMonitorArray;
|
|
RECT rcComponent;
|
|
|
|
// Check if the monitor layout has changed. If unchanged then
|
|
// there is no need to move the components.
|
|
|
|
oldMonitorArray = gOldMonitorArray;
|
|
newMonitorArray = gNewMonitorArray;
|
|
if (oldMonitorArray == NULL)
|
|
{
|
|
oldMonitorArray = newMonitorArray;
|
|
}
|
|
|
|
TBOOL(SetRect(&rcComponent, componentPosition.iLeft, componentPosition.iTop, componentPosition.iLeft + componentPosition.dwWidth, componentPosition.iTop + componentPosition.dwHeight));
|
|
bRepositionedComponent = RepositionDesktopRect(rcComponent, oldMonitorArray, newMonitorArray);
|
|
componentPosition.iLeft = rcComponent.left;
|
|
componentPosition.iTop = rcComponent.top;
|
|
componentPosition.dwWidth = rcComponent.right - rcComponent.left;
|
|
componentPosition.dwHeight = rcComponent.bottom - rcComponent.top;
|
|
ValidateComponentPosition(&componentPosition, dwItemState, iComponentType, NULL, NULL);
|
|
|
|
// If the component is zoomed also reposition the restored
|
|
// COMPSTATEINFO.
|
|
|
|
if (IsZoomedState(dwItemState))
|
|
{
|
|
COMPPOS restoredCompPos;
|
|
|
|
TBOOL(SetRect(&rcComponent, componentStateInfo.iLeft, componentStateInfo.iTop, componentStateInfo.iLeft + componentStateInfo.dwWidth, componentStateInfo.iTop + componentStateInfo.dwHeight));
|
|
bRepositionedComponent = RepositionDesktopRect(rcComponent, oldMonitorArray, newMonitorArray) || bRepositionedComponent;
|
|
restoredCompPos.iLeft = componentStateInfo.iLeft = rcComponent.left;
|
|
restoredCompPos.iTop = componentStateInfo.iTop = rcComponent.top;
|
|
restoredCompPos.dwWidth = componentStateInfo.dwWidth = rcComponent.right - rcComponent.left;
|
|
restoredCompPos.dwHeight = componentStateInfo.dwHeight = rcComponent.bottom - rcComponent.top;
|
|
ZoomComponent(&componentPosition, dwItemState, FALSE);
|
|
restoredCompPos.dwSize = sizeof(restoredCompPos);
|
|
ValidateComponentPosition(&restoredCompPos, IS_NORMAL, iComponentType, NULL, NULL);
|
|
}
|
|
|
|
return(bRepositionedComponent);
|
|
}
|
|
|
|
bool ReadAllComponents (HKEY hKeyDesktop, tComponentInfoPtr& pComponentInfo, DWORD& dwComponentCount)
|
|
|
|
{
|
|
tComponentInfoPtr pCI;
|
|
|
|
if (RegQueryInfoKey(hKeyDesktop, NULL, NULL, NULL, &dwComponentCount, NULL, NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
|
|
dwComponentCount = 0;
|
|
if (dwComponentCount > 0)
|
|
{
|
|
|
|
// 99/08/09 #383184: STRESS fix. Allocate the whole block of
|
|
// memory required for the components but allocate one extra
|
|
// entry. advapi32!RegEnumKeyEx will try to access the memory
|
|
// before determining that there is a failure condition. With
|
|
// pageheap on (and the block allocated at the end of the page)
|
|
// this causes an access violation. The simplest fix is to add
|
|
// an extra entry.
|
|
|
|
pComponentInfo = pCI = reinterpret_cast<tComponentInfoPtr>(LocalAlloc(LPTR, (dwComponentCount + 1) * sizeof(*pCI))); // LMEM_FIXED | LMEM_ZEROINIT
|
|
if (pCI != NULL)
|
|
{
|
|
DWORD dwIndex, dwSize;
|
|
|
|
// Enumerate all the desktop components.
|
|
|
|
dwIndex = 0;
|
|
dwSize = sizeof(pCI->ciName);
|
|
while (RegEnumKeyEx(hKeyDesktop, dwIndex, pCI->ciName, &dwSize, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
|
|
{
|
|
CRegKey regKeyComponent;
|
|
|
|
if (regKeyComponent.Open(hKeyDesktop, pCI->ciName, KEY_READ | KEY_WRITE) == ERROR_SUCCESS)
|
|
{
|
|
DWORD dwType, cbData;
|
|
|
|
// Read the Position value.
|
|
|
|
cbData = sizeof(pCI->ciPosition);
|
|
if (SHQueryValueEx(regKeyComponent, REG_VAL_COMP_POSITION, NULL, &dwType, &pCI->ciPosition, &cbData) == ERROR_SUCCESS)
|
|
{
|
|
DWORD dwFlags;
|
|
|
|
pCI->ciValidData = true;
|
|
if (SHQueryValueEx(regKeyComponent, REG_VAL_COMP_FLAGS, NULL, &dwType, &dwFlags, &cbData) == ERROR_SUCCESS)
|
|
{
|
|
pCI->ciVisible = ((dwFlags & COMP_SELECTED) != 0);
|
|
pCI->ciType = (dwFlags & COMP_TYPE_MASK);
|
|
}
|
|
else
|
|
{
|
|
pCI->ciVisible = false;
|
|
pCI->ciType = COMP_TYPE_WEBSITE;
|
|
}
|
|
pCI->ciItemState = IS_NORMAL; // if missing (IE4 machine) or error the assume normal
|
|
cbData = sizeof(pCI->ciItemState);
|
|
if ((SHQueryValueEx(regKeyComponent, REG_VAL_COMP_CURSTATE, NULL, &dwType, &pCI->ciItemState, &cbData) == ERROR_SUCCESS))
|
|
{
|
|
|
|
// If the component is zoomed also read in the COMPSTATEINFO.
|
|
|
|
if (IsZoomedState(pCI->ciItemState))
|
|
{
|
|
cbData = sizeof(pCI->ciStateInfo);
|
|
TW32(SHQueryValueEx(regKeyComponent, REG_VAL_COMP_RESTOREDSTATEINFO, NULL, &dwType, &pCI->ciStateInfo, &cbData));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
++pCI;
|
|
++dwIndex;
|
|
dwSize = sizeof(pCI->ciName);
|
|
}
|
|
}
|
|
}
|
|
return((dwComponentCount != 0) && (pComponentInfo != NULL));
|
|
}
|
|
|
|
int IndexOfComponent (tComponentInfoPtr pComponentInfo, DWORD dwComponentCount, LPCTSTR pcszName)
|
|
|
|
{
|
|
int iResult, i;
|
|
|
|
for (iResult = -1, i = 0; (iResult < 0) && (i < static_cast<int>(dwComponentCount)); ++i)
|
|
{
|
|
if (lstrcmp(pComponentInfo[i].ciName, pcszName) == 0)
|
|
iResult = i;
|
|
}
|
|
return(iResult);
|
|
}
|
|
|
|
void WriteAllComponents (HKEY hKeyDesktop, tComponentInfoPtr pComponentInfo, DWORD dwComponentCount)
|
|
|
|
{
|
|
TCHAR szSubKeyName[kNameSize];
|
|
DWORD dwSubKeyIndex, dwSubKeySize;
|
|
|
|
// Enumerate all the desktop components.
|
|
|
|
dwSubKeyIndex = 0;
|
|
dwSubKeySize = ARRAYSIZE(szSubKeyName);
|
|
while (RegEnumKeyEx(hKeyDesktop, dwSubKeyIndex, szSubKeyName, &dwSubKeySize, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
|
|
{
|
|
CRegKey regKeyComponent;
|
|
|
|
if (regKeyComponent.Open(hKeyDesktop, szSubKeyName, KEY_READ | KEY_WRITE) == ERROR_SUCCESS)
|
|
{
|
|
int i;
|
|
|
|
i = IndexOfComponent(pComponentInfo, dwComponentCount, szSubKeyName);
|
|
if ((i >= 0) && pComponentInfo[i].ciRepositioned)
|
|
{
|
|
TW32(RegSetValueEx(regKeyComponent, REG_VAL_COMP_POSITION, 0, REG_BINARY, reinterpret_cast<const unsigned char*>(&pComponentInfo[i].ciPosition), sizeof(pComponentInfo[i].ciPosition)));
|
|
TW32(RegSetValueEx(regKeyComponent, REG_VAL_COMP_CURSTATE, NULL, REG_BINARY, reinterpret_cast<const unsigned char*>(&pComponentInfo[i].ciItemState), sizeof(pComponentInfo[i].ciItemState)));
|
|
|
|
// If the component is zoomed also write out the COMPSTATEINFO.
|
|
|
|
if (IsZoomedState(pComponentInfo[i].ciItemState))
|
|
{
|
|
TW32(RegSetValueEx(regKeyComponent, REG_VAL_COMP_RESTOREDSTATEINFO, 0, REG_BINARY, reinterpret_cast<const unsigned char*>(&pComponentInfo[i].ciStateInfo), sizeof(pComponentInfo[i].ciStateInfo)));
|
|
}
|
|
}
|
|
}
|
|
++dwSubKeyIndex;
|
|
dwSubKeySize = ARRAYSIZE(szSubKeyName);
|
|
}
|
|
}
|
|
|
|
BOOL AdjustDesktopComponents (LPCRECT arectNew,
|
|
int crectNew,
|
|
LPCRECT arectOldMonitors,
|
|
LPCRECT arectOld,
|
|
int crectOld)
|
|
|
|
{
|
|
static const int kMaximumMonitorCount = 16;
|
|
HRESULT hr;
|
|
bool bRepositionedComponent;
|
|
int zoomedComponentIndices[kMaximumMonitorCount]; // 16 monitors limitation here - make dynamic if required
|
|
int i;
|
|
tMonitorInfoArrayPtr oldMonitorArray;
|
|
CRegKey regKeyDesktop;
|
|
TCHAR lpszDeskcomp[MAX_PATH];
|
|
|
|
for (i = 0; i < kMaximumMonitorCount; ++i)
|
|
zoomedComponentIndices[i] = -1;
|
|
|
|
bRepositionedComponent = false;
|
|
hr = CalculateCurrentMonitorArray();
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
oldMonitorArray = gOldMonitorArray;
|
|
if (oldMonitorArray == NULL)
|
|
oldMonitorArray = gNewMonitorArray;
|
|
GetRegLocation(lpszDeskcomp, SIZECHARS(lpszDeskcomp), REG_DESKCOMP_COMPONENTS, NULL);
|
|
if (regKeyDesktop.Open(HKEY_CURRENT_USER, lpszDeskcomp, KEY_READ) == ERROR_SUCCESS)
|
|
{
|
|
DWORD dwComponentCount;
|
|
tComponentInfoPtr pComponentInfo;
|
|
|
|
// Enumerate all the desktop components.
|
|
|
|
if (ReadAllComponents(regKeyDesktop, pComponentInfo, dwComponentCount))
|
|
{
|
|
tComponentInfoPtr pCI;
|
|
|
|
for (pCI = pComponentInfo, i = 0; i < static_cast<int>(dwComponentCount); ++pCI, ++i)
|
|
{
|
|
int iPreviousMonitorIndexOfComponent;
|
|
|
|
// Calculate the previous monitor position BEFORE the component
|
|
// gets repositioned.
|
|
|
|
iPreviousMonitorIndexOfComponent = IndexOfMonitor(oldMonitorArray, pCI->ciPosition);
|
|
if (RepositionDesktopComponent(pCI->ciPosition, pCI->ciStateInfo, pCI->ciItemState, pCI->ciType))
|
|
{
|
|
int iCurrentMonitorIndexOfComponent;
|
|
|
|
pCI->ciRepositioned = bRepositionedComponent = true;
|
|
iCurrentMonitorIndexOfComponent = IndexOfMonitor(gNewMonitorArray, pCI->ciPosition);
|
|
if (iCurrentMonitorIndexOfComponent >= 0)
|
|
{
|
|
|
|
// 99/05/12 #338446 vtan: Only use a zero or positive index into the
|
|
// monitor array. -1 is invalid and will cause an AV. This should NEVER
|
|
// happen but rather than assert this condition is handled.
|
|
|
|
if (IsZoomedState(pCI->ciItemState) && (zoomedComponentIndices[iCurrentMonitorIndexOfComponent] >= 0))
|
|
{
|
|
tComponentInfoPtr pCIToRestore;
|
|
|
|
// This component is zoomed on a monitor that already has a zoomed
|
|
// component. Compare this component and the component already on the
|
|
// monitor. The one that was there before is the one that stays. The one
|
|
// that shouldn't be there is the one that gets restored.
|
|
|
|
if ((iPreviousMonitorIndexOfComponent == iCurrentMonitorIndexOfComponent) && pCI->ciVisible)
|
|
pCIToRestore = pComponentInfo + zoomedComponentIndices[iCurrentMonitorIndexOfComponent];
|
|
else
|
|
pCIToRestore = pCI;
|
|
pCIToRestore->ciPosition.iLeft = pCIToRestore->ciStateInfo.iLeft;
|
|
pCIToRestore->ciPosition.iTop = pCIToRestore->ciStateInfo.iTop;
|
|
pCIToRestore->ciPosition.dwWidth = pCIToRestore->ciStateInfo.dwWidth;
|
|
pCIToRestore->ciPosition.dwHeight = pCIToRestore->ciStateInfo.dwHeight;
|
|
pCIToRestore->ciPosition.izIndex = COMPONENT_TOP;
|
|
pCIToRestore->ciItemState = IS_NORMAL;
|
|
}
|
|
|
|
// If the component is zoomed also write out the COMPSTATEINFO.
|
|
|
|
if (IsZoomedState(pCI->ciItemState))
|
|
{
|
|
zoomedComponentIndices[iCurrentMonitorIndexOfComponent] = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
WriteAllComponents(regKeyDesktop, pComponentInfo, dwComponentCount);
|
|
LocalFree(pComponentInfo);
|
|
}
|
|
|
|
if (bRepositionedComponent)
|
|
{
|
|
SHELLSTATE ss;
|
|
|
|
SetDesktopFlags(COMPONENTS_DIRTY, COMPONENTS_DIRTY);
|
|
SHGetSetSettings(&ss, SSF_DESKTOPHTML, FALSE);
|
|
|
|
// Refresh only if AD is turned on.
|
|
|
|
if(ss.fDesktopHTML)
|
|
{
|
|
|
|
// 98/09/22 #182982 vtan: Use dynamic HTML by default to refresh.
|
|
// Only disallow usage when specifically told to by a flag.
|
|
|
|
PokeWebViewDesktop(AD_APPLY_FORCE | AD_APPLY_HTMLGEN | AD_APPLY_REFRESH);
|
|
}
|
|
}
|
|
}
|
|
ApplyCurrentMonitorArray();
|
|
}
|
|
|
|
return bRepositionedComponent;
|
|
}
|