Category

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

Windows Kernel

Development Platform:

Visual C++

multimon.cpp：Code Content
  1. /**************************************************************************
  2.  * Module Name: multimon.cpp
  3.  *
  4.  * Contains all the code to manage multiple devices
  5.  *
  6.  * Copyright (c) Microsoft Corp.  1995-1996 All Rights Reserved
  7.  *
  8.  * NOTES:
  9.  *
  10.  * History: Create by toddla -- multimon.c
  11.  *          Changed to C++ by dli -- multimon.cpp on 7/10/1997
  12.  *
  13.  **************************************************************************/
  16. #include "precomp.h"
  17. #include "shlobjp.h"
  18. #include "shlwapi.h"
  20. #define COMPILE_MULTIMON_STUBS
  21. #include "multimon.h"
  22. #include "device.hxx"
  23. #include "settings.hxx"
  25. extern "C" {
  26.     LONG CALLBACK MonitorWindowProc(HWND hwnd, UINT msg,WPARAM wParam,LPARAM lParam);
  27.     extern BOOL g_bGradient;  // from lookdlg.c
  28. }
  30. #define MONITORS_MAX    10
  32. #define PREVIEWAREARATIO 2
  34. #ifdef WINNT
  35. // Global configuration variables 
  36. ULONG gUnattenedConfigureAtLogon = 0;
  37. ULONG gUnattenedInstall = 0;
  38. ULONG gUnattenedBitsPerPel = 0;
  39. ULONG gUnattenedXResolution = 0;
  40. ULONG gUnattenedYResolution = 0;
  41. ULONG gUnattenedVRefresh = 0;
  42. ULONG gUnattenedFlags = 0;
  43. ULONG gUnattenedAutoConfirm = 0;
  44. #endif
  46. static const TCHAR sc_szVideo[] = TEXT("Video");
  47. static const TCHAR sc_szOptimize[] = TEXT("Optimize");
  48. static const TCHAR sc_szQtwIni[] = TEXT("qtw.ini");
  49. static const TCHAR sc_szVGA[] = TEXT("Standard VGA");
  50. //
  51. // display devices
  52. //
  53. typedef struct _multimon_device {
  54.     ULONG          ComboBoxItem;
  55.     BOOL           bRepositionable;
  56.     DISPLAY_DEVICE DisplayDevice;
  57.     DEVMODE        DisplaySetting;
  58.     ULONG          DisplayIndex;
  59.     TCHAR          DisplayRegKey[128];
  60.     CDeviceSettings * pds;
  61.     int            w,h;
  62.     HIMAGELIST     himl;
  63.     int            iImage;
  64.     POINT          Snap;
  65.     HDC            hdc;
  66. } MULTIMON_DEVICE, *PMULTIMON_DEVICE;
  68. extern HWND ghwndPropSheet;
  69. extern int AskDynaCDS(HWND hDlg);
  70. extern BOOL WarnUserAboutCompatibility(HWND hDlg);
  72. //-----------------------------------------------------------------------------
  73. static const DWORD sc_MultiMonitorHelpIds[] =
  74. {
  75.    IDC_DISPLAYDESK,   IDH_SETTINGS_DISPLAYDESK, 
  76.    IDC_DISPLAYLIST,   IDH_SETTINGS_DISPLAYLIST, 
  77.    IDC_COLORBOX,      IDH_SETTINGS_COLORBOX,
  78.    IDC_SCREENSIZE,    IDH_SETTINGS_SCREENSIZE,
  79.    IDC_DISPLAYUSEME,  IDH_SETTINGS_DISPLAYUSEME, 
  80.    IDC_DISPLAYPROPERTIES, IDH_SETTINGS_DISPLAYPROPERTIES, 
  81.    0, 0
  82. };
  84. class CMultiMon  : public IMultiMonConfig
  85. {
  86.     private:
  87.         // Data Section
  88.         MULTIMON_DEVICE _Devices[MONITORS_MAX];
  89.         PMULTIMON_DEVICE _pCurDevice;
  90.         PMULTIMON_DEVICE _pPrimaryDevice;
  92.         // HWND for the main window
  93.         HWND _hDlg;
  94.         HWND _hwndDesk;
  95.         HWND _hwndList;
  96.         
  97.         // union of all monitor RECTs
  98.         RECT _rcDesk;
  100.         // ref count 
  101.         UINT _cRef;
  102.         
  103.         // how to translate to preview size
  104.         int   _DeskScale;
  105.         POINT _DeskOff;
  106.         UINT  _InSetInfo;
  107.         int   _NumDevices;
  108.         HBITMAP _hbmScrSample;
  109.         HBITMAP _hbmMonitor;
  110.         HIMAGELIST _himl;
  111.         
  112.         BOOL _bBadDriver         : 1;
  113.         BOOL _bNewDriver         : 1;
  114.         BOOL _bNoAttach          : 1;
  115.         BOOL _bDirty             : 1;
  116.         
  117.         // Private functions 
  118.         void _DeskToPreview(LPRECT in, LPRECT out);
  119.         void _OffsetPreviewToDesk(LPRECT in, LPRECT out);
  120.         BOOL _AnyColorChange();
  121.         BOOL _AnyResolutionChange();
  122.         BOOL _QueryForceSmallFont();
  123.         void _SetPreviewScreenSize(int HRes, int VRes, int iOrgXRes, int iOrgYRes);
  124.         void _CleanupRects(HWND hwndP);
  125.         BOOL _WriteMultiMonProfile(); 
  126.         void _SetReposition(HWND hwnd, PMULTIMON_DEVICE pDevice);
  127.         void _DoAdvancedSettingsSheet();
  128.         void _VerifyPrimaryMode(BOOL fKeepMode);
  130.         BOOL _HandleApply();
  131.         BOOL _HandleHScroll(HWND hwndSB, int iCode, int iPos); 
  132.         void _RedrawDeskPreviews();
  133.         void _ForwardToChildren(UINT msg, WPARAM wParam, LPARAM lParam);
  135.         BOOL _InitDisplaySettings(BOOL bExport);
  136.         void _DestroyDisplaySettings();
  138.         int  _GetMinColorBits();
  139.         void _GetDisplayName(PMULTIMON_DEVICE pDevice, LPTSTR pszDisplay);
  140.         int  _SaveDisplaySettings(DWORD dwSet);
  141.         void _RestoreDisplaySettings();
  142.         void _ConfirmDisplaySettingsChange();
  143.         BOOL _TestNewSettingsChange();
  144.         BOOL _RebuildDisplaySettings(BOOL bComplete = FALSE);
  145.         // NT specific stuff
  146. #ifdef WINNT
  147.         BOOL _InitMessage();
  148.         void _vPreExecMode();
  149.         void _vPostExecMode();
  150. #endif
  151.     public:
  152.         CMultiMon();
  154.         static BOOL RegisterPreviewWindowClass(WNDPROC pfnWndProc);
  155.         // *** IUnknown methods *** 
  156.         STDMETHODIMP QueryInterface(REFIID riid, LPVOID * ppvObj);
  157.         STDMETHODIMP_(ULONG) AddRef(void);
  158.         STDMETHODIMP_(ULONG) Release(void);    
  160.         // *** IMultiMonConfig methods ***
  161.         STDMETHOD ( Initialize ) ( HWND hwndHost, WNDPROC pfnWndProc, DWORD dwReserved);
  162.         STDMETHOD ( GetNumberOfMonitors ) (int * pCMon, DWORD dwReserved);
  163.         STDMETHOD ( GetMonitorData) (int iMonitor, MonitorData * pmd, DWORD dwReserved);
  164.         STDMETHOD ( Paint) (THIS_ int iMonitor, DWORD dwReserved);     
  166.         void InitMultiMonitorDlg(HWND hDlg);
  167.         PMULTIMON_DEVICE GetCurDevice(){return _pCurDevice;};
  168.         
  169.         int  GetNumberOfAttachedDisplays();
  170.         BOOL ToggleAttached(PMULTIMON_DEVICE pDevice, BOOL bPrime);
  171.         void UpdateActiveDisplay(PMULTIMON_DEVICE pDevice);
  172.         BOOL HandleMonitorChange(HWND hwndP, BOOL bMainDlg);
  173.         void SetDirty(BOOL bDirty=TRUE);
  175.         HWND GetCurDeviceHwnd() { return GetDlgItem(_hwndDesk, (int) _pCurDevice);};
  176.         int  GetNumDevices() { return _NumDevices;};
  177.         BOOL QueryNoAttach() { return _bNoAttach;};
  178.         BOOL IsDirty()       { return _bDirty;};
  180.         LRESULT CALLBACK WndProc(UINT uMsg, WPARAM wParam, LPARAM lParam);
  181. };
  184. CMultiMon::CMultiMon() : _cRef(1) {
  185.     ASSERT(_pCurDevice == NULL);
  186.     ASSERT(_pPrimaryDevice == NULL);
  187.     ASSERT(_DeskScale == 0);    
  188.     ASSERT(_InSetInfo == 0);
  189.     ASSERT(IsRectEmpty(&_rcDesk));
  190.     ASSERT(_bBadDriver == FALSE);
  191.     ASSERT(_bNewDriver == FALSE);
  192.     ASSERT(_bNoAttach == FALSE);
  193.     ASSERT(_bDirty == FALSE);
  194. };
  196. /*BUGBUG: (dli) per my talk with AndreVa, the unattended configuration stuff are NT only
  197.        and I don't have to do it. I tried my best to preserve the code and make them work
  198.        but they still may not work. 
  199.        
  200. */
  202. void CMultiMon::_DestroyDisplaySettings()
  203. {
  204.     int iDevice;
  205.     ASSERT(_NumDevices);
  206.     TraceMsg(TF_GENERAL, "DestroyDisplaySettings: %s devices", _NumDevices);
  207.     for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  208.     {
  209.         ASSERT(_Devices[iDevice].pds);
  210.         delete _Devices[iDevice].pds;
  212.         if (_Devices[iDevice].hdc)
  213.         {
  214.             DeleteDC(_Devices[iDevice].hdc);
  215.             _Devices[iDevice].hdc = NULL;
  216.         }
  217.     }
  219.     if (_himl)
  220.     {
  221.         ImageList_Destroy(_himl);
  222.         _himl = NULL;
  223.     }
  225.     TraceMsg(TF_GENERAL, "DestroyDisplaySettings: Finished destroying all devices");
  226. }
  228. #ifdef WINNT  
  229. //
  230. // deterines if the applet is in detect mode.
  231. //
  233. //
  234. // Called to put up initial messages that need to appear above the dialog
  235. // box
  236. //
  238. BOOL CMultiMon::_InitMessage()
  239. {
  240.     //
  241.     // If configure at logon is set, then we don't want to do anything
  242.     //
  243.     if (gUnattenedConfigureAtLogon)
  244.     {
  245.         PropSheet_PressButton(ghwndPropSheet, PSBTN_CANCEL);
  246.     }
  247.     else if (gUnattenedAutoConfirm)
  248.     {
  249.         PropSheet_PressButton(ghwndPropSheet, PSBTN_OK);
  250.     }
  251.     else
  252.     {
  253.         //
  254.         // _bBadDriver will be set when we fail to build the list of modes,
  255.         // or something else failed during initialization.
  256.         //
  257.         // In almost every case, we should already know about this situation
  258.         // based on our boot code.
  259.         // However, if this is a new situation, just report a "bad driver"
  260.         //
  262.         if (_bBadDriver)
  263.         {
  264.             ASSERT(gbExecMode == EXEC_INVALID_MODE);
  266.             gbExecMode = EXEC_INVALID_MODE;
  267.             gbInvalidMode = EXEC_INVALID_DISPLAY_DRIVER;
  268.         }
  271.         if (gbExecMode == EXEC_INVALID_MODE)
  272.         {
  273.             DWORD Mesg;
  275.             switch(gbInvalidMode) {
  277.             case EXEC_INVALID_NEW_DRIVER:
  278.                 Mesg = MSG_INVALID_NEW_DRIVER;
  279.                 break;
  280.             case EXEC_INVALID_DEFAULT_DISPLAY_MODE:
  281.                 Mesg = MSG_INVALID_DEFAULT_DISPLAY_MODE;
  282.                 break;
  283.             case EXEC_INVALID_DISPLAY_DRIVER:
  284.                 Mesg = MSG_INVALID_DISPLAY_DRIVER;
  285.                 break;
  286.             case EXEC_INVALID_OLD_DISPLAY_DRIVER:
  287.                 Mesg = MSG_INVALID_OLD_DISPLAY_DRIVER;
  288.                 break;
  289.             case EXEC_INVALID_16COLOR_DISPLAY_MODE:
  290.                 Mesg = MSG_INVALID_16COLOR_DISPLAY_MODE;
  291.                 break;
  292.             case EXEC_INVALID_DISPLAY_MODE:
  293.                 Mesg = MSG_INVALID_DISPLAY_MODE;
  294.                 break;
  295.             case EXEC_INVALID_CONFIGURATION:
  296.             default:
  297.                 Mesg = MSG_INVALID_CONFIGURATION;
  298.                 break;
  299.             }
  301.             FmtMessageBox(_hDlg,
  302.                           MB_ICONEXCLAMATION,
  303.                           FALSE,
  304.                           MSG_CONFIGURATION_PROBLEM,
  305.                           Mesg);
  307.             //
  308.             // For a bad display driver or old display driver, let's send the
  309.             // user straight to the installation dialog.
  310.             //
  312.             if ((gbInvalidMode == EXEC_INVALID_OLD_DISPLAY_DRIVER) ||
  313.                 (gbInvalidMode == EXEC_INVALID_DISPLAY_DRIVER))
  314.             {
  315.                 BOOL unused;
  316.                 //BUGBUG: (dli) _pCurDevice is the best guess.
  317.                 if (InstallNewDriver(_hDlg,
  318.                                      (LPCTSTR)_pCurDevice->DisplayDevice.DeviceString[0],
  319.                                      &unused) == NO_ERROR)
  320.                 {
  321.                     //
  322.                     // Set this flag so that we don't get a message about
  323.                     // having an untested mode.
  324.                     //
  326.                     _bNewDriver = TRUE;
  328.                     //
  329.                     // Let's leave the applet so the user sees the reboot
  330.                     // popup.
  331.                     //
  333.                     PropSheet_PressButton(ghwndPropSheet, PSBTN_OK);
  334.                 }
  335.             }
  336.         }
  337.     }
  339.     return TRUE;
  340. }
  342. VOID CMultiMon::_vPreExecMode()
  343. {
  345.     HKEY hkey;
  346.     DWORD cb;
  347. //    DWORD data;
  349.     //
  350.     // This function sets up the execution mode of the applet.
  351.     // There are four vlid modes.
  352.     //
  353.     // EXEC_NORMAL - When the apple is launched from the control panel
  354.     //
  355.     // EXEC_INVALID_MODE is exactly the same as for NORMAL except we will
  356.     //                   not mark the current mode as tested so the user has
  357.     //                   to at least test a mode
  358.     //
  359.     // EXEC_DETECT - When the applet is launched normally, but a detect was
  360.     //               done on the previous boot (the key in the registry is
  361.     //               set)
  362.     //
  363.     // EXEC_SETUP  - When we launch the applet in setup mode from setup (Both
  364.     //               the registry key is set and the setup flag is passed in).
  365.     //
  367.     //
  368.     // These two keys should only be checked  deleted if the machine has been
  369.     // rebooted and the detect  new display has actually happened.
  370.     // So we will look for the RebootNecessary key (a volatile key) and if
  371.     // it is not present, then we can delete the key.  Otherwise, the reboot
  372.     // has not happened, and we keep the key
  373.     //
  375.     if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  376.                      SZ_REBOOT_NECESSARY,
  377.                      0,
  378.                      KEY_READ | KEY_WRITE,
  379.                      &hkey) != ERROR_SUCCESS) {
  381.         if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  382.                          SZ_DETECT_DISPLAY,
  383.                          0,
  384.                          KEY_READ | KEY_WRITE,
  385.                          &hkey) == ERROR_SUCCESS) {
  387.             //
  388.             // NOTE: This key is also set when EXEC_SETUP is being run.
  389.             //
  391.             if (gbExecMode == EXEC_NORMAL) {
  393.                 gbExecMode = EXEC_DETECT;
  395.             } else {
  397.                 //
  398.                 // If we are in setup mode, we also check the extra values
  399.                 // under DetectDisplay that control the unattended installation.
  400.                 //
  402.                 ASSERT(gbExecMode == EXEC_SETUP);
  404.                 cb = 4;
  405.                 if (RegQueryValueEx(hkey,
  406.                                     SZ_CONFIGURE_AT_LOGON,
  407.                                     NULL,
  408.                                     NULL,
  409.                                     (LPBYTE) &gUnattenedConfigureAtLogon,
  410.                                     &cb) == ERROR_SUCCESS) {
  412.                     //
  413.                     // We delete only this value since the other values must remain
  414.                     // until the next boot
  415.                     //
  417.                     RegDeleteValue(hkey,
  418.                                    SZ_CONFIGURE_AT_LOGON);
  419.                 }
  421.                 if (gUnattenedConfigureAtLogon == 0)
  422.                 {
  424.                     cb = 4;
  425.                     RegQueryValueEx(hkey,
  426.                                     SZ_UNATTEND_INSTALL,
  427.                                     NULL,
  428.                                     NULL,
  429.                                     (LPBYTE) &gUnattenedInstall,
  430.                                     &cb);
  432.                     cb = 4;
  433.                     RegQueryValueEx(hkey,
  434.                                     SZ_UNATTEND_BPP,
  435.                                     NULL,
  436.                                     NULL,
  437.                                     (LPBYTE) &gUnattenedBitsPerPel,
  438.                                     &cb);
  440.                     cb = 4;
  441.                     RegQueryValueEx(hkey,
  442.                                     SZ_UNATTEND_X,
  443.                                     NULL,
  444.                                     NULL,
  445.                                     (LPBYTE) &gUnattenedXResolution,
  446.                                     &cb);
  448.                     cb = 4;
  449.                     RegQueryValueEx(hkey,
  450.                                     SZ_UNATTEND_Y,
  451.                                     NULL,
  452.                                     NULL,
  453.                                     (LPBYTE) &gUnattenedYResolution,
  454.                                     &cb);
  456.                     cb = 4;
  457.                     RegQueryValueEx(hkey,
  458.                                     SZ_UNATTEND_REF,
  459.                                     NULL,
  460.                                     NULL,
  461.                                     (LPBYTE) &gUnattenedVRefresh,
  462.                                     &cb);
  464.                     cb = 4;
  465.                     RegQueryValueEx(hkey,
  466.                                     SZ_UNATTEND_FLAGS,
  467.                                     NULL,
  468.                                     NULL,
  469.                                     (LPBYTE) &gUnattenedFlags,
  470.                                     &cb);
  472.                     cb = 4;
  473.                     RegQueryValueEx(hkey,
  474.                                     SZ_UNATTEND_CONFIRM,
  475.                                     NULL,
  476.                                     NULL,
  477.                                     (LPBYTE) &gUnattenedAutoConfirm,
  478.                                     &cb);
  479.                 }
  480.             }
  482.             RegCloseKey(hkey);
  483.         }
  485.         //
  486.         // Check for a new driver being installed
  487.         //
  489.         if ( (gbExecMode == EXEC_NORMAL) &&
  490.              (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  491.                            SZ_NEW_DISPLAY,
  492.                            0,
  493.                            KEY_READ | KEY_WRITE,
  494.                            &hkey) == ERROR_SUCCESS) ) {
  496.             gbExecMode = EXEC_INVALID_MODE;
  497.             gbInvalidMode = EXEC_INVALID_NEW_DRIVER;
  499.             RegCloseKey(hkey);
  500.         }
  502.         RegDeleteKey(HKEY_LOCAL_MACHINE,
  503.                      SZ_DETECT_DISPLAY);
  505.         RegDeleteKey(HKEY_LOCAL_MACHINE,
  506.                      SZ_NEW_DISPLAY);
  507.     }
  508.     {
  509.         LPTSTR psz;
  510.         LPTSTR pszInv;
  512.         switch(gbExecMode) {
  514.             case EXEC_NORMAL:
  515.                 psz = TEXT("Normal Execution mode");
  516.                 break;
  517.             case EXEC_DETECT:
  518.                 psz = TEXT("Detection Execution mode");
  519.                 break;
  520.             case EXEC_SETUP:
  521.                 psz = TEXT("Setup Execution mode");
  522.                 break;
  523.             case EXEC_INVALID_MODE:
  524.                 psz = TEXT("Invalid Mode Execution mode");
  526.                 switch(gbInvalidMode) {
  528.                     case EXEC_INVALID_NEW_DRIVER:
  529.                         pszInv = TEXT("Invalid new driver");
  530.                         break;
  531.                     default:
  532.                         pszInv = TEXT("*** Invalid *** Invalid mode");
  533.                         break;
  534.                 }
  535.                 break;
  536.             default:
  537.                 psz = TEXT("*** Invalid *** Execution mode");
  538.                 break;
  539.         }
  541.         KdPrint(("n nDisplay.cpl: The display applet is in : %wsn", psz));
  543.         if (gbExecMode == EXEC_INVALID_MODE)
  544.         {
  545.             KdPrint(("tt sub invalid mode : %ws", pszInv));
  546.         }
  547.         KdPrint(("nn", psz));
  548.     }
  549. }
  552. VOID CMultiMon::_vPostExecMode() {
  554.     HKEY hkey;
  555.     DWORD cb;
  556.     DWORD data;
  558.     //
  559.     // Check for various invalid configurations
  560.     //
  562.     if ( (gbExecMode == EXEC_NORMAL) &&
  563.          (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  564.                        SZ_INVALID_DISPLAY,
  565.                        0,
  566.                        KEY_READ | KEY_WRITE,
  567.                        &hkey) == ERROR_SUCCESS) ) {
  569.         gbExecMode = EXEC_INVALID_MODE;
  571.         //
  572.         // Check for these fields in increasing order of "badness" or
  573.         // "detail" so that the *worst* error is the one remaining in the
  574.         // gbInvalidMode  variable once all the checks are done.
  575.         //
  577.         cb = 4;
  578.         if (RegQueryValueEx(hkey,
  579.                             TEXT("DefaultMode"),
  580.                             NULL,
  581.                             NULL,
  582.                             (LPBYTE)(&data),
  583.                             &cb) == ERROR_SUCCESS)
  584.         {
  585.             gbInvalidMode = EXEC_INVALID_DEFAULT_DISPLAY_MODE;
  586.         }
  588.         cb = 4;
  589.         if (RegQueryValueEx(hkey,
  590.                             TEXT("BadMode"),
  591.                             NULL,
  592.                             NULL,
  593.                             (LPBYTE)(&data),
  594.                             &cb) == ERROR_SUCCESS)
  595.         {
  596.             gbInvalidMode = EXEC_INVALID_DISPLAY_MODE;
  597.         }
  599.         cb = 4;
  600.         if (RegQueryValueEx(hkey,
  601.                             TEXT("16ColorMode"),
  602.                             NULL,
  603.                             NULL,
  604.                             (LPBYTE)(&data),
  605.                             &cb) == ERROR_SUCCESS)
  606.         {
  607.             gbInvalidMode = EXEC_INVALID_16COLOR_DISPLAY_MODE;
  608.         }
  611.         cb = 4;
  612.         if (RegQueryValueEx(hkey,
  613.                             TEXT("InvalidConfiguration"),
  614.                             NULL,
  615.                             NULL,
  616.                             (LPBYTE)(&data),
  617.                             &cb) == ERROR_SUCCESS)
  618.         {
  619.             gbInvalidMode = EXEC_INVALID_CONFIGURATION;
  620.         }
  622.         cb = 4;
  623.         if (RegQueryValueEx(hkey,
  624.                             TEXT("MissingDisplayDriver"),
  625.                             NULL,
  626.                             NULL,
  627.                             (LPBYTE)(&data),
  628.                             &cb) == ERROR_SUCCESS)
  629.         {
  630.             gbInvalidMode = EXEC_INVALID_DISPLAY_DRIVER;
  631.         }
  633.         //
  634.         // This last case will be set in addition to the previous one in the
  635.         // case where the driver was an old driver linking to winsvr.dll
  636.         // and we can not load it.
  637.         //
  639.         cb = 4;
  640.         if (RegQueryValueEx(hkey,
  641.                             TEXT("OldDisplayDriver"),
  642.                             NULL,
  643.                             NULL,
  644.                             (LPBYTE)(&data),
  645.                             &cb) == ERROR_SUCCESS)
  646.         {
  647.             gbInvalidMode = EXEC_INVALID_OLD_DISPLAY_DRIVER;
  648.         }
  650.         RegCloseKey(hkey);
  652.     }
  654.     //
  655.     // Delete all of these bad configuration keys since we only want the
  656.     // user to see the message once.
  657.     //
  659.     RegDeleteKey(HKEY_LOCAL_MACHINE,
  660.                  SZ_INVALID_DISPLAY);
  662. {
  663.     LPTSTR psz;
  664.     LPTSTR pszInv;
  666.     if (gbExecMode == EXEC_INVALID_MODE)
  667.     {
  668.         switch (gbInvalidMode)
  669.         {
  670.         case EXEC_INVALID_DEFAULT_DISPLAY_MODE:
  671.             pszInv = TEXT("Default mode being used");
  672.             break;
  673.         case EXEC_INVALID_DISPLAY_DRIVER:
  674.             pszInv = TEXT("Invalid Display Driver");
  675.             break;
  676.         case EXEC_INVALID_OLD_DISPLAY_DRIVER:
  677.             pszInv = TEXT("Old Display Driver");
  678.             break;
  679.         case EXEC_INVALID_16COLOR_DISPLAY_MODE:
  680.             pszInv = TEXT("16 color mode not supported");
  681.             break;
  682.         case EXEC_INVALID_DISPLAY_MODE:
  683.             pszInv = TEXT("Invalid display mode");
  684.             break;
  685.         case EXEC_INVALID_CONFIGURATION:
  686.             pszInv = TEXT("Invalid configuration");
  687.             break;
  688.         default:
  689.             psz = TEXT("*** Invalid *** Invalid mode");
  690.             break;
  691.         }
  693.         KdPrint(("tt sub invlid mode : %ws", pszInv));
  694.         KdPrint(("nn", psz));
  695.     }
  696. }
  697. }
  699. #endif
  701. //-----------------------------------------------------------------------------
  702. //-----------------------------------------------------------------------------
  703. void CMultiMon::_DeskToPreview(LPRECT in, LPRECT out)
  704. {
  705.     out->left   = _DeskOff.x + MulDiv(in->left   - _rcDesk.left,_DeskScale,1000);
  706.     out->top    = _DeskOff.y + MulDiv(in->top    - _rcDesk.top, _DeskScale,1000);
  707.     out->right  = _DeskOff.x + MulDiv(in->right  - _rcDesk.left,_DeskScale,1000);
  708.     out->bottom = _DeskOff.y + MulDiv(in->bottom - _rcDesk.top, _DeskScale,1000);
  709. }
  711. //-----------------------------------------------------------------------------
  712. //-----------------------------------------------------------------------------
  713. void CMultiMon::_OffsetPreviewToDesk(LPRECT in, LPRECT out)
  714. {
  715.     int x, y;
  717.     // Scale preview rects back to desk size
  718.     x = _rcDesk.left + MulDiv(in->left - _DeskOff.x,1000,_DeskScale);
  719.     y = _rcDesk.top  + MulDiv(in->top  - _DeskOff.y,1000,_DeskScale);
  721.     // Figure out how much to offset
  722.     x = x - out->left;
  723.     y = y - out->top;
  725.     OffsetRect(out, x, y);
  726. }
  728. void CMultiMon::_SetReposition(HWND hwnd, PMULTIMON_DEVICE pDevice)
  729. {
  730.     //
  731.     // Try to open the device with the new settings.
  732.     // If it works, we get the reposition flag, otherwise we assume
  733.     // the paramters are wrong and we fail (since the rectangle will
  734.     // not be updated).
  735.     //
  737. #ifdef WINNT
  738.     HDC hdc;
  740.     if (pDevice->bRepositionable == FALSE)
  741.     {
  742.         hdc = CreateDC(NULL,
  743.                        pDevice->DisplayDevice.DeviceName,
  744.                        NULL,
  745.                        &pDevice->DisplaySetting);
  747.         if (hdc == NULL)
  748.         {
  749.             //
  750.             // Device may be attached - try with a NULL DEVMODE.
  751.             //
  753.             hdc = CreateDC(NULL,
  754.                            pDevice->DisplayDevice.DeviceName,
  755.                            NULL,
  756.                            NULL);
  757.         }
  759.         if (hdc)
  760.         {
  761.             pDevice->bRepositionable = TRUE;
  762.             // DLI: make it Compile GetDeviceCaps(hdc, RASTERCAPS) & RC_REPOSITIONABLE;
  764.             DeleteDC(hdc);
  765.         }
  766.     }
  768. #else
  769.     //
  770.     // For WIN95, any device can be relocated.
  771.     //
  772.     pDevice->bRepositionable = TRUE;
  773. #endif
  775. }
  778. int CMultiMon::_GetMinColorBits()
  779. {
  780.     
  781.     int     iMinColorBits = 64; // This is the max possible
  782.     int     iDevice;
  784.     for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  785.     {
  786.         int iColorBits = _Devices[iDevice].pds->GetColorBits();
  787.         if (iColorBits < iMinColorBits)
  788.             iMinColorBits = iColorBits;
  789.     }
  791.     return iMinColorBits;
  792. }
  795. //-----------------------------------------------------------------------------
  796. int CMultiMon::_SaveDisplaySettings(DWORD dwSet)
  797. {
  798.     int     iRet = 0;
  799.     int     iDevice;
  800.     HWND    hwndC;
  802.     _VerifyPrimaryMode(FALSE);
  804.     for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  805.     {
  806.         int iResult = _Devices[iDevice].pds->SaveSettings(dwSet);
  807.         if (iResult != DISP_CHANGE_SUCCESSFUL)
  808.         {
  809.             if (iResult == DISP_CHANGE_RESTART)
  810.             {
  811.                 iRet = iResult;
  812.                 continue;
  813.             }
  814.             else
  815.             {
  816.                 ASSERT(iResult < 0);
  817.                 return iResult;
  818.             }
  819.         }
  821.     }
  823.     // If we get here, the above functions are successful or requires restart
  824.     // This ChangeDisplaySettings call will actually go refresh the whole desktop
  825.     // Of course we don't want to do it at a test. 
  826.     if (!(dwSet & CDS_TEST))
  827.     {
  828.         if (_GetMinColorBits() > 8)
  829.             g_bGradient = TRUE;
  830.         else
  831.             g_bGradient = FALSE;
  833.         SystemParametersInfo(SPI_SETGRADIENTCAPTIONS, 0, (LPVOID)g_bGradient, SPIF_UPDATEINIFILE);
  834.         
  835.         hwndC = CreateCoverWindow(COVER_NOPAINT);
  836.         ChangeDisplaySettings(NULL, NULL);
  837.         DestroyCoverWindow(hwndC);
  838.     }
  839.     return iRet;
  840. }
  842. void CMultiMon::_RestoreDisplaySettings()
  843. {
  844.     int     iDevice;
  845.     HWND    hwndC;
  847.     for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  848.         _Devices[iDevice].pds->RestoreSettings();
  849.     
  850.     //DLI: This last function call will actually go refresh the whole desktop
  851.     hwndC = CreateCoverWindow(COVER_NOPAINT);
  852.     ChangeDisplaySettings(NULL, NULL);
  853.     DestroyCoverWindow(hwndC);
  854. }
  856. void CMultiMon::_ConfirmDisplaySettingsChange()
  857. {
  858.     int iDevice;
  859.     for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  860.         _Devices[iDevice].pds->ConfirmChangeSettings();
  862.     if (GetNumberOfAttachedDisplays() > 1)
  863.         _WriteMultiMonProfile();
  864. }
  866. BOOL CALLBACK KeepNewDlgProc(HWND hDlg, UINT message , WPARAM wParam, LPARAM lParam)
  867. {
  868.     UINT idTimer = 0;
  869.     HICON hicon;
  871.     switch(message)
  872.     {
  873.         case WM_INITDIALOG:
  874.             hicon = LoadIcon(NULL, IDI_QUESTION);
  875.             if (hicon)
  876.                 SendDlgItemMessage(hDlg, IDC_BIGICON, STM_SETIMAGE, IMAGE_ICON, (DWORD)hicon);
  877.             idTimer = SetTimer(hDlg, 1, 20000, NULL);
  878.             break;
  880.         case WM_DESTROY:
  881.             if (idTimer)
  882.                 KillTimer(hDlg, idTimer);
  883.             hicon = (HICON)SendDlgItemMessage(hDlg, IDC_BIGICON, STM_GETIMAGE, IMAGE_ICON, 0);
  884.             if (hicon)
  885.                 DestroyIcon(hicon);
  886.             break;
  888.         case WM_TIMER:
  889.             EndDialog(hDlg, IDNO);
  890.             break;
  892.         case WM_COMMAND:
  893.             EndDialog(hDlg, wParam);
  894.             break;
  896.         default:
  897.             return FALSE;
  898.     }
  899.     return TRUE;
  900. }
  902. BOOL CMultiMon::_TestNewSettingsChange()
  903. {
  904.     int iAnswer = DialogBox(hInstance, MAKEINTRESOURCE(DLG_KEEPNEW), GetParent(_hDlg),
  905.                             KeepNewDlgProc);
  906.     return (iAnswer == IDYES);
  907. }
  909. BOOL CMultiMon::_RebuildDisplaySettings(BOOL bComplete)
  910. {
  911.     BOOL result = TRUE;
  912.     HCURSOR hcur = SetCursor(LoadCursor(NULL, IDC_WAIT));
  914.     for (int iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  915.         if (!_Devices[iDevice].pds->RefreshSettings(bComplete))
  916.             result = FALSE;
  918.     RedrawWindow(_hDlg, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_ALLCHILDREN);
  920.     SetCursor(hcur);
  921.     return result;
  922. }
  924. int CMultiMon::GetNumberOfAttachedDisplays()
  925. {
  926.     int nDisplays = 0;
  927.     int iDevice;
  928.     for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  929.     {
  930.         if (_Devices[iDevice].pds->IsAttached())
  931.             nDisplays++;
  932.     }
  933.     return nDisplays;
  934. }
  936. BOOL CMultiMon::_AnyColorChange()
  937. {
  938.     int iDevice;
  939.     for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  940.     {
  941.         if (_Devices[iDevice].pds->IsAttached() && _Devices[iDevice].pds->IsColorChanged())
  942.             return TRUE;
  943.     }
  944.     return FALSE;
  945. }
  947. BOOL CMultiMon::_AnyResolutionChange()
  948. {
  949.    int iDevice;
  950.    for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  951.    {
  952.        if (_Devices[iDevice].pds->IsAttached() && _Devices[iDevice].pds->IsResolutionChanged())
  953.            return TRUE;
  954.    }
  955.    return FALSE;
  956. }
  958. BOOL CMultiMon::_QueryForceSmallFont()
  959. {
  960.     int iDevice;
  961.     for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  962.     {
  963.         if (_Devices[iDevice].pds->IsSmallFontNecessary())
  964.             return TRUE;
  965.     }
  966.     return FALSE;
  967. }
  969. void CMultiMon::_GetDisplayName(PMULTIMON_DEVICE pDevice, LPTSTR pszDisplay)
  970. {
  971.     TCHAR szMonitor[140];
  972.     TCHAR szDisplayFormat[20];
  973.     LoadString(hInstance, IDS_DISPLAYFORMAT, szDisplayFormat, SIZEOF(szDisplayFormat));
  974.     if (!pDevice->pds->GetMonitorName(szMonitor, NULL) || szMonitor[0] == 0)
  975.         LoadString(hInstance, IDS_UNKNOWNMONITOR, szMonitor, SIZEOF(szMonitor));
  976.         
  977.     wsprintf(pszDisplay, szDisplayFormat, pDevice->DisplayIndex, szMonitor, pDevice->DisplayDevice.DeviceString);
  978. }
  980. //-----------------------------------------------------------------------------
  981. void CMultiMon::_DoAdvancedSettingsSheet()
  982. {
  983. #ifndef WINNT
  984.     HINSTANCE hDesk16 = LoadLibrary16( "DeskCp16.Dll" );
  985.     FARPROC16 pDesk16 = (FARPROC16)( hDesk16?
  986.                         GetProcAddress16( hDesk16, "CplApplet" ) : NULL );
  987. #endif
  988.     PROPSHEETHEADER psh;
  989.     HPROPSHEETPAGE rPages[MAX_PAGES];
  990.     PROPSHEETPAGE psp;
  991.     HPSXA hpsxa = NULL;
  992.     HPSXA hpsxaOEM = NULL;
  993.     int iResult = 0;
  994.     TCHAR szDisplay[256];
  995.     PMONPARAM pmMon = NULL;
  997.     psh.dwSize = sizeof(psh);
  998.     psh.dwFlags = PSH_PROPTITLE;
  999.     psh.hwndParent = GetParent(_hDlg);
  1000.     psh.hInstance = hInstance;
  1001.     psh.pszCaption = (LPTSTR)_pCurDevice->DisplayDevice.DeviceString;
  1002.     psh.nPages = 0;
  1003.     psh.nStartPage = 0;
  1004.     psh.phpage = rPages;
  1006.     psp.dwSize = sizeof(psp);
  1007.     psp.dwFlags = PSP_DEFAULT;
  1008.     psp.hInstance = hInstance;
  1010.     psp.pfnDlgProc = GeneralPageProc;
  1011.     psp.pszTemplate = MAKEINTRESOURCE(DLG_GENERAL);
  1012.     psp.lParam = (LPARAM)_QueryForceSmallFont();
  1014.     if (rPages[psh.nPages] = CreatePropertySheetPage(&psp))
  1015.         psh.nPages++;
  1017. #ifdef WINNT
  1018.     //BUGBUG: (dli) Should use the one from pds
  1019.     GetAdvAdapterPropPageParam( NULL, _AddDisplayPropSheetPage, (LPARAM)&psh, (LPARAM)&_pCurDevice->DisplaySetting);
  1020.     pmMon = _pCurDevice->pds->GetMonitorParams();
  1021.     if (pmMon)
  1022.         GetAdvMonitorPropPageParam( NULL, _AddDisplayPropSheetPage, (LPARAM)&psh, (LPARAM)pmMon );
  1023. #else
  1024.     ATOM AtomDevice = GlobalAddAtom((char *)&_pCurDevice->DisplayDevice.DeviceName);
  1025.     if( pDesk16 && CallCPLEntry16( hDesk16, pDesk16, NULL, CPL_INIT, (LPARAM)AtomDevice, 0 ) )
  1026.     {
  1027.         // or just add the default page
  1028.         SHAddPages16( NULL, "DESKCP16.DLL,GetAdapterPage",
  1029.                       _AddDisplayPropSheetPage, (LPARAM)&psh );
  1031.         //
  1032.         // only add the monitor tab iff a monitor exists
  1033.         //
  1034.         if (_pCurDevice->DisplayDevice.DeviceName[0])
  1035.         {
  1036.             TCHAR szMonitor[140];
  1037.             szMonitor[0] = 0;
  1038.             _pCurDevice->pds->GetMonitorName(szMonitor, NULL);
  1040.             if (szMonitor[0])
  1041.             {
  1042.                 SHAddPages16( NULL, "DESKCP16.DLL,GetMonitorPage",
  1043.                           _AddDisplayPropSheetPage, (LPARAM)&psh );
  1044.             }
  1045.         }
  1047.         SHAddPages16( NULL, "DESKCP16.DLL,GetPerformancePage",
  1048.                       _AddDisplayPropSheetPage, (LPARAM)&psh );
  1049.     }
  1050. #endif
  1052.     InitClipboardFormats();
  1053.     IDataObject * pdo = NULL;
  1054.     _pCurDevice->pds->QueryInterface(IID_IDataObject, (LPVOID *) &pdo);
  1056.     //
  1057.     // load any extensions from the registry
  1058.     //
  1059.     if (gbExecMode == EXEC_NORMAL)
  1060.     {
  1061.         //
  1062.         // load the generic (non hardware specific) extensions
  1063.         //
  1064.         if( ( hpsxa = SHCreatePropSheetExtArrayEx( HKEY_LOCAL_MACHINE, REGSTR_PATH_CONTROLSFOLDER TEXT("\Device"), 8, pdo) ) != NULL )
  1065.         {
  1066.             SHAddFromPropSheetExtArray( hpsxa, _AddDisplayPropSheetPage, (LPARAM)&psh );
  1067.         }
  1069.         //
  1070.         // load the hardware-specific extensions
  1071.         //
  1072.         // NOTE it is very important to load the OEM extensions *after* the
  1073.         // generic extensions some HW extensions expect to be the last tabs
  1074.         // in the propsheet (right before the settings tab)
  1075.         //
  1076.         if( ( hpsxaOEM = SHCreatePropSheetExtArrayEx( HKEY_LOCAL_MACHINE, _pCurDevice->DisplayRegKey, 8, pdo) ) != NULL )
  1077.         {
  1078.             SHAddFromPropSheetExtArray( hpsxaOEM, _AddDisplayPropSheetPage, (LPARAM)&psh );
  1079.         }
  1081.         //
  1082.         // add a fake settings page to fool OEM extensions (must be last)
  1083.         //
  1084.         if (hpsxa || hpsxaOEM)
  1085.         {
  1086.             AddFakeSettingsPage(&psh);
  1087.         }
  1088.     }
  1090.     if (psh.nPages)
  1091.     {
  1092.         iResult = PropertySheet(&psh);
  1093.     }
  1095.     _GetDisplayName(_pCurDevice, szDisplay);
  1097.     if (_NumDevices == 1)
  1098.     {
  1099.         //Set the name of the primary in the static text
  1100.         //strip the first token off (this is the number we dont want it)
  1101.         TCHAR *pch;
  1102.         for (pch=szDisplay; *pch && *pch != TEXT(' '); pch++);
  1103.         for (;*pch && *pch == TEXT(' '); pch++);
  1104.         SetDlgItemText(_hDlg, IDC_DISPLAYTEXT, pch);
  1105.     }
  1106.     else
  1107.     {
  1108.         ComboBox_DeleteString(_hwndList, _pCurDevice->ComboBoxItem);
  1109.         ComboBox_InsertString(_hwndList, _pCurDevice->ComboBoxItem, szDisplay);
  1110.         ComboBox_SetItemData(_hwndList, _pCurDevice->ComboBoxItem, (DWORD)_pCurDevice);
  1111.         ComboBox_SetCurSel(_hwndList, _pCurDevice->ComboBoxItem);
  1112.     }
  1113.     
  1114. #ifdef WINNT
  1115.     _pCurDevice->pds->UpdateRefreshRate(pmMon);
  1116. #endif
  1118.     if( hpsxa )
  1119.         SHDestroyPropSheetExtArray( hpsxa );
  1120.     if( hpsxaOEM )
  1121.         SHDestroyPropSheetExtArray( hpsxaOEM );
  1122.     if (pdo)
  1123.         pdo->Release();
  1124.     
  1125. #ifndef WINNT
  1126.     if (pDesk16)
  1127.         CallCPLEntry16( hDesk16, pDesk16, NULL, CPL_EXIT, 0, 0 );
  1128.     if (AtomDevice)
  1129.         GlobalDeleteAtom(AtomDevice);
  1130.     if( hDesk16 )
  1131.         FreeLibrary16( hDesk16 );
  1132. #endif
  1133.     
  1134.     if ((iResult == ID_PSRESTARTWINDOWS) || (iResult == ID_PSREBOOTSYSTEM))
  1135.     {
  1136.         PropSheet_CancelToClose(GetParent(_hDlg));
  1138.         if (iResult == ID_PSREBOOTSYSTEM)
  1139.             PropSheet_RebootSystem(ghwndPropSheet);
  1140.         else
  1141.             PropSheet_RestartWindows(ghwndPropSheet);
  1142.     }
  1143. }
  1145. //-----------------------------------------------------------------------------
  1146. void CMultiMon::UpdateActiveDisplay(PMULTIMON_DEVICE pDevice)
  1147. {
  1148.     HWND hwndC;
  1150.     _InSetInfo++;
  1152.     if (pDevice == NULL)
  1153.         pDevice = (PMULTIMON_DEVICE)ComboBox_GetItemData(_hwndList, ComboBox_GetCurSel(_hwndList));
  1154.     else
  1155.         ComboBox_SetCurSel(_hwndList, pDevice->ComboBoxItem);
  1157.     if (pDevice && ((ULONG)pDevice) != 0xFFFFFFFF)
  1158.     {
  1159.         hwndC = GetDlgItem(_hwndDesk, (int) _pCurDevice);
  1161.         _pCurDevice->pds->SetActive(FALSE);
  1162.         _pCurDevice = pDevice;
  1164.         if (hwndC)
  1165.             RedrawWindow(hwndC, NULL, NULL, RDW_ERASE | RDW_INVALIDATE);
  1167.         hwndC = GetDlgItem(_hwndDesk, (int) _pCurDevice);
  1168.         if (hwndC)
  1169.             RedrawWindow(hwndC, NULL, NULL, RDW_ERASE | RDW_INVALIDATE);
  1171.         //
  1172.         // Update the two check box windows
  1173.         //
  1174. #ifdef WINNT 
  1175.         CheckDlgButton(_hDlg, IDC_DISPLAYPRIME, _pCurDevice->pds->IsPrimary());
  1176.         EnableWindow(GetDlgItem(_hDlg, IDC_DISPLAYPRIME), 1);  // fUseDevice);
  1177. #endif
  1178.         CheckDlgButton(_hDlg, IDC_DISPLAYUSEME, _pCurDevice->pds->IsAttached());
  1179.         EnableWindow(GetDlgItem(_hDlg, IDC_DISPLAYUSEME), !_bNoAttach && !_pCurDevice->pds->IsPrimary());
  1181.         // Update the color and screen size combo box
  1182.         _pCurDevice->pds->SetActive(TRUE);
  1183.     }
  1184.     else
  1185.     {
  1186.         //
  1187.         // No display device !
  1188.         //
  1189.         WarnMsg(TEXT("UpdateActiveDisplay: No display device!!!!"), TEXT(""));
  1190.         ASSERT(FALSE);
  1191.     }
  1193.     _InSetInfo--;
  1194. }
  1196. //----------------------------------------------------------------------------
  1197. //
  1198. //  VerifyPrimaryMode()
  1199. //
  1200. //----------------------------------------------------------------------------
  1202. void CMultiMon::_VerifyPrimaryMode(BOOL fKeepMode)
  1203. {
  1204. #ifndef WINNT
  1205.     //
  1206.     // on Win9x make sure the primary is in a mode >= 256 color
  1207.     //
  1208.     if (GetNumberOfAttachedDisplays() > 1 && _pPrimaryDevice &&
  1209.         _pPrimaryDevice->pds->GetColorBits() < 8)
  1210.     {
  1211.         if (fKeepMode)
  1212.         {
  1213.             for (int i = 0; _Devices[i].DisplayDevice.cb != 0; i++)
  1214.             {
  1215.                 if (_pPrimaryDevice != &_Devices[i])
  1216.                     _Devices[i].pds->SetAttached(FALSE);
  1217.             }
  1219.             RedrawWindow(GetDlgItem(_hDlg, IDC_DISPLAYDESK), NULL, NULL,
  1220.                 RDW_ALLCHILDREN | RDW_ERASE | RDW_INVALIDATE);
  1221.         }
  1222.         else
  1223.         {
  1224.             _pPrimaryDevice->pds->SetMode(640,480,8);
  1225.         }
  1227.         SetDirty();
  1228.     }
  1229. #endif
  1230. }
  1232. //----------------------------------------------------------------------------
  1233. //
  1234. //  SetDirty
  1235. //
  1236. //----------------------------------------------------------------------------
  1237. void CMultiMon::SetDirty(BOOL bDirty)
  1238. {
  1239.     _bDirty = bDirty;
  1241.     if (_bDirty)
  1242.     {
  1243.         PostMessage(GetParent(_hDlg), PSM_CHANGED, (WPARAM)_hDlg, 0L);
  1244.     }
  1245. }
  1247. //----------------------------------------------------------------------------
  1248. //
  1249. //  ToggleAttached()
  1250. //
  1251. //  Toggles the attached state of the device, unless the bPrime is set which
  1252. //  forces an attach also.
  1253. //
  1254. //----------------------------------------------------------------------------
  1255. BOOL CMultiMon::ToggleAttached(PMULTIMON_DEVICE pDevice, BOOL bPrime)
  1256. {
  1257.     DWORD iDevice;
  1258.     RECT rcPos;
  1259.     if (bPrime || (!pDevice->pds->IsAttached()))
  1260.     {
  1261.         //
  1262.         // Make sure this device actually has a rectangle.
  1263.         // If it does not (not configured in the registry, then we need
  1264.         // to put up a popup and ask the user to configure the device.
  1265.         //
  1266.         pDevice->pds->GetCurPosition(&rcPos);
  1267.         if (IsRectEmpty(&rcPos))
  1268.             return FALSE;
  1270. #ifdef WINNT
  1271.         //
  1272.         // NT requires the same number of colors.
  1273.         // Don't let the driver get attached if it is has a different color
  1274.         // depth than the primary (unless we are settings it to the primary.
  1275.         //
  1277.         if ((bPrime == FALSE) &&
  1278.             (pDevice->DisplaySetting.dmBitsPerPel !=
  1279.              _pPrimaryDevice->DisplaySetting.dmBitsPerPel))
  1280.         {
  1281.             FmtMessageBox(_hDlg,
  1282.                           MB_ICONSTOP | MB_OK,
  1283.                           FALSE,
  1284.                           ID_DSP_TXT_SETTINGS,
  1285.                           MSG_MULTI_BAD_COLORS);
  1286.             return FALSE;
  1287.         }
  1288. #endif
  1290.         //
  1291.         // If the device is not the primary, let's see if it is repositionable.
  1292.         // If not, we will have to ask the user if it should be the primary also.
  1293.         //
  1295.         if ((bPrime == FALSE) && (!pDevice->bRepositionable))
  1296.         {
  1297.             if (FmtMessageBox(_hDlg,
  1298.                               MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
  1299.                               FALSE,
  1300.                               ID_DSP_TXT_SETTINGS,
  1301.                               MSG_MULTI_NO_REPOSITION) == IDYES)
  1302.             {
  1303.                 bPrime = TRUE;
  1304.             }
  1305.             else
  1306.             {
  1307.                 return FALSE;
  1308.             }
  1309.         }
  1311.         //
  1312.         // The DM_POSITION determines whether the device should be
  1313.         // part of the desktop or not.
  1314.         // Make sure this device actually has a rectangle now.
  1315.         //
  1316.         pDevice->pds->SetAttached(TRUE);
  1318.         //
  1319.         // make sure the primary is in a valid mode
  1320.         //
  1321.         _VerifyPrimaryMode(FALSE);
  1322.     }
  1323.     else
  1324.         //
  1325.         // Toggling the device out of the desktop, unless it's the primary
  1326.         //
  1327.         pDevice->pds->SetAttached(FALSE);
  1329.     if (bPrime)
  1330.     {
  1331.         //
  1332.         // Unmark the primary device.
  1333.         //
  1334.         // Remove all the devices which are non-repositionable or of a
  1335.         // different color depths.
  1336.         // Also, if this device is not repositionable, then remove it from the
  1337.         // desktop.
  1338.         //
  1340.         for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  1341.         {
  1342.             _Devices[iDevice].pds->SetPrimary(FALSE);
  1344. #ifdef WINNT
  1345.             if (pDevice->DisplaySetting.dmBitsPerPel != _Devices[iDevice].DisplaySetting.dmBitsPerPel)
  1346.                 _Devices[iDevice].pds->SetAttached(FALSE);
  1347. #endif
  1348.             if (!_Devices[iDevice].bRepositionable)
  1349.                 _Devices[iDevice].pds->SetAttached(FALSE);
  1350.         }
  1351.         _pPrimaryDevice->pds->SetPrimary(FALSE);
  1352.         //
  1353.         // Mark the new device as the primary and attached since we
  1354.         // unattached it in the above loop.
  1355.         //
  1357.         _pPrimaryDevice = pDevice;
  1358.         _pPrimaryDevice->pds->SetPrimary(TRUE);
  1359.         _pPrimaryDevice->pds->SetAttached(TRUE);
  1360.     }
  1362.     return TRUE;
  1363. }
  1366. //-----------------------------------------------------------------------------
  1368. void CMultiMon::_CleanupRects(HWND hwndP)
  1369. {
  1370.     int   n;
  1371.     ULONG iDevice;
  1372.     HWND  hwndC;
  1373.     RECT  arc[20];
  1374.     DWORD arcDev[20];
  1375.     DWORD iArcPrimary = 0;
  1377.     RECT rc;
  1378.     RECT rcU;
  1379.     int   i;
  1380.     RECT rcPrev;
  1381.     int sx,sy;
  1382.     int x,y;
  1384.     //
  1385.     // get the positions of all the windows
  1386.     //
  1388.     n = 0;
  1391.     for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  1392.     {
  1393.         PMULTIMON_DEVICE pDevice = &_Devices[iDevice];
  1395.         hwndC = GetDlgItem(hwndP, (int) pDevice);
  1397.         if (hwndC != NULL)
  1398.         {
  1399.             RECT rcPos;
  1400. #ifdef WINNT
  1401.             ASSERT(pDevice->DisplaySetting.dmBitsPerPel ==
  1402.                    _pPrimaryDevice->DisplaySetting.dmBitsPerPel);
  1403. #endif
  1404.             TraceMsg(TF_GENERAL, "_CleanupRects start Device %08lx, Dev = %d, hwnd = %08lxn",
  1405.                      pDevice, iDevice, hwndC);
  1407.             ShowWindow(hwndC, SW_SHOW);
  1409.             GetWindowRect(hwndC, &arc[n]);
  1410.             MapWindowPoints(NULL, hwndP, (POINT FAR*)&arc[n], 2);
  1412.             pDevice->pds->GetCurPosition(&rcPos);
  1413.             _OffsetPreviewToDesk(&arc[n], &rcPos);
  1414.             arc[n] = rcPos;
  1415.             arcDev[n] = iDevice;
  1417.             if (pDevice->pds->IsPrimary())
  1418.             {
  1419.                 TraceMsg(TF_GENERAL, "_CleanupRects primary Device %08lxn", pDevice);
  1421.                 iArcPrimary = n;
  1422.             }
  1423.             else
  1424.             {
  1425.                 ASSERT(pDevice->bRepositionable);
  1426.             }
  1428.             n++;
  1429.         }
  1430.     }
  1432.     //
  1433.     // cleanup the rects
  1434.     //
  1435.     AlignRects(arc, n, iArcPrimary, CUDR_NORMAL);
  1437.     //
  1438.     // Get the union.
  1439.     //
  1441.     SetRectEmpty(&rcU);
  1442.     for (i=0; i<n; i++)
  1443.         UnionRect(&rcU, &rcU, &arc[i]);
  1444.     GetClientRect(hwndP, &rcPrev);
  1446.     //
  1447.     // only rescale if the new desk hangs outside the preview area.
  1448.     // or is too small
  1449.     //
  1451.     _DeskToPreview(&rcU, &rc);
  1452.     x = ((rcPrev.right  - rcPrev.left)-(rc.right  - rc.left))/2;
  1453.     y = ((rcPrev.bottom - rcPrev.top) -(rc.bottom - rc.top))/2;
  1455.     if (rcU.left < 0 || rcU.top < 0 || x < 0 || y < 0 ||
  1456.         rcU.right > rcPrev.right || rcU.bottom > rcPrev.bottom ||
  1457.         (x > (rcPrev.right-rcPrev.left)/8 &&
  1458.          y > (rcPrev.bottom-rcPrev.top)/8))
  1459.     {
  1460.         _rcDesk = rcU;
  1461.         sx = MulDiv(rcPrev.right  - rcPrev.left - 16,1000,_rcDesk.right  - _rcDesk.left);
  1462.         sy = MulDiv(rcPrev.bottom - rcPrev.top  - 16,1000,_rcDesk.bottom - _rcDesk.top);
  1464.         _DeskScale = min(sx,sy) * 2 / 3;
  1465.         _DeskToPreview(&_rcDesk, &rc);
  1466.         _DeskOff.x = ((rcPrev.right  - rcPrev.left)-(rc.right  - rc.left))/2;
  1467.         _DeskOff.y = ((rcPrev.bottom - rcPrev.top) -(rc.bottom - rc.top))/2;
  1468.     }
  1470.     //
  1471.     // Show all the windows and save them all to the devmode.
  1472.     //
  1474.     for (i=0; i < n; i++)
  1475.     {
  1476.         RECT rcPos;
  1477.         POINT ptPos;
  1478.         
  1479.         _Devices[arcDev[i]].pds->GetCurPosition(&rcPos);
  1480.         hwndC = GetDlgItem(hwndP, (int) &_Devices[arcDev[i]]);
  1481.         _DeskToPreview(&arc[i], &rc);
  1483.         rc.right =  MulDiv(RECTWIDTH(rcPos),  _DeskScale, 1000);
  1484.         rc.bottom = MulDiv(RECTHEIGHT(rcPos), _DeskScale, 1000);
  1486.         TraceMsg(TF_GENERAL, "_CleanupRects set Dev = %d, hwnd = %08lxn", arcDev[i], hwndC);
  1487.         TraceMsg(TF_GENERAL, "_CleanupRects window pos %d,%d,%d,%dn", rc.left, rc.top, rc.right, rc.bottom);
  1489.         SetWindowPos(hwndC,
  1490.                      NULL,
  1491.                      rc.left,
  1492.                      rc.top,
  1493.                      rc.right,
  1494.                      rc.bottom,
  1495.                      SWP_NOZORDER);
  1497.         ptPos.x = arc[i].left;
  1498.         ptPos.y = arc[i].top;
  1499.         _Devices[arcDev[i]].pds->SetCurPosition(&ptPos);
  1500.     }
  1502. }
  1504. BOOL CMultiMon::_WriteMultiMonProfile()
  1505. {
  1506.     return WritePrivateProfileString(sc_szVideo, sc_szOptimize, TEXT("bmp"), sc_szQtwIni);
  1507. }
  1509. BOOL CMultiMon::HandleMonitorChange(HWND hwndP, BOOL bMainDlg)
  1510. {
  1511.     if (!bMainDlg && _InSetInfo)
  1512.         return FALSE;
  1514.     SetDirty();
  1516.     if (bMainDlg)
  1517.         BringWindowToTop(hwndP);
  1518.     _CleanupRects(GetParent(hwndP));
  1519.     UpdateActiveDisplay(_pCurDevice);
  1520.     return TRUE;
  1521. }
  1523. BOOL CMultiMon::RegisterPreviewWindowClass(WNDPROC pfnWndProc)
  1524. {
  1525.     TraceMsg(TF_GENERAL, "InitMultiMonitorDlgn");
  1526.     WNDCLASS         cls;
  1528.     cls.hCursor        = LoadCursor(NULL,IDC_ARROW);
  1529.     cls.hIcon          = NULL;
  1530.     cls.lpszMenuName   = NULL;
  1531.     cls.lpszClassName  = TEXT("Monitor32");
  1532.     cls.hbrBackground  = (HBRUSH)(COLOR_DESKTOP + 1);
  1533.     cls.hInstance      = hInstance;
  1534.     cls.style          = CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS;
  1535.     cls.lpfnWndProc    = (WNDPROC)pfnWndProc;
  1536.     cls.cbWndExtra     = SIZEOF(LPVOID);
  1537.     cls.cbClsExtra     = 0;
  1539.     return RegisterClass(&cls);
  1540. }
  1542. LRESULT CALLBACK DeskWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam, UINT uID, DWORD dwRefData);
  1544. BOOL CMultiMon::_InitDisplaySettings(BOOL bExport)
  1545. {
  1546.     HWND             hwndC;
  1547.     int              iItem;
  1548.     DWORD            iDevice = 0;
  1549.     DWORD            iEnum;
  1550.     LONG             iPrimeDevice = -1;
  1551.     TCHAR            ach[128];
  1552.     PMULTIMON_DEVICE pDevice;
  1553.     RECT             rcPrimary;
  1554.     BOOL             f;
  1556.     //
  1557.     // Reset some globals.
  1558.     // Clear out the list box.
  1559.     //
  1561.     _InSetInfo = 1;
  1563.     ComboBox_ResetContent(_hwndList);
  1564.     SetRectEmpty(&_rcDesk);
  1566.     while (hwndC = GetWindow(_hwndDesk, GW_CHILD))
  1567.         DestroyWindow(hwndC);
  1569.     ShowWindow(_hwndDesk, SW_HIDE);
  1571.     if (_himl != NULL)
  1572.     {
  1573.         ImageList_Destroy(_himl);
  1574.         _himl = NULL;
  1575.     }
  1577.     //
  1578.     // Reenumerate all the devices in the system.
  1579.     //
  1580.     for (iDevice = 0, iEnum = 0; iEnum < MONITORS_MAX; iEnum++)
  1581.     {
  1582.         TraceMsg(TF_GENERAL, "Device %d", iEnum);
  1584.         pDevice = &_Devices[iDevice];
  1585.         ZeroMemory(pDevice, sizeof(DISPLAY_DEVICE));
  1586.         pDevice->DisplayDevice.cb = sizeof(DISPLAY_DEVICE);
  1588.         f = EnumDisplayDevices(NULL, iEnum, &pDevice->DisplayDevice, 0);
  1590.         //
  1591.         // ignore device's we cant create a DC for.
  1592.         //
  1593.         if (f)
  1594.         {
  1595.             pDevice->hdc = CreateDC(NULL,(LPTSTR)pDevice->DisplayDevice.DeviceName,NULL,NULL);
  1596.             f = pDevice->hdc != NULL;
  1597.         }
  1599.         //
  1600.         // EnumDisplayDevices is returning NO devices, this is bad
  1601.         // invent a fake device.
  1602.         //
  1603.         if (!f && iEnum == 0)
  1604.         {
  1605.             pDevice->DisplayDevice.DeviceName[0] = 0;
  1607.             LoadString(hInstance, IDS_UNKNOWNDEVICE,
  1608.                 (LPTSTR)&pDevice->DisplayDevice.DeviceString[0],
  1609.                 SIZEOF(pDevice->DisplayDevice.DeviceString));
  1611.             pDevice->DisplayDevice.StateFlags = DISPLAY_DEVICE_PRIMARY_DEVICE;
  1613.             gbExecMode    = EXEC_INVALID_MODE;
  1614.             gbInvalidMode = EXEC_INVALID_DISPLAY_DEVICE;
  1616.             f = TRUE;
  1617.         }
  1619.         if (f)
  1620.         {
  1621.             TraceMsg(TF_GENERAL, "%s   %sn", pDevice->DisplayDevice.DeviceName, pDevice->DisplayDevice.DeviceString);
  1623.             //
  1624.             // We won't even include the MIRRORING drivers in the list for
  1625.             // now.
  1626.             //
  1627.             if (pDevice->DisplayDevice.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER)
  1628.             {
  1629.                 TraceMsg(TF_GENERAL, "Mirroring driver - skip itn");
  1630.                 continue;
  1631.             }
  1633.             //
  1634.             // get the device software key
  1635.             //
  1636.             pDevice->DisplayRegKey[0] = 0;
  1637.             GetDisplayKey(iEnum, pDevice->DisplayRegKey, sizeof(pDevice->DisplayRegKey));
  1639.             TraceMsg(TF_GENERAL, "DeviceKey %s", pDevice->DisplayRegKey);
  1641.             FillMemory(&(pDevice->DisplaySetting), sizeof(DEVMODE), 0);
  1642.             pDevice->DisplaySetting.dmSize = sizeof(DEVMODE);
  1644.             _SetReposition(_hwndDesk, pDevice);
  1645.             pDevice->pds = new CDeviceSettings(_hDlg);
  1646.             if (pDevice->pds->InitSettings(&pDevice->DisplayDevice))
  1647.                 iDevice++;
  1648.             else
  1649.                 delete pDevice->pds;
  1650.         }
  1651.         else
  1652.         {
  1653.             //
  1654.             // Mark the end of the list of devices.
  1655.             //
  1656.             TraceMsg(TF_GENERAL, "End of listn");
  1658.             pDevice->DisplayDevice.cb = 0;
  1659.             break;
  1660.         }
  1661.     }
  1663.     if (iDevice == 0)
  1664.     {
  1665.         ASSERT(0);
  1666.         return FALSE;
  1667.     }
  1668.     //
  1669.     // Because we are getting the registry values, the current state of
  1670.     // the registry may be inconsistent with that of the system:
  1671.     //
  1672.     // EmumDisplayDevices will return the active primary in the
  1673.     // system, which may be different than the actual primary marked in the
  1674.     // registry
  1675.     //
  1676.     // First, we determine if the registry is in a consistent state with
  1677.     // the system by making sure the system primary is also marked as
  1678.     // primary in the regsitry.  This means the primary as returned by
  1679.     // EnumDisplayDevices is also at position 0,0, with the DM_POSITION flag
  1680.     // set.
  1681.     //
  1682.     // If this is not the case, then we will present the current state of the
  1683.     // registry (if there is any) or the primary device only (for a non-
  1684.     // configured system) and ask the user to properly configure the devices.
  1685.     //
  1687.     _pPrimaryDevice = NULL;
  1688.     for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  1689.     {
  1690.         if (_Devices[iDevice].pds->IsAttached() &&
  1691.             (_Devices[iDevice].DisplaySetting.dmPosition.x  == 0)   &&
  1692.             (_Devices[iDevice].DisplaySetting.dmPosition.y == 0)    &&
  1693.             _Devices[iDevice].pds->IsPrimary())
  1694.         {
  1695.             if (iPrimeDevice == -1)
  1696.             {
  1697.                 iPrimeDevice = iDevice;
  1698.                 _pPrimaryDevice = &_Devices[iDevice];
  1699.             }
  1700.             else
  1701.             {
  1702.                 // Multiple primaries are set !
  1703.                 ASSERT(FALSE);
  1704.                 //_pPrimaryDevice = NULL;
  1705.             }
  1706.         }
  1707.     }
  1709.     //
  1710.     // Primary is not set correctly !
  1711.     // Let's show the state of the registry if it appears the user has ever
  1712.     // setup multiple displays in the registry.
  1713.     //
  1715.     if (_pPrimaryDevice == NULL)
  1716.     {
  1717.         for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  1718.         {
  1719.             //
  1720.             // We can have multiple devices at this location since we
  1721.             // support overlapping devices.  Just pick anyone since this is an
  1722.             // error path.  Just make sure we are not picking a remote control
  1723.             // driver.
  1724.             //
  1726.             if (_Devices[iDevice].pds->IsAttached() &&
  1727.                 ((_pPrimaryDevice == NULL) || _Devices[iDevice].pds->IsPrimary()))
  1728.             {
  1729.                 TraceMsg(TF_GENERAL, "InitDisplaySettings: attached device foundn");
  1730.                 
  1731.                 iPrimeDevice = iDevice;
  1732.                 _pPrimaryDevice = &_Devices[iDevice];
  1733.             }
  1734.         }
  1736.         //
  1737.         // If we did find a device, then let's make sure we reset the primary
  1738.         // flag in our structure to be the one we will reset to 0,0
  1739.         //
  1741.         if (_pPrimaryDevice != NULL)
  1742.         {
  1743.             WarnMsg(TEXT("InitDisplaySettings:"), TEXT("Resetting primary"));
  1744.             for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  1745.                 _Devices[iDevice].pds->SetPrimary(&_Devices[iDevice] == _pPrimaryDevice);
  1746.         }
  1747.     }
  1749.     //
  1750.     // If we still do not have a primary device, (no registry information)
  1751.     // assume this is an initial multimonitor setup and we should just deal
  1752.     // with the primary device.
  1753.     //
  1754.     // We will have to setup at least one rectangle.
  1755.     //
  1757.     if (_pPrimaryDevice == NULL)
  1758.     {
  1759.         for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  1760.         {
  1761.             if (_Devices[iDevice].pds->IsAttached())
  1762.             {
  1763.                 POINT ptPos = {0,0};
  1764.                 iPrimeDevice = iDevice;
  1765.                 _pPrimaryDevice = &_Devices[iDevice];
  1766.                 _pPrimaryDevice->pds->SetCurPosition(&ptPos);
  1767.                 break;
  1768.             }
  1769.         }
  1770.     }
  1772.     //
  1773.     // Reset the primary's variables to make sure it is a properly formated
  1774.     // primary entry.
  1775.     //
  1776.     ASSERT(_pPrimaryDevice != NULL);
  1777.     if (_pPrimaryDevice == NULL)
  1778.     {
  1779.         WarnMsg(TEXT("InitDisplaySettings: No Primary Device!!!!"), TEXT(""));
  1780.         return FALSE;
  1781.     }
  1782.     _pPrimaryDevice->pds->SetPrimary(TRUE);
  1783.     _pPrimaryDevice->pds->GetCurPosition(&rcPrimary);
  1785.     if (!lstrcmpi((LPTSTR)_pPrimaryDevice->DisplayDevice.DeviceString,sc_szVGA))
  1786.         _bNoAttach = TRUE;
  1788.     //
  1789.     // compute the max image size needed for a monitor bitmap
  1790.     //
  1791.     // NOTE this must be the max size the images will *ever*
  1792.     // be we cant just take the current max size.
  1793.     // we use the client window size, a child monitor cant be larger than this.
  1794.     //
  1795.     RECT rcDesk;
  1796.     GetClientRect(_hwndDesk, &rcDesk);
  1797.     int cxImage = rcDesk.right;
  1798.     int cyImage = rcDesk.bottom;
  1800.     //
  1801.     // load the monitor bitmap
  1802.     //
  1803.     HBITMAP hbm = (HBITMAP)LoadImage(hInstance, MAKEINTRESOURCE(BMP_MONITOR2),
  1804.             IMAGE_BITMAP, cxImage, cyImage, 0);
  1806.     //
  1807.     // Go through all the devices to count them
  1808.     //
  1809.     for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  1810.         ;
  1812.     // For the ASSERT: We should have at least the primary device
  1813.     ASSERT(iDevice > 0);
  1815.     _NumDevices = iDevice;
  1817.     //
  1818.     // Go through all the devices one last time to create the windows
  1819.     //
  1820.     for (iDevice = 0; _Devices[iDevice].DisplayDevice.cb != 0; iDevice++)
  1821.     {
  1822.         TCHAR szDisplay[256];
  1823.         pDevice = &_Devices[iDevice];
  1824.         MonitorData md = {0};
  1825.         RECT rcPos;
  1826.         LPVOID pWindowData = (LPVOID)this;
  1827.         pDevice->DisplayIndex = iDevice + 1;
  1828.         _GetDisplayName(pDevice, szDisplay);
  1829.         iItem = ComboBox_AddString(_hwndList, szDisplay);
  1831.         pDevice->ComboBoxItem = iItem;
  1833.         ComboBox_SetItemData(_hwndList,
  1834.                              iItem,
  1835.                              (DWORD)pDevice);
  1837.         //
  1838.         // If the monitor is part of the desktop, show it on the screen
  1839.         // otherwise keep it invisible.
  1840.         //
  1841.         // On NT, we require all the devices to have the same color depth.
  1842.         // Don't let them on the desktop if they don't
  1843.         //
  1844. #ifdef WINNT
  1845.         if (pDevice->DisplaySetting.dmBitsPerPel != _pPrimaryDevice->DisplaySetting.dmBitsPerPel)
  1846.             pDevice->pds->SetAttached(FALSE);
  1847. #endif
  1848.         wsprintf(ach, TEXT("%d"), iDevice + 1);
  1850.         if (!pDevice->pds->IsAttached())
  1851.         {
  1852.             // By default set the unattached monitors to the right of the primary monitor
  1853.             POINT ptPos = {rcPrimary.right, rcPrimary.top};
  1854.             pDevice->pds->SetCurPosition(&ptPos);
  1855.         }
  1857.         pDevice->pds->GetCurPosition(&rcPos);
  1859.         if (bExport)
  1860.         {
  1861.             md.dwSize = SIZEOF(MonitorData);
  1862.             if ( pDevice->pds->IsPrimary() )
  1863.                 md.dwStatus |= MD_PRIMARY;
  1864.             if ( pDevice->pds->IsAttached() )
  1865.                 md.dwStatus |= MD_ATTACHED;
  1866.             md.rcPos = rcPos;
  1868.             pWindowData = &md;
  1869.         }
  1871.         if (_himl == NULL)
  1872.         {
  1873.             // use ILC_COLORDDB to always get stipple selection
  1874.             // UINT flags = ILC_COLORDDB | ILC_MASK;
  1876.             // use ILC_COLOR4   to get HiColor selection
  1877.             UINT flags = ILC_COLOR4 | ILC_MASK;
  1879.             _himl = ImageList_Create(cxImage, cyImage, flags, _NumDevices, 1);
  1880.             ASSERT(_himl);
  1881.             ImageList_SetBkColor(_himl, GetSysColor(COLOR_APPWORKSPACE));
  1882.         }
  1884.         pDevice->w      = -1;
  1885.         pDevice->h      = -1;
  1886.         pDevice->himl   = _himl;
  1887.         pDevice->iImage = ImageList_AddMasked(_himl, hbm, CLR_DEFAULT);
  1889.         TraceMsg(TF_GENERAL, "InitDisplaySettings: Creating preview windows %s at %d %d %d %d",
  1890.                  ach, rcPos.left, rcPos.top, rcPos.right, rcPos.bottom);
  1891.         hwndC = CreateWindowEx(
  1892.                                0, // WS_EX_CLIENTEDGE,
  1893.                                TEXT("Monitor32"), ach,
  1894.                                WS_CLIPSIBLINGS | /* WS_DLGFRAME | */ WS_VISIBLE | WS_CHILD,
  1895.                                rcPos.left, rcPos.top, RECTWIDTH(rcPos), RECTHEIGHT(rcPos),
  1896.                                _hwndDesk,
  1897.                                (HMENU)pDevice,
  1898.                                hInstance,
  1899.                                pWindowData);
  1901.         ASSERT(hwndC);
  1902.     }
  1904.     //  nuke the temp monitor bitmap
  1905.     if (hbm)
  1906.         DeleteObject(hbm);
  1908.     // Set the primary device as the current device
  1909.     ASSERT(iPrimeDevice >= 0);
  1910.     ComboBox_SetCurSel(_hwndList, iPrimeDevice);
  1911.     _pCurDevice = _pPrimaryDevice;
  1913.     // Initialize all the constants and the settings fields
  1914.     _DeskScale = 1000;
  1915.     _DeskOff.x = 0;
  1916.     _DeskOff.y = 0;
  1917.     _CleanupRects(_hwndDesk);
  1918.     _VerifyPrimaryMode(FALSE);
  1919.     UpdateActiveDisplay(_pCurDevice);
  1920.     ShowWindow(_hwndDesk, SW_SHOW);
  1921.     _InSetInfo--;
  1922.     return TRUE;
  1923. }
  1924.                     
  1925. //-----------------------------------------------------------------------------
  1926. void CMultiMon::InitMultiMonitorDlg(HWND hDlg)
  1927. {
  1928.     HCURSOR hcur;
  1930.     hcur = SetCursor(LoadCursor(NULL, IDC_WAIT));
  1931.     _hDlg = hDlg;
  1932.     _hwndDesk = GetDlgItem(_hDlg, IDC_DISPLAYDESK);
  1933.     _hwndList = GetDlgItem(_hDlg, IDC_DISPLAYLIST);
  1934.     
  1935. #ifdef WINNT
  1936.     //
  1937.     // Determine in what mode we are running the applet before getting information
  1938.     //
  1939.     _vPreExecMode();
  1940. #endif
  1943.     RegisterPreviewWindowClass(&MonitorWindowProc);
  1944.     _InitDisplaySettings(FALSE);
  1946.     // Now: depends on whether we have a multimon system, change the UI
  1947.     if (_NumDevices == 1)
  1948.     {
  1949.         HWND hwndMultimonHelp = GetDlgItem(_hDlg, IDC_MULTIMONHELP);
  1950.         ShowWindow(hwndMultimonHelp, SW_HIDE);
  1951.         ShowWindow(_hwndDesk, SW_HIDE);
  1952.         
  1953.         // set up bitmaps for sample screen
  1954.         _hbmScrSample = LoadMonitorBitmap( TRUE ); // let them do the desktop
  1955.         SendDlgItemMessage(_hDlg, IDC_SCREENSAMPLE, STM_SETIMAGE, IMAGE_BITMAP, (DWORD)_hbmScrSample);
  1956.         
  1957.         // get a base copy of the bitmap for when the "internals" change
  1958.         _hbmMonitor = LoadMonitorBitmap( FALSE ); // we'll do the desktop
  1959.         
  1960.         //Hide the combo box, keep the static text
  1961.         ShowWindow(_hwndList, SW_HIDE);
  1963.         //Set the name of the primary in the static text
  1964.         //strip the first token off (this is the number we dont want it)
  1965.         TCHAR *pch, szDisplay[MAX_PATH];
  1966.         _GetDisplayName(_pPrimaryDevice, szDisplay);
  1967.         for (pch=szDisplay; *pch && *pch != TEXT(' '); pch++);
  1968.         for (;*pch && *pch == TEXT(' '); pch++);
  1969.         SetDlgItemText(_hDlg, IDC_DISPLAYTEXT, pch);
  1970.     }
  1971.     else if (_NumDevices > 0)
  1972.     {
  1973.         //Hide the static text, keep the combo box
  1974.         ShowWindow(GetDlgItem(_hDlg, IDC_DISPLAYTEXT), SW_HIDE);
  1976.         // Hide the Multimon version of the preview objects
  1977.         ShowWindow(GetDlgItem(_hDlg, IDC_SCREENSAMPLE), SW_HIDE);
  1979.         // In case of multiple devices, subclass the _hwndDesk window for key board support
  1980.         SetWindowSubclass(_hwndDesk, DeskWndProc, 0, (DWORD)this);
  1981.         ShowWindow(_hwndDesk, SW_SHOW);
  1982.     }
  1985. #ifdef WINNT
  1986.     //
  1987.     // Determine if any errors showed up during enumerations and initialization
  1988.     //
  1989.     _vPostExecMode();
  1990.     
  1991.     //
  1992.     // Now tell the user what we found out during initialization
  1993.     // Errors, or what we found during detection
  1994.     //
  1996.     PostMessage(hDlg, MSG_DSP_SETUP_MESSAGE, 0, 0);
  1997.     //
  1998.     // Since this could have taken a very long time, just make us visible
  1999.     // if another app (like progman) came up.
  2000.     //
  2002.     ShowWindow(hDlg, SW_SHOW);
  2003. #endif
  2005.     SetCursor(hcur);
  2006. }
  2009. LRESULT CALLBACK DeskWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam, UINT uID, DWORD dwRefData)
  2010. {
  2011.     CMultiMon * pcmm = (CMultiMon *)dwRefData;
  2012.     HWND hwndC;
  2013.     HDC  hdc;
  2014.     RECT rcPos;
  2015.     BOOL bMoved = TRUE;
  2016.     LRESULT lret;
  2017.     int iMonitor;
  2018.     switch(message)
  2019.     {
  2020.         case WM_GETDLGCODE:
  2021.             return DLGC_WANTCHARS | DLGC_WANTARROWS;
  2023.         case WM_KILLFOCUS:
  2024.             RedrawWindow(hDlg, NULL, NULL, RDW_INVALIDATE);
  2025.             break;
  2027.         case WM_PAINT:
  2028.             if (GetFocus() != hDlg)
  2029.                 break;
  2030.             lret = DefSubclassProc(hDlg, message, wParam, lParam);
  2032.             // Fall through
  2033.         case WM_SETFOCUS:
  2034.             hdc = GetDC(hDlg);
  2035.             GetClientRect(hDlg, &rcPos);
  2036.             InflateRect(&rcPos, -1, -1);
  2037.             //DrawFocusRect(hdc, &rcPos);
  2038.             DrawEdge(hdc, &rcPos, EDGE_SUNKEN, BF_TOP | BF_BOTTOM | BF_LEFT | BF_RIGHT);
  2039.             ReleaseDC(hDlg, hdc);
  2041.             if (message == WM_PAINT)
  2042.                 return lret;
  2043.             break;            
  2045.         case WM_LBUTTONDOWN:
  2046.             SetFocus(hDlg);
  2047.             break;
  2048.             
  2049.         case WM_KEYDOWN:
  2050. #define MONITORMOVEUNIT 3
  2051.             hwndC = pcmm->GetCurDeviceHwnd();
  2052.             GetWindowRect(hwndC, &rcPos);
  2053.             MapWindowRect(NULL, hDlg, &rcPos);
  2054.             switch(wParam)
  2055.             {
  2056.                 case VK_LEFT:
  2057.                     MoveWindow(hwndC, rcPos.left - MONITORMOVEUNIT, rcPos.top, RECTWIDTH(rcPos), RECTHEIGHT(rcPos), TRUE);
  2058.                     break;
  2059.                 case VK_RIGHT:
  2060.                     MoveWindow(hwndC, rcPos.left + MONITORMOVEUNIT, rcPos.top, RECTWIDTH(rcPos), RECTHEIGHT(rcPos), TRUE);
  2061.                     break;
  2062.                 case VK_UP:
  2063.                     MoveWindow(hwndC, rcPos.left, rcPos.top - MONITORMOVEUNIT, RECTWIDTH(rcPos), RECTHEIGHT(rcPos), TRUE);
  2064.                     break;
  2065.                 case VK_DOWN:
  2066.                     MoveWindow(hwndC, rcPos.left, rcPos.top + MONITORMOVEUNIT, RECTWIDTH(rcPos), RECTHEIGHT(rcPos), TRUE);
  2067.                     break;
  2068.                 default:
  2069.                     bMoved = FALSE;
  2070.                     break;
  2071.             }
  2072. #undef MONITORMOVEUNIT
  2073.             
  2074.             pcmm->HandleMonitorChange(hwndC, FALSE);
  2075.             break;
  2077.         case WM_CHAR:
  2078.             if (pcmm)
  2079.             {
  2080.                 iMonitor = (TCHAR)wParam - TEXT('0');
  2081.                 if ((iMonitor == 0) && (pcmm->GetNumDevices() >= 10))
  2082.                     iMonitor = 10;
  2084.                 if ((iMonitor > 0) && (iMonitor <= pcmm->GetNumDevices()))
  2085.                 {
  2086.                     HWND hwndList = GetDlgItem(GetParent(hDlg), IDC_DISPLAYLIST);
  2087.                     ComboBox_SetCurSel(hwndList, iMonitor - 1);
  2088.                     pcmm->UpdateActiveDisplay(NULL);
  2089.                     return 0;
  2090.                 }
  2091.             }
  2092.             break;
  2094.         case WM_DESTROY:
  2095.             RemoveWindowSubclass(hDlg, DeskWndProc, 0);
  2096.             break;
  2098.         default:
  2099.             break;
  2100.     }
  2101.     
  2102.     return DefSubclassProc(hDlg, message, wParam, lParam);
  2103. }
  2106. //-----------------------------------------------------------------------------
  2107. //
  2108. // Callback functions PropertySheet can use
  2109. //
  2110. BOOL CALLBACK
  2111. MultiMonitorDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  2112. {
  2113.     CMultiMon * pcmm = (CMultiMon *) GetWindowLong(hDlg, DWL_USER);
  2114.     switch (message)
  2115.     {
  2116.         case WM_INITDIALOG:
  2117.             ASSERT(!pcmm);
  2118.             pcmm = new CMultiMon;
  2119.             if (pcmm)
  2120.             {
  2121.                 SetWindowLong(hDlg, DWL_USER, (LPARAM)pcmm);
  2122.                 ghwndPropSheet = GetParent(hDlg);
  2123.                 pcmm->InitMultiMonitorDlg(hDlg);
  2125.                 //
  2126.                 // if we have a invalid mode force the user to Apply
  2127.                 //
  2128.                 if (gbExecMode == EXEC_INVALID_MODE)
  2129.                     pcmm->SetDirty();
  2131.                 return TRUE;
  2132.             }
  2133.             break;
  2134.         case WM_DESTROY:
  2135.             if (pcmm)
  2136.             {
  2137.                 pcmm->WndProc(message, wParam, lParam);
  2138.                 SetWindowLong(hDlg, DWL_USER, NULL);
  2139.                 delete pcmm;
  2140.             }
  2141.             break;
  2142.         default:
  2143.             if (pcmm)
  2144.                 return pcmm->WndProc(message, wParam, lParam);
  2145.             break;
  2146.     }
  2148.     return FALSE;
  2149. }
  2151. void CMultiMon::_SetPreviewScreenSize(int HRes, int VRes, int iOrgXRes, int iOrgYRes)
  2152. {
  2153.     HBITMAP hbmOld;
  2154.     HBRUSH hbrOld;
  2155.     HDC hdcMem2;
  2157.     // stretching the taskbar could get messy, we'll only do the desktop
  2158.     int mon_dy = MON_DY - MON_TRAY;
  2160.     // init to identical extents
  2161.     SIZE dSrc = { MON_DX, mon_dy };
  2162.     SIZE dDst = { MON_DX, mon_dy };
  2164.     // set up a work area to play in
  2165.     if (!_hbmMonitor || !_hbmScrSample)
  2166.         return;
  2167.     hdcMem2 = CreateCompatibleDC(g_hdcMem);
  2168.     if (!hdcMem2)
  2169.         return;
  2170.     SelectObject(hdcMem2, _hbmScrSample);
  2171.     hbmOld = (HBITMAP)SelectObject(g_hdcMem, _hbmMonitor);
  2173.     // see if we need to shrink either aspect of the image
  2174.     if (HRes > iOrgXRes || VRes > iOrgYRes)
  2175.     {
  2176.         // make sure the uncovered area will be seamless with the desktop
  2177.         RECT rc = { MON_X, MON_Y, MON_X + MON_DX, MON_Y + mon_dy };
  2178.         HBRUSH hbr =
  2179.                     CreateSolidBrush( GetPixel( g_hdcMem, MON_X + 1, MON_Y + 1 ) );
  2181.         FillRect(hdcMem2, &rc, hbr);
  2182.         DeleteObject( hbr );
  2183.     }
  2185.     // stretch the image to reflect the new resolution
  2186.     if( HRes > iOrgXRes )
  2187.         dDst.cx = MulDiv( MON_DX, iOrgXRes, HRes );
  2188.     else if( HRes < iOrgXRes )
  2189.         dSrc.cx = MulDiv( MON_DX, HRes, iOrgXRes );
  2191.     if( VRes > iOrgYRes )
  2192.         dDst.cy = MulDiv( mon_dy, iOrgYRes, VRes );
  2193.     else if( VRes < iOrgYRes )
  2194.         dSrc.cy = MulDiv( mon_dy, VRes, iOrgYRes );
  2196.     SetStretchBltMode( hdcMem2, COLORONCOLOR );
  2197.     StretchBlt( hdcMem2, MON_X, MON_Y, dDst.cx, dDst.cy,
  2198.                 g_hdcMem, MON_X, MON_Y, dSrc.cx, dSrc.cy, SRCCOPY );
  2200.     // now fill the new image's desktop with the possibly-dithered brush
  2201.     // the top right corner seems least likely to be hit by the stretch...
  2202.     hbrOld = (HBRUSH)SelectObject( hdcMem2, GetSysColorBrush( COLOR_DESKTOP ) );
  2203.     ExtFloodFill(hdcMem2, MON_X + MON_DX - 2, MON_Y+1,
  2204.                  GetPixel(hdcMem2, MON_X + MON_DX - 2, MON_Y+1), FLOODFILLSURFACE);
  2206.     // clean up after ourselves
  2207.     SelectObject( hdcMem2, hbrOld );
  2208.     SelectObject( hdcMem2, g_hbmDefault );
  2209.     DeleteObject( hdcMem2 );
  2210.     SelectObject( g_hdcMem, hbmOld );    
  2211. }
  2213. void CMultiMon::_RedrawDeskPreviews()
  2214. {
  2215.     if (_NumDevices > 1)
  2216.     {
  2217.         _CleanupRects(_hwndDesk);
  2218.         RedrawWindow(_hwndDesk, NULL, NULL, RDW_ALLCHILDREN | RDW_ERASE | RDW_INVALIDATE);
  2219.     }
  2220.     else if (_pCurDevice && _pCurDevice->pds)
  2221.     {
  2222.         RECT rcPos, rcOrigPos;
  2223.         _pCurDevice->pds->GetCurPosition(&rcPos);
  2224.         _pCurDevice->pds->GetOrigPosition(&rcOrigPos);
  2225.         _SetPreviewScreenSize(RECTWIDTH(rcPos), RECTHEIGHT(rcPos), RECTWIDTH(rcOrigPos), RECTHEIGHT(rcOrigPos));
  2226.         // only invalidate the "screen" part of the monitor bitmap
  2227.         rcPos.left = MON_X;
  2228.         rcPos.top = MON_Y;
  2229.         rcPos.right = MON_X + MON_DX + 2;  // fudge (trust me)
  2230.         rcPos.bottom = MON_Y + MON_DY + 1; // fudge (trust me)
  2231.         InvalidateRect(GetDlgItem(_hDlg, IDC_SCREENSAMPLE), &rcPos, FALSE);
  2232.     }
  2233. }
  2235. BOOL CMultiMon::_HandleApply()
  2236. {
  2237.     BOOL bReboot = FALSE;
  2238.     BOOL bTest = FALSE;
  2239.     int  iTestResult;
  2240.     int  iSave;
  2241. #ifdef WINNT
  2242.     //
  2243.     // If a new driver is installed, we just want to tell the
  2244.     // system to reboot.
  2245.     //
  2246.     // NOTE - this is only until we can get drivers to load on the fly.
  2247.     //
  2248.     if (_bNewDriver)
  2249.     {
  2250.         PropSheet_RestartWindows(ghwndPropSheet);
  2251.         SetWindowLong(_hDlg, DWL_MSGRESULT, PSNRET_NOERROR);
  2252.         return TRUE;
  2253.     }
  2254. #endif
  2256. #ifndef WINNT   //BUGBUG should we do this on NT???
  2257.     //
  2258.     // if the user hits apply when we dont have a valid display device
  2259.     // force VGA mode in the registry and restart.
  2260.     //
  2261.     if (gbExecMode    == EXEC_INVALID_MODE &&
  2262.         gbInvalidMode == EXEC_INVALID_DISPLAY_DEVICE)
  2263.     {
  2264.         NukeDisplaySettings();
  2265.         PropSheet_RestartWindows(ghwndPropSheet);
  2266.         return TRUE;
  2267.     }
  2269.     //
  2270.     // if we are in VGA fallback mode, and the user stays in VGA mode
  2271.     // also nuke all settings from the registry.
  2272.     //
  2273.     if (gbExecMode    == EXEC_INVALID_MODE &&
  2274.         gbInvalidMode == EXEC_INVALID_DISPLAY_MODE &&
  2275.         _pPrimaryDevice->pds->GetColorBits() == 4)
  2276.     {
  2277.         NukeDisplaySettings();
  2278.         PropSheet_RestartWindows(ghwndPropSheet);
  2279.         return TRUE;
  2280.     }
  2281. #endif
  2283.     // Test the new settings first
  2284.     iTestResult = _SaveDisplaySettings(CDS_TEST);
  2286.     if (iTestResult == DISP_CHANGE_RESTART)
  2287.         bReboot = TRUE;
  2288.     else if (iTestResult < 0)
  2289.         return FALSE;
  2290.     
  2291.     // Ask first and then change the settings.
  2292.     if (!bReboot && _AnyColorChange())
  2293.     {
  2294.         int iDynaResult = AskDynaCDS(_hDlg);
  2295.         if (iDynaResult == -1)
  2296.             return FALSE;
  2297.         else if (iDynaResult == 0)
  2298.             bReboot = TRUE;
  2299.     }
  2301.     if (!bReboot && _AnyResolutionChange())
  2302.     {
  2303.         TCHAR szWarnFlicker[510];
  2304.         LPTSTR pstr;
  2306.         LoadString(hInstance, IDS_WARNFLICK1, szWarnFlicker, SIZEOF(szWarnFlicker));
  2307.         pstr = szWarnFlicker + lstrlen(szWarnFlicker);
  2308.         LoadString(hInstance, IDS_WARNFLICK2, pstr, SIZEOF(szWarnFlicker) - (pstr - (LPTSTR)szWarnFlicker));
  2309.         if (ShellMessageBox(hInstance, GetParent(_hDlg), szWarnFlicker, NULL, MB_OKCANCEL | MB_ICONINFORMATION) != IDOK)
  2310.             return FALSE;
  2311.         bTest = TRUE;
  2312.     }
  2314.     iSave = _SaveDisplaySettings(CDS_UPDATEREGISTRY | CDS_NORESET);
  2316.     // This shouldn't fail because we already tested it above.
  2317.     ASSERT(iSave >= 0);
  2318.     if (iSave == DISP_CHANGE_RESTART)
  2319.         bReboot = TRUE;
  2320.     else if ((iSave < 0) || (bTest && !_TestNewSettingsChange()))
  2321.     {
  2322.         _RestoreDisplaySettings();
  2323.         return FALSE;
  2324.     }
  2325.     else
  2326.         _ConfirmDisplaySettingsChange();
  2327.     
  2328.     if (bReboot)
  2329.         PropSheet_RestartWindows(ghwndPropSheet);
  2331.     return TRUE;
  2332. }
  2334. CMultiMon::_HandleHScroll(HWND hwndTB, int iCode, int iPos)
  2335. {
  2336.     int cRes = SendMessage(hwndTB, TBM_GETRANGEMAX, TRUE, 0);
  2337.     int iRes = _pCurDevice->pds->GetCurResolution();
  2339.     switch(iCode ) {
  2340.         case TB_LINEUP:
  2341.         case TB_PAGEUP:
  2342.             if (iRes != 0)
  2343.                 iRes--;
  2344.             break;
  2346.         case TB_LINEDOWN:
  2347.         case TB_PAGEDOWN:
  2348.             if (++(iRes) >= cRes)
  2349.                 iRes = cRes;
  2350.             break;
  2352.         case TB_BOTTOM:
  2353.             iRes = cRes;
  2354.             break;
  2356.         case TB_TOP:
  2357.             iRes = 0;
  2358.             break;
  2360.         case TB_THUMBTRACK:
  2361.         case TB_THUMBPOSITION:
  2362.             iRes = iPos;
  2363.             break;
  2365.         default:
  2366.             return FALSE;
  2367.     }
  2370.     _pCurDevice->pds->ChangeResolution(iRes);
  2371.     _VerifyPrimaryMode(TRUE);
  2373.     if ( (gbExecMode == EXEC_NORMAL) ||
  2374.          (gbExecMode == EXEC_INVALID_MODE) ||
  2375.          (gbExecMode == EXEC_DETECT) ) {
  2377.         //
  2378.         // Set the apply button if resolution has changed
  2379.         //
  2381.         if (_pCurDevice->pds->IsResolutionChanged())
  2382.             SetDirty();
  2384.         return 0;
  2385.     }
  2387.     return TRUE;
  2388. }
  2390. void CMultiMon::_ForwardToChildren(UINT msg, WPARAM wParam, LPARAM lParam)
  2391. {
  2392.     HWND hwndC = GetDlgItem(_hDlg, IDC_SCREENSIZE);
  2393.     if (hwndC)
  2394.         SendMessage(hwndC, msg, wParam, lParam);
  2395. }
  2397. LRESULT CALLBACK CMultiMon::WndProc(UINT message, WPARAM wParam, LPARAM lParam)
  2398. {
  2399.     NMHDR FAR *lpnm;
  2400.     HWND hwndC;
  2401.     HWND hwndSample;
  2402.     HBITMAP hbm;
  2403.     
  2404.     switch (message)
  2405.     {
  2406.     case WM_NOTIFY:
  2407.         lpnm = (NMHDR FAR *)lParam;
  2408.         switch (lpnm->code)
  2409.         {
  2410.             case PSN_APPLY:
  2411.                 if (IsDirty())
  2412.                 {
  2413.                     _HandleApply();
  2414.                     SetDirty(FALSE);
  2416.                     // if the close flag is false, rebuild the settings
  2417.                     if (((PSHNOTIFY*)lParam)->lParam == FALSE)
  2418.                         _RebuildDisplaySettings(TRUE);
  2419.                 }
  2420.                 break;
  2421.             default:
  2422.                 return FALSE;
  2423.         }
  2424.         break;
  2426.     case WM_CTLCOLORSTATIC:
  2427.         if (GetDlgCtrlID((HWND)lParam) == IDC_DISPLAYDESK)
  2428.         {
  2429.             return (BOOL)(UINT)GetSysColorBrush(COLOR_APPWORKSPACE);
  2430.         }
  2431.         return FALSE;
  2434.     case WM_COMMAND:
  2436.         switch (GET_WM_COMMAND_ID(wParam, lParam))
  2437.         {
  2438. #ifdef WINNT
  2439.         case IDC_DISPLAYPRIME:
  2440. #endif
  2441.         case IDC_DISPLAYUSEME:
  2442.         {
  2443.             //
  2444.             // Don't pop up warning dialog box if this display is already attached
  2445.             // or if there are already more than 1 display
  2446.             //
  2447.             BOOL bWarn = (!_pCurDevice->pds->IsAttached() && GetNumberOfAttachedDisplays() == 1);
  2448.             
  2449.             if (!ToggleAttached(_pCurDevice, GET_WM_COMMAND_ID(wParam, lParam) ==
  2450.                                 IDC_DISPLAYPRIME))
  2451.                 return FALSE;
  2452.             
  2453.             if ((GET_WM_COMMAND_ID(wParam, lParam) == IDC_DISPLAYUSEME) && bWarn
  2454.                 && !WarnUserAboutCompatibility(_hDlg))
  2455.             {
  2456.                 _pCurDevice->pds->SetAttached(FALSE);
  2457.                 UpdateActiveDisplay(_pCurDevice);
  2458.             }
  2459.             else
  2460.             {
  2461.                 hwndC = GetDlgItem(_hwndDesk, (int) _pCurDevice);
  2462.                 HandleMonitorChange(hwndC, TRUE);
  2463.             }
  2464.             return TRUE;
  2465.         }  
  2466.         case IDC_DISPLAYLIST:
  2467.             switch (GET_WM_COMMAND_CMD(wParam, lParam))
  2468.             {
  2469.             case CBN_DBLCLK:
  2470.                 goto DoDeviceSettings;
  2472.             case CBN_SELCHANGE:
  2473.                 UpdateActiveDisplay(NULL);
  2474.                 break;
  2476.             default:
  2477.                 return FALSE;
  2478.             }
  2479.             break;
  2481.         case IDC_DISPLAYPROPERTIES:
  2482.             switch (GET_WM_COMMAND_CMD(wParam, lParam))
  2483.             {
  2484.             DoDeviceSettings:
  2485.             case BN_CLICKED:
  2486.                 if (IsWindowEnabled(GetDlgItem(_hDlg, IDC_DISPLAYPROPERTIES)))
  2487.                 {
  2488.                     _DoAdvancedSettingsSheet();
  2489.                     _RebuildDisplaySettings(TRUE);
  2490.                 }
  2491.                 break;
  2493.             default:
  2494.                 return FALSE;
  2495.             }
  2496.             break;
  2498.         case IDC_COLORBOX:
  2499.             switch(GET_WM_COMMAND_CMD(wParam, lParam))
  2500.             {
  2501.                 
  2502.                 case CBN_SELCHANGE:
  2503.                 {
  2504.                     HWND hwndColorBox = GetDlgItem(_hDlg, IDC_COLORBOX);
  2505.                     int iClr = ComboBox_GetCurSel(hwndColorBox);
  2506.                     
  2507.                     if (iClr != CB_ERR ) {
  2509.                         _pCurDevice->pds->ChangeColor(iClr);
  2510.                         _VerifyPrimaryMode(TRUE);
  2511.                     }
  2513.                     break;
  2514.                 }
  2515.                 default:
  2516.                     break;
  2517.             }
  2519.             break;
  2520.             
  2521.         default:
  2522.             return FALSE;
  2523.         }
  2526.         //
  2527.         // Enable the apply button only if we are not in setup.
  2528.         //
  2529.         
  2530.         if ( (gbExecMode == EXEC_NORMAL) ||
  2531.              (gbExecMode == EXEC_INVALID_MODE) ||
  2532.              (gbExecMode == EXEC_DETECT) ) {
  2533.             
  2534.             //
  2535.             // Set the apply button if something changed
  2536.             //
  2537.             if (_pCurDevice->pds->IsResolutionChanged() ||
  2538.                 _pCurDevice->pds->IsColorChanged() ||
  2539.                 _pCurDevice->pds->IsFrequencyChanged())
  2540.             {
  2541.                 SetDirty();
  2542.             }
  2544.             return TRUE;
  2545.         }
  2546.         break;
  2548.     case WM_HSCROLL:
  2549.         _HandleHScroll((HWND)lParam, (int) LOWORD(wParam), (int) HIWORD(wParam));
  2550.         break;
  2551.         
  2552.     case WM_HELP:
  2553.         WinHelp((HWND)((LPHELPINFO)lParam)->hItemHandle, TEXT("mds.hlp"), HELP_WM_HELP,
  2554.             (DWORD)(LPTSTR)sc_MultiMonitorHelpIds);
  2555.         break;
  2557.     case WM_CONTEXTMENU:
  2558.         WinHelp((HWND)wParam, TEXT("mds.hlp"), HELP_CONTEXTMENU,
  2559.             (DWORD)(LPTSTR)sc_MultiMonitorHelpIds);
  2560.         break;
  2562.     case WM_WININICHANGE:
  2563.         _ForwardToChildren(message, wParam, lParam);
  2564.         break;
  2566.     case WM_SYSCOLORCHANGE:
  2567.         if (_himl)
  2568.             ImageList_SetBkColor(_himl, GetSysColor(COLOR_APPWORKSPACE));
  2569.         _ForwardToChildren(message, wParam, lParam);
  2570.         break;
  2572.     case WM_DISPLAYCHANGE:
  2573.         _RebuildDisplaySettings();
  2574.         _RedrawDeskPreviews();
  2575.         _ForwardToChildren(message, wParam, lParam);
  2576.         break;
  2577.         
  2578.     case WM_DESTROY:
  2579.         TraceMsg(TF_GENERAL, "WndProc:: WM_DESTROY");
  2580.         hwndSample = GetDlgItem(_hDlg, IDC_COLORSAMPLE);
  2581.         if (hbm = (HBITMAP)SendMessage(hwndSample, STM_SETIMAGE, IMAGE_BITMAP, NULL))
  2582.             DeleteObject(hbm);
  2583.         
  2584.         if (_NumDevices == 1)
  2585.         {
  2586.             hwndSample = GetDlgItem(_hDlg, IDC_SCREENSAMPLE);
  2587.             if (hbm = (HBITMAP)SendMessage(hwndSample, STM_SETIMAGE, IMAGE_BITMAP, NULL))
  2588.                 DeleteObject(hbm);
  2589.             
  2590.             if (_hbmScrSample && (GetObjectType(_hbmScrSample) != 0))
  2591.                 DeleteObject(_hbmScrSample);
  2592.             if (_hbmMonitor && (GetObjectType(_hbmMonitor) != 0))
  2593.                 DeleteObject(_hbmMonitor);
  2594.         }
  2596.         _DestroyDisplaySettings();
  2597.         break;
  2598.         
  2599. #ifdef WINNT
  2600.     case MSG_DSP_SETUP_MESSAGE:
  2601.         return _InitMessage();
  2602. #endif
  2603.         // MultiMonitor CPL specific messages
  2604.     case MM_REDRAWPREVIEW:
  2605.         _RedrawDeskPreviews();
  2606.         break;
  2608.     default:
  2609.         return FALSE;
  2610.     }
  2612.     return TRUE;
  2613. }
  2616. // IUnknown methods
  2617. HRESULT CMultiMon::QueryInterface(REFIID riid, LPVOID * ppvObj)
  2618. { 
  2619.     // ppvObj must not be NULL
  2620.     ASSERT(ppvObj != NULL);
  2621.     
  2622.     if (ppvObj == NULL)
  2623.         return E_INVALIDARG;
  2625.     *ppvObj = NULL;
  2626.     if (IsEqualIID(riid, IID_IUnknown))
  2627.         *ppvObj = SAFECAST(this, IUnknown *);
  2628.     else if (IsEqualIID(riid, IID_IMultiMonConfig))
  2629.         *ppvObj = SAFECAST(this, IMultiMonConfig *);
  2630.     else
  2631.         return E_NOINTERFACE;
  2632.      
  2633.     
  2634.     AddRef();
  2635.     return S_OK;
  2636. }
  2639. ULONG CMultiMon::AddRef()
  2640. {
  2641.     _cRef++;
  2642.     return _cRef;
  2643. }
  2645. ULONG CMultiMon::Release()
  2646. {
  2647.     _cRef--;
  2648.     if (_cRef > 0)
  2649.         return _cRef;
  2651.     delete this;
  2652.     return 0;
  2653. }
  2656. // IMultiMonConfig methods
  2657. HRESULT CMultiMon::Initialize(HWND hwndHost, WNDPROC pfnWndProc, DWORD dwReserved)
  2658. {
  2659.     WNDCLASS wc = {0};
  2660.     HRESULT hr = E_FAIL;
  2662.     if (hwndHost && RegisterPreviewWindowClass(pfnWndProc))
  2663.     {
  2664.         _hwndDesk = hwndHost;
  2665.         if (_InitDisplaySettings(TRUE))
  2666.             hr = S_OK;
  2667.     }
  2668.     return hr;
  2669. }
  2671. HRESULT CMultiMon::GetNumberOfMonitors(int * pCMon, DWORD dwReserved)
  2672. {
  2673.     if (pCMon)
  2674.     {
  2675.         *pCMon = _NumDevices;
  2676.         return S_OK;
  2677.     }
  2679.     return E_FAIL;
  2680. }
  2682. HRESULT CMultiMon::GetMonitorData(int iMonitor, MonitorData * pmd, DWORD dwReserved)
  2683. {
  2684.     ASSERT(pmd);
  2685.     if ((pmd == NULL) || (iMonitor >= _NumDevices))
  2686.         return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
  2688.     PMULTIMON_DEVICE pDevice = &_Devices[iMonitor];
  2690.     pmd->dwSize = SIZEOF(MonitorData);
  2691.     if ( pDevice->pds->IsPrimary() )
  2692.         pmd->dwStatus |= MD_PRIMARY;
  2693.     if ( pDevice->pds->IsAttached() )
  2694.         pmd->dwStatus |= MD_ATTACHED;
  2695.     pDevice->pds->GetCurPosition(&pmd->rcPos);
  2697.     return S_OK;
  2698. }
  2700. HRESULT CMultiMon::Paint(int iMonitor, DWORD dwReserved)
  2701. {
  2702.     _RedrawDeskPreviews();
  2704.     return S_OK;
  2705. }
  2707. STDAPI CMultiMonConfig_CreateInstance(IUnknown* pUnkOuter, REFIID riid, OUT LPVOID * ppvOut)
  2708. {
  2709.     HRESULT hr = E_OUTOFMEMORY;
  2711.     *ppvOut = NULL;                     // null the out param
  2713.     if (pUnkOuter)
  2714.         return CLASS_E_NOAGGREGATION;
  2716.     CMultiMon *pmm = new CMultiMon;
  2718.     if (pmm)
  2719.     {
  2720.         hr = pmm->QueryInterface(riid, ppvOut);
  2721.         pmm->Release();
  2722.     }
  2724.     return hr;
  2725. }
  2727. /*----------------------------------------------------------------------------
  2728. ----------------------------------------------------------------------------*/
  2729. HFONT GetFont(LPRECT prc)
  2730. {
  2731.     LOGFONT lf;
  2733.     FillMemory(&lf,  SIZEOF(lf), 0);
  2734.     lf.lfWeight = FW_EXTRABOLD;
  2735.     lf.lfHeight = prc->bottom - prc->top;
  2736.     lf.lfWidth  = 0;
  2737.     lf.lfPitchAndFamily = FF_SWISS;
  2738.     lf.lfOutPrecision = OUT_TT_ONLY_PRECIS;
  2740.     return CreateFontIndirect(&lf);
  2741. }
  2743. /*----------------------------------------------------------------------------
  2744. ----------------------------------------------------------------------------*/
  2745. #define HANG_TIME 2500
  2747. LONG CALLBACK BigNumberWindowProc(HWND hwnd, UINT msg,WPARAM wParam,LPARAM lParam)
  2748. {
  2749.     TCHAR ach[80];
  2750.     HFONT hfont;
  2751.     RECT  rc;
  2752.     HDC   hdc;
  2753.     HRGN  hrgnTxtA;
  2754.     HRGN  hrgnTxtB;
  2755.     HRGN  hrgnTxtU;
  2756.     PAINTSTRUCT ps;
  2758.     switch (msg)
  2759.     {
  2760.     case WM_CREATE:
  2761.         break;
  2763.     case WM_SIZE:
  2764.         GetWindowText(hwnd, ach, sizeof(ach));
  2765.         GetClientRect(hwnd, &rc);
  2766.         hfont = GetFont(&rc);
  2768.         hdc = GetDC(hwnd);
  2769.         SelectObject(hdc, hfont);
  2771.         BeginPath(hdc);
  2772.             SetBkMode(hdc, TRANSPARENT);
  2773.             TextOut(hdc,0,0,ach,lstrlen(ach));
  2774.         EndPath(hdc);
  2776.         hrgnTxtA = PathToRegion(hdc);
  2777.         hrgnTxtB = CreateRectRgn(0, 0, 1, 1);
  2778.         hrgnTxtU = CreateRectRgn(0, 0, 1, 1);
  2780.         // Copy region A (our number) to a new region (B)
  2782.         CombineRgn(hrgnTxtB, hrgnTxtA, NULL, RGN_COPY);
  2784.         // Offset region B by two pixels in x and y
  2786.         OffsetRgn(hrgnTxtB, 2, 2);
  2788.         // Now create a region that is the union of A and B.
  2789.         // This gives us our number with 2 pixels worth of
  2790.         // room for shadowing.
  2792.         CombineRgn(hrgnTxtU, hrgnTxtA, hrgnTxtB, RGN_OR);
  2793.         DeleteObject(hrgnTxtA);
  2794.         DeleteObject(hrgnTxtB);
  2795.         SetWindowRgn(hwnd,hrgnTxtU,TRUE);
  2797.         ReleaseDC(hwnd, hdc);
  2798.         DeleteObject(hfont);
  2799.         break;
  2801.     case WM_TIMER:
  2802.         DestroyWindow(hwnd);
  2803.         return 0;
  2805.     case WM_PAINT:
  2806.         GetWindowText(hwnd, ach, sizeof(ach));
  2807.         GetClientRect(hwnd, &rc);
  2808.         hfont = GetFont(&rc);
  2810.         hdc = BeginPaint(hwnd, &ps);
  2811.         PatBlt(hdc, 0, 0, rc.right, rc.bottom, BLACKNESS | NOMIRRORBITMAP);
  2812.         SelectObject(hdc, hfont);
  2813.         SetTextColor(hdc, 0xFFFFFF);
  2814.         SetBkMode(hdc, TRANSPARENT);
  2815.         TextOut(hdc,0,0,ach,lstrlen(ach));
  2816.         EndPaint(hwnd, &ps);
  2817.         DeleteObject(hfont);
  2818.         break;
  2819.     }
  2821.     return DefWindowProc(hwnd,msg,wParam,lParam);
  2822. }
  2824. int Bail()
  2825. {
  2826.     POINT pt;
  2827.     POINT pt0;
  2828.     DWORD time0;
  2829.     DWORD d;
  2831.     d     = GetDoubleClickTime();
  2832.     time0 = GetMessageTime();
  2833.     pt0.x = (int)(short)LOWORD(GetMessagePos());
  2834.     pt0.y = (int)(short)HIWORD(GetMessagePos());
  2836.     if (GetTickCount()-time0 > d)
  2837.         return 2;
  2839.     if (!((GetAsyncKeyState(VK_LBUTTON) | GetAsyncKeyState(VK_RBUTTON)) & 0x8000))
  2840.         return 1;
  2842.     GetCursorPos(&pt);
  2844.     if ((pt.y - pt0.y) > 2 || (pt.y - pt0.y) < -2)
  2845.         return 1;
  2847.     if ((pt.x - pt0.x) > 2 || (pt.x - pt0.x) < -2)
  2848.         return 1;
  2850.     return 0;
  2851. }
  2853. void FlashText(LPCTSTR sz, LPRECT prc, BOOL fWait)
  2854. {
  2855.     HFONT hfont;
  2856.     SIZE  size;
  2857.     HDC   hdc;
  2858.     int   i;
  2860.     static HWND hWnd;
  2862.     if (hWnd && IsWindow(hWnd))
  2863.     {
  2864.         DestroyWindow(hWnd);
  2865.         hWnd = NULL;
  2866.     }
  2868.     if (sz == NULL)
  2869.         return;
  2871.     if (fWait)
  2872.     {
  2873.         while ((i=Bail()) == 0)
  2874.             ;
  2876.         if (i == 1)
  2877.             return;
  2878.     }
  2880.     hdc = GetDC(NULL);
  2881.     hfont = GetFont(prc);
  2882.     SelectObject(hdc, hfont);
  2883.     GetTextExtentPoint(hdc, sz, lstrlen(sz), &size);
  2884.     ReleaseDC(NULL, hdc);
  2885.     DeleteObject(hfont);
  2887.     WNDCLASS    cls;
  2888.     cls.hCursor        = LoadCursor(NULL,IDC_ARROW);
  2889.     cls.hIcon          = NULL;
  2890.     cls.lpszMenuName   = NULL;
  2891.     cls.lpszClassName  = TEXT("MonitorNumber32");
  2892.     cls.hbrBackground  = (HBRUSH)(COLOR_DESKTOP + 1);
  2893.     cls.hInstance      = hInstance;
  2894.     cls.style          = CS_VREDRAW | CS_HREDRAW;
  2895.     cls.lpfnWndProc    = (WNDPROC)BigNumberWindowProc;
  2896.     cls.cbWndExtra     = 0;
  2897.     cls.cbClsExtra     = 0;
  2899.     RegisterClass(&cls);
  2901.     hWnd = CreateWindowEx(
  2902.         WS_EX_TOPMOST, //WS_BORDER,
  2903.         TEXT("MonitorNumber32"), sz,
  2904.         WS_POPUP,
  2905.         (prc->right  + prc->left - size.cx)/2,
  2906.         (prc->bottom + prc->top  - size.cy)/2,
  2907.         size.cx,
  2908.         size.cy,
  2909.         NULL,
  2910.         NULL,
  2911.         hInstance,
  2912.         NULL);
  2914.     ShowWindow(hWnd, SW_SHOW);
  2915.     UpdateWindow(hWnd);
  2916.     SetTimer(hWnd, 1, HANG_TIME, NULL);
  2917. }
  2919. void PaintCurrentDevice(HDC hdc, LPRECT prc)
  2920. {
  2921.     FillRect(hdc, prc, GetSysColorBrush(COLOR_ACTIVECAPTION));
  2922. }
  2924. void DrawMonitorNum(HDC hdc, int w, int h, LPCTSTR sz, BOOL fDrawBackground=TRUE)
  2925. {
  2926.     HFONT    hfont;
  2927.     HFONT    hfontT;
  2928.     RECT     rc;
  2929.     COLORREF rgb;
  2930.     COLORREF rgbDesk;
  2932.     rc.left   = MON_X * w / MON_W;
  2933.     rc.top    = MON_Y * h / MON_H;
  2934.     rc.right  = rc.left + ((MON_DX * w + MON_W-1) / MON_W);
  2935.     rc.bottom = rc.top  + ((MON_DY * h + MON_H-1) / MON_H);
  2937.     rgb     = GetSysColor(COLOR_CAPTIONTEXT);
  2938.     rgbDesk = GetSysColor(COLOR_DESKTOP);
  2940.     if (fDrawBackground)
  2941.         FillRect(hdc, &rc, GetSysColorBrush(COLOR_DESKTOP));
  2943.     if (rgbDesk == rgb)
  2944.         rgb = GetSysColor(COLOR_WINDOWTEXT);
  2946.     if (rgbDesk == rgb)
  2947.         rgb = rgbDesk ^ 0x00FFFFFF;
  2949.     SetTextColor(hdc, rgb);
  2951.     hfont = GetFont(&rc);
  2952.     hfontT = (HFONT)SelectObject(hdc, hfont);
  2953.     SetTextAlign(hdc, TA_CENTER | TA_TOP);
  2954.     SetBkMode(hdc, TRANSPARENT);
  2955.     ExtTextOut(hdc, (rc.left+rc.right)/2, rc.top, 0, NULL, sz, lstrlen(sz), NULL);
  2956.     SelectObject(hdc, hfontT);
  2957.     DeleteObject(hfont);
  2958. }
  2960. BOOL MakeMonitorBitmap(int w, int h, LPCTSTR sz, HBITMAP *pBitmap, HBITMAP *pMaskBitmap, int cx, int cy)
  2961. {
  2962.     HBITMAP hbm;        // 128x128 bitmap we will return
  2963.     HBITMAP hbmT;       // bitmap loaded from resource
  2964.     HBITMAP hbmM;       // mask bitmap
  2965.     HDC     hdc;        // work dc
  2966.     HDC     hdcS;       // screen dc
  2967.     HDC     hdcT;       // another work dc
  2968.     HDC     hdcM;       // another work dc
  2969.     RECT    rc;
  2971.     ASSERT(w <= cx);
  2972.     ASSERT(h <= cy);
  2974.     hdcS = GetDC(NULL);
  2975.     hdc  = CreateCompatibleDC(hdcS);
  2976.     hdcT = CreateCompatibleDC(hdcS);
  2977.     hdcM = CreateCompatibleDC(hdcS);
  2979.     hbm  = CreateCompatibleBitmap(hdcS, cx, cy);
  2980.     hbmM = CreateBitmap(cx,cy,1,1,NULL);
  2981.     hbmT = (HBITMAP)LoadImage(hInstance, MAKEINTRESOURCE(BMP_MONITOR2), IMAGE_BITMAP, w, h, 0);
  2982.     ReleaseDC(NULL,hdcS);
  2984.     SelectObject(hdc, hbm);
  2985.     SelectObject(hdcT,hbmT);
  2986.     SelectObject(hdcM,hbmM);
  2988.     //
  2989.     // fill bitmap with transparent color
  2990.     //
  2991.     SetBkColor(hdc,GetPixel(hdcT, 0, h-1));
  2992.     SetRect(&rc, 0, 0, cx, cy);
  2993.     ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
  2995.     //
  2996.     // copy bitmap to upper-left of bitmap
  2997.     //
  2998.     BitBlt(hdc,0,0,w,h,hdcT,0,0,SRCCOPY);
  3000.     //
  3001.     // make mask
  3002.     //
  3003.     BitBlt(hdcM,0,0,cx,cy,hdc,0,0,SRCCOPY);
  3005.     //
  3006.     // draw the monitor number in the bitmap (in the right place)
  3007.     //
  3008.     DrawMonitorNum(hdc, w, h, sz);
  3010.     DeleteDC(hdc);
  3011.     DeleteDC(hdcT);
  3012.     DeleteDC(hdcM);
  3013.     DeleteObject(hbmT);
  3015.     *pBitmap     = hbm;
  3016.     *pMaskBitmap = hbmM;
  3017.     return TRUE;
  3018. }
  3020. //
  3021. // SnapMonitorRect
  3022. //
  3023. // called while the user is moving a monitor window (WM_MOVING)
  3024. // if the CTRL key is not down we will snap the window rect
  3025. // to the edge of one of the other monitors.
  3026. //
  3027. // this is done so the user can easily align monitors
  3028. //
  3029. // NOTE pDevice->Snap must be initialized to 0,0 in WM_ENTERSIZEMOVE
  3030. //
  3031. void SnapMonitorRect(PMULTIMON_DEVICE pDevice, HWND hwnd, RECT *prc)
  3032. {
  3033.     HWND hwndT;
  3034.     int  d;
  3035.     RECT rcT;
  3036.     RECT rc;
  3038.     //
  3039.     // allow the user to move the window anywhere when the CTRL key is down
  3040.     //
  3041.     if (GetKeyState(VK_CONTROL) & 0x8000)
  3042.         return;
  3044.     //
  3045.     // macros to help in alignment
  3046.     //
  3047.     #define SNAP_DX 6
  3048.     #define SNAP_DY 6
  3050.     #define SNAPX(f,x) 
  3051.         d = rcT.x - rc.f; if (abs(d) <= SNAP_DX) rc.left+=d, rc.right+=d;
  3053.     #define SNAPY(f,y) 
  3054.         d = rcT.y - rc.f; if (abs(d) <= SNAP_DY) rc.top+=d, rc.bottom+=d;
  3056.     //
  3057.     // get current rect and offset it by the amount we have corrected
  3058.     // it so far (this alignes the rect with the position of the mouse)
  3059.     //
  3060.     rc = *prc;
  3061.     OffsetRect(&rc, pDevice->Snap.x, pDevice->Snap.y);
  3063.     //
  3064.     // walk all other windows and snap our window to them
  3065.     //
  3066.     for (hwndT = GetWindow(hwnd,  GW_HWNDFIRST); hwndT;
  3067.          hwndT = GetWindow(hwndT, GW_HWNDNEXT))
  3068.     {
  3069.         if (hwndT == hwnd)
  3070.             continue;
  3072.         GetWindowRect(hwndT, &rcT);
  3073.         InflateRect(&rcT,SNAP_DX,SNAP_DY);
  3075.         if (IntersectRect(&rcT, &rcT, &rc))
  3076.         {
  3077.             GetWindowRect(hwndT, &rcT);
  3078.             SNAPX(right,left);  SNAPY(bottom,top);
  3079.             SNAPX(right,right); SNAPY(bottom,bottom);
  3080.             SNAPX(left,left);   SNAPY(top,top);
  3081.             SNAPX(left,right);  SNAPY(top,bottom);
  3082.         }
  3083.     }
  3085.     //
  3086.     // adjust the amount we have snap'ed so far, and return the new rect
  3087.     //
  3088.     pDevice->Snap.x += prc->left - rc.left;
  3089.     pDevice->Snap.y += prc->top  - rc.top;
  3090.     *prc = rc;
  3091. }
  3093. LONG CALLBACK MonitorWindowProc(HWND hwnd, UINT msg,WPARAM wParam,LPARAM lParam)
  3094. {
  3095.     PAINTSTRUCT ps;
  3096.     HDC hdc;
  3097.     RECT rc;
  3098.     int w,h;
  3099.     TCHAR ach[80];
  3100.     PMULTIMON_DEVICE pDevice;
  3101.     HWND hDlg = NULL;
  3102.     RECT rcPos;
  3103.     CMultiMon * pcmm = (CMultiMon *) GetWindowLong(hwnd, 0);
  3105.     switch (msg)
  3106.     {
  3107.         case WM_CREATE:
  3108.             ASSERT(((LPCREATESTRUCT)lParam)->lpCreateParams);
  3109.             SetWindowLong(hwnd, 0, (LONG)((LPCREATESTRUCT)lParam)->lpCreateParams);
  3110.             break;
  3112.         case WM_NCCREATE:
  3113.             // turn off RTL_MIRRORED_WINDOW in GWL_EXSTYLE
  3114.             SHSetWindowBits(hwnd, GWL_EXSTYLE, RTL_MIRRORED_WINDOW, 0);
  3115.             break;
  3117.         case WM_NCHITTEST:
  3118.             pDevice = (PMULTIMON_DEVICE) GetDlgCtrlID(hwnd);
  3119.             if (pDevice && pDevice->pds->IsAttached())
  3120.                 return HTCAPTION;
  3121.             break;
  3122.             
  3123.         case WM_NCLBUTTONDBLCLK:
  3124.             FlashText(NULL,NULL,FALSE);
  3125.             hDlg = GetParent(GetParent(hwnd));
  3126.             PostMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDC_DISPLAYPROPERTIES, BN_CLICKED), (LPARAM)hwnd );
  3127.             break;
  3129.         case WM_COMMAND:
  3130.             switch (GET_WM_COMMAND_ID(wParam, lParam))
  3131.             {
  3132.             case IDC_DISPLAYPRIME:
  3133.             case IDC_DISPLAYUSEME:
  3134.             case IDC_DISPLAYPROPERTIES:
  3135.                 hDlg = GetParent(GetParent(hwnd));
  3136.                 PostMessage(hDlg, WM_COMMAND, wParam, lParam);
  3137.                 break;
  3139.             case IDC_FLASH:
  3140.                 pDevice = (PMULTIMON_DEVICE) GetDlgCtrlID(hwnd);
  3141.                 pDevice->pds->GetOrigPosition(&rcPos);
  3142.                 if (!IsRectEmpty(&rcPos))
  3143.                 {
  3144.                     GetWindowText(hwnd, ach, ARRAYSIZE(ach));
  3145.                     FlashText(ach, &rcPos, FALSE);
  3146.                 }
  3147.             }
  3148.             break;
  3150.         case WM_INITMENUPOPUP:
  3151.             pDevice = (PMULTIMON_DEVICE) GetDlgCtrlID(hwnd);
  3153.             CheckMenuItem((HMENU)wParam, IDC_DISPLAYUSEME, pDevice->pds->IsAttached() ? MF_CHECKED : MF_UNCHECKED);
  3154.             CheckMenuItem((HMENU)wParam, IDC_DISPLAYPRIME, pDevice->pds->IsPrimary()  ? MF_CHECKED : MF_UNCHECKED);
  3156.             EnableMenuItem((HMENU)wParam, IDC_FLASH,             pDevice->pds->IsAttached() ? MF_ENABLED : MF_GRAYED);
  3157.             EnableMenuItem((HMENU)wParam, IDC_DISPLAYPROPERTIES, pDevice->pds->IsAttached() ? MF_ENABLED : MF_GRAYED);
  3158. #ifndef WINNT
  3159.             EnableMenuItem((HMENU)wParam, IDC_DISPLAYPRIME, MF_GRAYED);
  3160.             EnableMenuItem((HMENU)wParam, IDC_DISPLAYUSEME, pDevice->pds->IsPrimary() ? MF_GRAYED : MF_ENABLED);
  3161. #endif
  3162.             SetMenuDefaultItem((HMENU)wParam, IDC_DISPLAYPROPERTIES, MF_BYCOMMAND);
  3163.             break;
  3165.         case WM_RBUTTONDOWN:
  3166.         case WM_NCRBUTTONDOWN:
  3167.             hDlg = GetParent(GetParent(hwnd));
  3168.             pDevice = (PMULTIMON_DEVICE) GetDlgCtrlID(hwnd);
  3170.             if (pDevice && pcmm)
  3171.             {
  3172.                 HMENU hmenu;
  3173.                 hmenu = LoadMenu(hInstance, MAKEINTRESOURCE(MENU_MONITOR));
  3175.                 if (hmenu)
  3176.                 {
  3177.                     POINT pt;
  3178.                     pcmm->UpdateActiveDisplay(pDevice);
  3179.                     GetCursorPos(&pt);
  3180.                     TrackPopupMenu(GetSubMenu(hmenu,0), TPM_RIGHTBUTTON,
  3181.                         pt.x, pt.y, 0, hwnd, NULL);
  3182.                     DestroyMenu(hmenu);
  3183.                 }
  3184.             }
  3185.             break;
  3187.         case WM_NCLBUTTONDOWN:
  3188.             BringWindowToTop(hwnd);
  3189.             hDlg = GetParent(GetParent(hwnd));
  3190.             pDevice = (PMULTIMON_DEVICE) GetDlgCtrlID(hwnd);
  3191.             if (pDevice->pds->IsAttached())
  3192.             {
  3193.                 if (pcmm)
  3194.                     pcmm->UpdateActiveDisplay(pDevice);
  3195.                 pDevice->pds->GetOrigPosition(&rcPos);
  3196.                 if (!IsRectEmpty(&rcPos))
  3197.                 {
  3198.                     GetWindowText(hwnd, ach, ARRAYSIZE(ach));
  3199.                     FlashText(ach, &rcPos, TRUE);
  3200.                 }
  3201.             }
  3202.             break;
  3204.         case WM_LBUTTONUP:
  3205.             pDevice = (PMULTIMON_DEVICE) GetDlgCtrlID(hwnd);
  3206.             if (pcmm && !pcmm->QueryNoAttach() && pDevice && !pDevice->pds->IsAttached())
  3207.             {
  3208.                 TCHAR szTurnItOn[400];
  3209.                 TCHAR szTurnOnTitleFormat[30];
  3210.                 TCHAR szTurnOnTitle[110];
  3211.                 
  3212.                 LoadString(hInstance, IDS_TURNONTITLE, szTurnOnTitleFormat, SIZEOF(szTurnOnTitleFormat));
  3213.                 GetWindowText(hwnd, ach, SIZEOF(ach));
  3214.                 wsprintf(szTurnOnTitle, szTurnOnTitleFormat, ach);
  3217.                 LPTSTR pstr = szTurnItOn;
  3218.                 if (pcmm->GetNumberOfAttachedDisplays() <= 1)
  3219.                 {
  3220.                     LoadString(hInstance, IDS_TURNONWARN, szTurnItOn, SIZEOF(szTurnItOn));
  3221.                     pstr += lstrlen(szTurnItOn);
  3222.                 }
  3223.                 
  3224.                 LoadString(hInstance, IDS_TURNITON, pstr, SIZEOF(szTurnItOn));
  3225.                 hDlg = GetParent(GetParent(hwnd));
  3226.                 if (ShellMessageBox(hInstance, hwnd, szTurnItOn, szTurnOnTitle, MB_YESNO | MB_ICONINFORMATION) == IDYES)
  3227.                 {
  3228.                     if (pcmm->ToggleAttached(pDevice, FALSE))
  3229.                     {
  3230.                         pcmm->SetDirty();
  3231.                         pcmm->UpdateActiveDisplay(pDevice);
  3232.                     }
  3233.                 }
  3234.             }
  3235.             break;
  3237.         case WM_ENTERSIZEMOVE:
  3238.             pDevice = (PMULTIMON_DEVICE) GetDlgCtrlID(hwnd);
  3239.             pDevice->Snap.x = 0;
  3240.             pDevice->Snap.y = 0;
  3241.             FlashText(NULL,NULL,FALSE);
  3242.             break;
  3244.         case WM_MOVING:
  3245.             pDevice = (PMULTIMON_DEVICE) GetDlgCtrlID(hwnd);
  3246.             SnapMonitorRect(pDevice, hwnd, (RECT*)lParam);
  3247.             break;
  3249.         case WM_EXITSIZEMOVE:
  3250.             if (pcmm)
  3251.                 pcmm->HandleMonitorChange(hwnd, FALSE);
  3252.             RedrawWindow(GetParent(hwnd), NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_ALLCHILDREN);
  3253.             break;
  3255.         case WM_DESTROY:
  3256.             SetWindowLong(hwnd, 0, NULL);
  3257.             break;
  3259.         case WM_ERASEBKGND:
  3260.             //GetClientRect(hwnd, &rc);
  3261.             //FillRect((HDC)wParam, &rc, GetSysColorBrush(COLOR_APPWORKSPACE));
  3262.             return 0L;
  3264.         case WM_PAINT:
  3265.             hdc = BeginPaint(hwnd,&ps);
  3266.             GetWindowText(hwnd, ach, ARRAYSIZE(ach));
  3267.             GetClientRect(hwnd, &rc);
  3268.             w = rc.right;
  3269.             h = rc.bottom;
  3271.             pDevice = (PMULTIMON_DEVICE) GetDlgCtrlID(hwnd);
  3273.             if (pDevice->w != w || pDevice->h != h)
  3274.             {
  3275.                 HBITMAP hbm, hbmMask;
  3276.                 int cx,cy;
  3278.                 pDevice->w = w;
  3279.                 pDevice->h = h;
  3281.                 ImageList_GetIconSize(pDevice->himl, &cx, &cy);
  3282.                 MakeMonitorBitmap(w,h,ach,&hbm,&hbmMask,cx,cy);
  3283.                 ImageList_Replace(pDevice->himl,pDevice->iImage,hbm,hbmMask);
  3285.                 DeleteObject(hbm);
  3286.                 DeleteObject(hbmMask);
  3287.             }
  3289.             if (!pDevice->pds->IsAttached())
  3290.             {
  3291.                 FillRect(hdc, &rc, GetSysColorBrush(COLOR_APPWORKSPACE));
  3292.                 ImageList_DrawEx(pDevice->himl,pDevice->iImage,hdc,0,0,w,h,
  3293.                     CLR_DEFAULT,CLR_NONE,ILD_BLEND50);
  3294.             }
  3295.             else if (pcmm && (pDevice == pcmm->GetCurDevice()))
  3296.             {
  3297.                 ImageList_DrawEx(pDevice->himl,pDevice->iImage,hdc,0,0,w,h,
  3298.                     CLR_DEFAULT,CLR_DEFAULT,ILD_BLEND50);
  3299.                 DrawMonitorNum(hdc, w, h, ach, FALSE);
  3300.             }
  3301.             else
  3302.             {
  3303.                 ImageList_DrawEx(pDevice->himl,pDevice->iImage,hdc,0,0,w,h,
  3304.                     CLR_DEFAULT,CLR_DEFAULT,ILD_NORMAL);
  3305.             }
  3307.             EndPaint(hwnd,&ps);
  3308.             return 0L;
  3309.     }
  3310.     return DefWindowProc(hwnd,msg,wParam,lParam);
  3311. }