开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 酒店行业 > 查看源码
CoolControlsManager.cpp
资源名称：VC+ACCESS开发的酒店管理+论文.rar　[点击查看]
上传用户：sunh8215
上传日期：2010-02-13
资源大小：1616k
文件大小：77k
源码类别：

酒店行业

开发平台：

Visual C++

CoolControlsManager.cpp：源码内容
  2. /******************************************************************
  4. $Archive: /MfcExt/Source/CoolControlsManager.cpp $
  5. $Workfile: CoolControlsManager.cpp $
  6. $Author: Bogdan Ledwig $
  7. $Date: 99-04-26 22:12 $
  8. $Revision: 13 $
  10. *******************************************************************/
  12. #include "StdAfx.h"
  14. #include "CoolControlsManager.h"
  16. // If you don't want to see extra TRACE diagnostics,
  17. // modify the line below to: #define CCM_TRACE
  18. #define CCM_TRACE TRACE
  20. #define CCM_TIMER_VAL 100        // 100 ms timer period seems to be good enough...
  21. #define MAX_CLASSNAME 64         // Length of buffer for retrieving the class name
  23. ////////////////////////////////////////////////////////////////////////
  24. // CCMControl static members initialization
  26. HWND CCoolControlsManager::CCMControl::m_hWndOld = NULL;
  27. CMapPtrToPtr CCoolControlsManager::m_ctrlMap = 10;
  28. CMapPtrToPtr CCoolControlsManager::m_dlgMap = 10;
  29. BOOL CCoolControlsManager::m_bEnabled = TRUE;
  31. // Changed 02.03.1999 Mike Walter
  32. CMapWordToPtr CCoolControlsManager::m_threadMap = 10;     
  34. ///////////////////////////////////////////////////////////////////////
  35. // Here is the one and only CCoolControlsManager object
  36. static CCoolControlsManager g_ctrlManager;
  38. CCoolControlsManager& GetCtrlManager()
  39. {
  40.    return g_ctrlManager;
  41. }
  43. ////////////////////////////////////////////////////////////////////////
  44. // WH_CALLWNDPROC hook procedure
  46. LRESULT CALLBACK CCM_CallWndProc( int nCode, WPARAM wParam, LPARAM lParam )
  47. {   
  48.    HOOKPROC hHookProc;
  49.    if ( g_ctrlManager.m_threadMap.Lookup( (WORD)GetCurrentThreadId(), (void*&)hHookProc ) == FALSE )
  50.    {
  51. //      TRACE( "CCoolControlsManager: No hook for this thread installed!n" );
  52.       return 0;
  53.    }
  55.    if ( nCode == HC_ACTION )
  56.    {      
  57.       CWPSTRUCT* pwp = (CWPSTRUCT*)lParam;
  58.       if ( g_ctrlManager.IsEnabled() )
  59.       {
  60.          if ( g_ctrlManager.m_bDialogOnly == TRUE )        
  61.          {
  62.             if ( pwp->message == WM_INITDIALOG )
  63.                g_ctrlManager.Install( pwp->hwnd );
  64.          }
  65.          else if ( pwp->message == WM_CREATE && g_ctrlManager.IsEnabled() )
  66.          {
  67.             TCHAR szBuf[MAX_CLASSNAME];
  68.             if ( GetWindowLong( pwp->hwnd, GWL_STYLE ) & WS_CHILD )
  69.             {
  70.                GetClassName( pwp->hwnd, szBuf, MAX_CLASSNAME );
  71.                if ( lstrcmp( szBuf, _T( "ScrollBar" ) ) ) // Don't add scrollbars
  72.                   g_ctrlManager.AddControl( pwp->hwnd );
  73.             }
  74.          }
  75.       }
  76.    }   
  77.    // Changed 02.03.1999 Mike Walter
  78.    return CallNextHookEx( (HHOOK)hHookProc, nCode, wParam, lParam );
  79. }
  81. // Install a hook for the current thread only
  82. void CCoolControlsManager::InstallHook( DWORD dwThreadID, BOOL bDialogOnly )
  83. {
  84.    // ASSERT( m_hkWndProc == NULL );
  86.    m_bDialogOnly = bDialogOnly;
  88.    // Changes 02.03.1999 Mike Walter
  89.    HOOKPROC hNewHook;
  91.    if ( m_threadMap.Lookup( (WORD)( dwThreadID == -1 ? GetCurrentThreadId() : dwThreadID ), (void*&)hNewHook ) == FALSE )
  92.    {
  93.       hNewHook = (HOOKPROC)SetWindowsHookEx( WH_CALLWNDPROC,
  94.                                              (HOOKPROC)CCM_CallWndProc,
  95.                                              NULL,
  96.                                              ( dwThreadID == -1 ? GetCurrentThreadId() : dwThreadID ) );
  98.       m_threadMap.SetAt( (WORD)( dwThreadID == -1 ? GetCurrentThreadId() : dwThreadID ), hNewHook );
  100.       CCM_TRACE( "CCoolControlsManager: WH_CALLWNDPROC hook installed for thread: %dn", ( dwThreadID == -1 ? GetCurrentThreadId() : dwThreadID ) );
  101.    }
  102.    else
  103.       CCM_TRACE( "CCoolControlsManager: WH_CALLWNDPROC hook already installed for thread: %d!n", ( dwThreadID == -1 ? GetCurrentThreadId() : dwThreadID ) );
  104. }
  106. // Install a global hook for all windows in the system.
  107. // This function may be called only when is put in a DLL.
  108. void CCoolControlsManager::InstallGlobalHook( HINSTANCE hInstance, BOOL bDialogOnly )
  109. {
  110.    ASSERT( hInstance );      // hInstance must not be NULL!
  111.    ASSERT( m_hkWndProc == NULL );
  112.    
  113.    m_bDialogOnly = bDialogOnly;
  115.    HOOKPROC hkProc = (HOOKPROC)GetProcAddress( hInstance, "CCM_CallWndProc" );
  117.    m_hkWndProc = (HOOKPROC)SetWindowsHookEx( WH_CALLWNDPROC,
  118.                                          (HOOKPROC)hkProc,
  119.                                          hInstance,
  120.                                          0 );   
  122.    CCM_TRACE( _T( "CCoolControlsManager: WH_CALLWNDPROC global hook installedn" ) );
  123. }
  125. void CCoolControlsManager::UninstallHook( DWORD dwThreadID )
  126. {
  127.    // ASSERT( m_hkWndProc != NULL );
  129.    // Changes 02.03.1999 Mike Walter
  130.    HOOKPROC hHookProc;
  132.    if ( dwThreadID == -1 )
  133.    {
  134.       if ( g_ctrlManager.m_threadMap.Lookup( (WORD)GetCurrentThreadId(), (void*&)hHookProc ) == FALSE )
  135.       {
  136.          CCM_TRACE( "CCoolControlsManager: No hook installed for thread: %d!n", GetCurrentThreadId() );
  137.          return;
  138.       }
  140.       UnhookWindowsHookEx( (HHOOK)hHookProc );
  141.       m_threadMap.RemoveKey( (WORD)GetCurrentThreadId() );
  143.       CCM_TRACE( "CCoolControlsManager: Hook uninstalled for thread: %dn", GetCurrentThreadId() );
  144.       CCM_TRACE( "CCoolControlsManager: Thread map has %d itemsn",g_ctrlManager.m_threadMap.GetCount() );
  145.    }
  146.    else
  147.    {
  148.       if ( g_ctrlManager.m_threadMap.Lookup( (WORD)dwThreadID, (void*&)hHookProc) == FALSE )
  149.       {
  150.          CCM_TRACE( "CCoolControlsManager: No hook installed for thread: %d!n", dwThreadID );
  151.          return;
  152.       }
  154.       UnhookWindowsHookEx( (HHOOK)hHookProc );
  155.       m_threadMap.RemoveKey( (WORD)dwThreadID );
  157.       CCM_TRACE( "CCoolControlsManager: Hook uninstalled for thread: %dn", dwThreadID );
  158.       CCM_TRACE( "CCoolControlsManager: Thread map has %d itemsn", g_ctrlManager.m_threadMap.GetCount() );
  159.    }
  161.    if ( m_uTimerID && g_ctrlManager.m_threadMap.IsEmpty() == TRUE )
  162.       KillTimer( NULL, m_uTimerID );
  163. }
  165. //////////////////////////////////////////////////////////////////////
  166. // Construction/Destruction
  167. //////////////////////////////////////////////////////////////////////
  169. CCoolControlsManager::CCoolControlsManager()
  170. {  
  171.    m_hkWndProc = NULL;
  172.    m_uTimerID = 0;
  173.    CCM_TRACE( _T( "CCoolControlsManager::CCoolControlsManager()n" ) );
  174. }
  176. CCoolControlsManager::~CCoolControlsManager()
  177. {  
  178.    // Changed 02.03.1999 Mike Walter
  179.    POSITION pos = m_threadMap.GetStartPosition();
  181.    while ( pos )
  182.    {
  183.       HOOKPROC hHook;
  184.       DWORD dwThreadID = 0;
  186.       m_threadMap.GetNextAssoc( pos, (WORD&)dwThreadID, (void*&)hHook );
  187.       UninstallHook( dwThreadID );
  188.    }
  190.    // If we have any elements in the map (normally impossible), unsubclass they and remove
  191.    pos = m_ctrlMap.GetStartPosition();
  193.    while ( pos )
  194.    {
  195.       HWND hWnd;
  197.       CCMControl* pCtl;
  198.       m_ctrlMap.GetNextAssoc( pos, (void*&)hWnd, (void*&)pCtl );
  199.       pCtl->Unsubclass();
  200.       m_ctrlMap.RemoveKey( hWnd );
  201.       delete pCtl;
  202.    }
  204.    // Now do the same things for dialog map
  205.    pos = m_dlgMap.GetStartPosition();
  207.    while ( pos )
  208.    {
  209.       HWND hWnd;
  210.       CCMDialog* pCtl;
  211.       m_dlgMap.GetNextAssoc( pos, (void*&)hWnd, (void*&)pCtl );
  213.       pCtl->Unsubclass();
  214.       m_dlgMap.RemoveKey( hWnd );
  215.       delete pCtl;
  216.    }
  218.    CCM_TRACE( "CCoolControlsManager::~CCoolControlsManager()n" ); 
  219. }
  221. void CCoolControlsManager::Install( HWND hWnd )
  222. {
  223.    CCMControl* pCtl;
  224.    if ( m_dlgMap.Lookup( hWnd, (void*&)pCtl ) ) // Already in the dialog map
  225.       return;
  227.    // Iterate through all child windows
  228.    HWND hCtrl = GetTopWindow( hWnd );
  230.    while ( hCtrl )
  231.    {
  232.       if ( GetWindowLong( hCtrl, GWL_STYLE ) & WS_CHILD )
  233.       {
  234.          TCHAR szBuf[MAX_CLASSNAME];
  235.          GetClassName( hCtrl, szBuf, MAX_CLASSNAME );
  236.          if ( lstrcmpi( szBuf, _T( "#32770" ) ) ) // Never add child dialogs!
  237.             AddControl( hCtrl );
  238.       }
  239.       hCtrl = GetNextWindow( hCtrl, GW_HWNDNEXT );
  240.    }    
  242.    AddDialog( hWnd ); // Add parent window as well
  244.    // Now redraw all recently inserted controls   
  245.    hCtrl = GetTopWindow( hWnd );
  246.    while ( hCtrl ) 
  247.    {
  248.       if ( m_ctrlMap.Lookup( hCtrl, (void*&)pCtl ) )
  249.          pCtl->DrawBorder();
  250.       hCtrl = GetNextWindow( hCtrl, GW_HWNDNEXT );
  251.    }    
  252. }
  254. void CCoolControlsManager::Uninstall( HWND hWnd )
  255. {
  256.    // Remove all window controls from the map
  257.    // when the window is about to destroy
  258.    CCM_TRACE( _T( "CCoolControlsManager: Uninstall, handle: %Xn" ), hWnd );
  259.    
  260.    HWND hCtrl = GetTopWindow( hWnd );
  261.    while ( hCtrl )
  262.    {
  263.       if ( GetWindowLong( hCtrl, GWL_STYLE ) & WS_CHILD )
  264.          RemoveControl( hCtrl );
  265.       hCtrl = GetNextWindow( hCtrl, GW_HWNDNEXT );
  266.    }
  267. }
  269. // In lpszClass you can specify class name, which will be used 
  270. // instead of true class name (useful for non-standard controls 
  271. // that are similar to the one of those we have supported)
  272. BOOL CCoolControlsManager::AddControl( HWND hWnd, LPCTSTR lpszClass )
  273. {  
  274.    CCMControl* pCtl = NULL; 
  276.    // Must not be NULL or already in the map
  277.    if ( hWnd == NULL || m_ctrlMap.Lookup( hWnd, (void*&)pCtl ) )
  278.       return FALSE;   
  279.    
  280.    TCHAR szBuf[MAX_CLASSNAME];
  281.    if ( lpszClass == NULL )
  282.       GetClassName( hWnd, szBuf, MAX_CLASSNAME );
  283.    else
  284.       lstrcpy( szBuf, lpszClass );
  286.    DWORD dwStyle = GetWindowLong( hWnd, GWL_STYLE );
  287.    DWORD dwExStyle = GetWindowLong( hWnd, GWL_EXSTYLE );
  289.    if ( !lstrcmpi( szBuf, _T( "Button" ) ) )
  290.    {
  291.       if ( ( dwStyle & BS_OWNERDRAW ) == BS_OWNERDRAW )         
  292.          return FALSE;     // Do not subclass ownerdraw buttons
  293.       else if ( ( dwStyle & BS_GROUPBOX ) == BS_GROUPBOX ||
  294.            ( dwStyle & BS_FLAT ) == BS_FLAT ) 
  295.          return FALSE;     // Skip all group boxes and flat buttons
  296.       else if ( ( dwStyle & BS_AUTOCHECKBOX ) == BS_AUTOCHECKBOX ||
  297.                 ( dwStyle & BS_CHECKBOX ) == BS_CHECKBOX ||                
  298.                 ( dwStyle & BS_3STATE ) == BS_3STATE )
  299.          pCtl = new CCMCheckBox;
  300.       else if ( ( dwStyle & BS_AUTORADIOBUTTON ) == BS_AUTORADIOBUTTON || 
  301.            ( dwStyle & BS_RADIOBUTTON ) == BS_RADIOBUTTON )
  302.          pCtl = new CCMRadioButton;
  303.       else
  304.          pCtl = new CCMPushButton;     // If none of the above then it must be a pushbutton!
  305.    }
  306.    else if ( !lstrcmpi( szBuf, _T( "ComboBox" ) ) )
  307.    {      
  308.       // Special case for simple comboboxes
  309.       if ( ( dwStyle & 0x03 ) == CBS_SIMPLE )
  310.       {
  311.          hWnd = GetTopWindow( hWnd );
  312.          while ( hWnd )
  313.          {
  314.             AddControl( hWnd );
  315.             hWnd = GetNextWindow( hWnd, GW_HWNDNEXT );
  316.          }
  317.          return FALSE;
  318.       }   
  319.       else
  320.          pCtl = new CCMComboBox;
  321.    }
  322.    else if ( !lstrcmpi( szBuf, _T( "Edit" ) ) )
  323.    {
  324.       // Edit window in a simple combobox
  325.       GetClassName( GetParent( hWnd ), szBuf, MAX_CLASSNAME );
  326.       if ( !lstrcmpi( szBuf, _T( "ComboBox" ) ) && 
  327.             ( GetWindowLong( GetParent( hWnd ), GWL_STYLE ) & 0x03 ) == CBS_SIMPLE ) 
  328.          pCtl = new CCMEditCombo;
  329.       else
  330.       {
  331.          if ( dwExStyle & WS_EX_CLIENTEDGE )
  332.             pCtl = new CCMEdit;
  333.       }
  334.      #if defined _DEBUG
  335.        lstrcpy( szBuf, _T( "Edit" ) );
  336.      #endif
  337.    }
  338.    else if ( !lstrcmpi( szBuf, _T( "ListBox" ) ) )
  339.    {
  340.       if ( dwExStyle & WS_EX_CLIENTEDGE )
  341.          pCtl = new CCMControl;
  342.    }
  343.    else if ( !lstrcmpi( szBuf, _T( "SysListView32" ) ) )
  344.    {
  345.       if ( dwExStyle & WS_EX_CLIENTEDGE )
  346.       {
  347.          pCtl = new CCMControl;
  348.          AddControl( GetTopWindow( hWnd ) );  // Don't forget to add the header control
  349.       }
  350.    }
  351.    else if ( !lstrcmpi( szBuf, _T( "SHELLDLL_DefView" ) ) ) // In open/save common dialogs
  352.    {
  353.       AddControl( GetTopWindow( hWnd ) );  // Add child ListView control
  354.       return FALSE;
  355.    }
  356.    else if ( !lstrcmpi( szBuf, _T( "SysTreeView32" ) ) )
  357.    {
  358.       if ( dwExStyle & WS_EX_CLIENTEDGE )
  359.          pCtl = new CCMControl;
  360.    }
  361.    else if ( !lstrcmpi( szBuf, _T( "SysDateTimePick32" ) ) )
  362.    {
  363.       if ( dwExStyle & WS_EX_CLIENTEDGE )
  364.       {
  365.          pCtl = new CCMDateTime;
  366.          if ( dwStyle & DTS_UPDOWN )
  367.             AddControl( GetTopWindow( hWnd ) );  // Add up-down control as well
  368.       }
  369.    }
  370.    else if ( !lstrcmpi( szBuf, _T( "SysMonthCal32" ) ) )
  371.       pCtl = new CCMControl;
  372.    else if ( !lstrcmpi( szBuf, _T( "msctls_updown32" ) ) )
  373.       pCtl = new CCMUpDown;
  374.    else if ( !lstrcmpi( szBuf, _T( "ComboLBox" ) ) )
  375.    {
  376.       if ( dwExStyle & WS_EX_CLIENTEDGE )
  377.          pCtl = new CCMControl;
  378.    }
  379.    else if ( !lstrcmpi( szBuf, _T( "ScrollBar" ) ) )
  380.    {
  381.       if ( !( dwStyle & SBS_SIZEBOX ) && !( dwStyle & SBS_SIZEGRIP ) )
  382.          pCtl = new CCMScrollBar;
  383.    }
  384.    else if ( !lstrcmpi( szBuf, _T( "ComboBoxEx32" ) ) )
  385.    {
  386.       AddControl( GetTopWindow( hWnd ) );
  387.       return FALSE;
  388.    }
  389.    else if ( !lstrcmpi( szBuf, _T( "msctls_hotkey32" ) ) )
  390.    {
  391.       if ( dwExStyle & WS_EX_CLIENTEDGE )
  392.          pCtl = new CCMControl;
  393.    }
  394.    else if ( !lstrcmpi( szBuf, _T( "SysIPAddress32" ) ) )
  395.    {
  396.       if ( dwExStyle & WS_EX_CLIENTEDGE )
  397.          pCtl = new CCMIPAddress;
  398.    }
  399.    else if ( !lstrcmpi( szBuf, _T( "msctls_trackbar32" ) ) )
  400.       pCtl = new CCMTrackbar;
  401.    else if ( !lstrcmpi( szBuf, _T( "RichEdit" ) ) )
  402.    {
  403.       if ( dwExStyle & WS_EX_CLIENTEDGE )
  404.          pCtl = new CCMControl;
  405.    }
  406.    else if ( !lstrcmpi( szBuf, _T( "RichEdit20W" ) ) )
  407.    {
  408.       if ( dwExStyle & WS_EX_CLIENTEDGE )
  409.          pCtl = new CCMControl;
  410.    }
  411.    else if ( !lstrcmpi( szBuf, _T( "SysHeader32" ) ) )
  412.    {
  413.       if ( dwStyle & HDS_BUTTONS )         
  414.          pCtl = new CCMHeaderCtrl;
  415.       else
  416.          return FALSE;
  417.    }
  418.    else if ( !lstrcmpi( szBuf, _T( "ToolbarWindow32" ) ) )
  419.    {
  420.       // Skip the flat toolbars
  421.       if ( dwStyle & TBSTYLE_FLAT )
  422.          return FALSE;
  423.       HWND hCtrl = GetTopWindow( hWnd );  // Add additional toolbar controls
  424.       while ( hCtrl )
  425.       {
  426.          AddControl( hCtrl );
  427.          hCtrl = GetNextWindow( hCtrl, GW_HWNDNEXT );
  428.       }      
  429.       pCtl = new CCMToolbar;
  430.    }
  431.    else if ( !lstrcmpi( szBuf, _T( "SysTabControl32" ) ) )
  432.    {
  433.       pCtl = new CCMTabControl;
  434.       HWND hWndTop = GetTopWindow( hWnd );
  435.       if ( hWndTop )
  436.          AddControl( hWndTop );  // Also add the up-down control (horizontal tabs only)
  437.    }
  438.    else  // Unknown control, do not process
  439.       return FALSE;
  441.    if ( pCtl )
  442.    {
  443.       CCM_TRACE( _T( "CCoolControlsManager::AddControl, handle: %X, type: %sn" ), 
  444.                  hWnd, szBuf );
  446.       // Perform window subclassing
  447.       pCtl->Subclass( hWnd, CCM_ControlProc );
  449.       // Add the control to the map         
  450.       m_ctrlMap.SetAt( hWnd, pCtl );
  451.       
  452.       if ( m_uTimerID == 0 ) // If timer is not initialized yet
  453.       {    
  454.          m_uTimerID = SetTimer( NULL, 0, CCM_TIMER_VAL, CCM_TimerProc );
  455.          CCM_TRACE( _T( "CControlManager: Timer createdn" ) );
  456.          ASSERT( m_uTimerID );    // Failed to create the timer
  457.       }
  458.       return TRUE;
  459.    }
  460.    return FALSE;
  461. }
  463. BOOL CCoolControlsManager::RemoveControl( HWND hWnd )
  464. {
  465.    BOOL bResult = TRUE;   
  466.    CCMControl* pCtl;
  467.    if ( m_ctrlMap.Lookup( hWnd, (void*&)pCtl ) == FALSE )
  468.       bResult =  FALSE;   
  470.   #if defined _DEBUG
  471.    TCHAR szBuf[MAX_CLASSNAME];
  472.    GetClassName( hWnd, szBuf, MAX_CLASSNAME );         
  473.    CCM_TRACE( _T( "CCoolControlsManager::RemoveControl, handle: %X, class: %s, " ), 
  474.            hWnd, szBuf );
  475.    CCM_TRACE( bResult ? _T( "OKn" ) : _T( "failn" ) );
  476.   #endif
  478.    if ( bResult == TRUE )
  479.    {
  480.       // Unsubclass window and next remove it from the map
  481.       pCtl->Unsubclass();
  482.       m_ctrlMap.RemoveKey( hWnd );
  483.       delete pCtl;      // Destroy the object
  485.       if ( m_ctrlMap.IsEmpty() )
  486.       {
  487.          KillTimer( NULL, m_uTimerID );
  488.          CCM_TRACE( _T( "CCoolControlsManager: Timer killed, map is emptyn" ) );
  489.          m_uTimerID = 0;
  490.       }  
  491.       else
  492.          CCM_TRACE( _T( "CCoolControlsManager: map has %d itemsn" ), m_ctrlMap.GetCount() );
  493.    }
  494.    return bResult;
  495. }
  497. void CCoolControlsManager::AddDialog( HWND hWnd )
  498. {   
  499.    if ( hWnd  )
  500.    {
  501.       CCMDialog* pCtl = new CCMDialog;
  502.       pCtl->Subclass( hWnd, CCM_DialogProc );    // Perform window subclassing
  503.       m_dlgMap.SetAt( hWnd, pCtl ); // Add the dialog to the map   
  504.    }
  505. }
  507. void CCoolControlsManager::RemoveDialog( HWND hWnd )
  508. {   
  509.    CCMDialog* pCtl;
  510.    if ( m_dlgMap.Lookup( hWnd, (void*&)pCtl ) == TRUE )   
  511.    {
  512.       // Unsubclass window and next remove it from the map
  513.       pCtl->Unsubclass();
  514.       m_dlgMap.RemoveKey( hWnd );
  515.       delete pCtl;      // Destroy the object
  516.    }
  517. }
  519. static void CALLBACK CCM_TimerProc( HWND /*hwnd*/, UINT /*uMsg*/, 
  520.                                     UINT /*idEvent*/, DWORD /*dwTime*/ )
  521. { 
  522.    g_ctrlManager.TimerProc();
  523. }
  525. void CCoolControlsManager::TimerProc()
  526. {
  527.    // Do not process when the map is empty or the capture is set
  528.    if ( m_ctrlMap.IsEmpty() || GetCapture() != NULL )
  529.       return;
  531.    POINT point;
  532.    GetCursorPos( &point );
  533.    HWND hWnd = WindowFromPoint( point );
  534.    
  535.    CCMControl* pCtl;
  536.    // Lookup for a window in the map      
  537.    if ( m_ctrlMap.Lookup( hWnd, (void*&)pCtl ) == FALSE ) // Not found
  538.    {
  539.       // If window does not exist in the map, it can be
  540.       // a child of the control (e.g. edit control in ComboBox
  541.       // or header control in ListView). If so, get the parent window and
  542.       // carry on
  543.       hWnd = GetParent( hWnd );            
  544.       // Not our window, so just reset previous control and exit
  545.       if ( hWnd == NULL || m_ctrlMap.Lookup( hWnd, (void*&)pCtl ) == FALSE )
  546.       {            
  547.          // Not our window, so just reset previous control and exit
  548.          if ( m_ctrlMap.Lookup( CCMControl::m_hWndOld, (void*&)pCtl ) == TRUE )
  549.          {            
  550.             pCtl->SetState( dsHover, 0 );
  551.             CCMControl::m_hWndOld = NULL;
  552.          }
  553.          return;
  554.       }      
  555.    }
  557.    if ( pCtl->NeedRedraw( point ) ) // Window has been found and needs to be redrawn!
  558.    {
  559.       // First, reset old control (if any)      
  560.       CCMControl* pCtlOld;
  561.       if ( m_ctrlMap.Lookup( CCMControl::m_hWndOld, (void*&)pCtlOld ) == TRUE )            
  562.       {         
  563.          pCtlOld->SetState( dsHover, 0 );
  564.          CCMControl::m_hWndOld = NULL;
  565.       }
  567.       // Redraw control under the cursor            
  568.       pCtl->SetState( 0, dsHover );
  569.       CCMControl::m_hWndOld = hWnd;
  570.    }
  571. }
  573. ///////////////////////////////////////////////////////////////////////
  574. // All messages from subclassed dialogs will come here
  576. static LRESULT CALLBACK CCM_DialogProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  577. {  
  578.    // Try to find dialog in the dialog map    
  579.    CCoolControlsManager::CCMDialog* pCtl;
  580.    if ( g_ctrlManager.m_dlgMap.Lookup( hWnd, (void*&)pCtl ) == FALSE )
  581.    {
  582.       // This is not our dialog, so just apply default processing
  583.       return DefWindowProc( hWnd, uMsg, wParam, lParam ); 
  584.    }
  586.    // Otherwise, let the dialog to process this message
  587.    return pCtl->WindowProc( uMsg, wParam, lParam );
  588. }
  590. ///////////////////////////////////////////////////////////////////////
  591. // All messages from subclassed controls will come here
  593. static LRESULT CALLBACK CCM_ControlProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  594. {  
  595.    CCoolControlsManager::CCMControl* pCtl;
  597.    // Try to find window in the control map
  598.    if ( g_ctrlManager.m_ctrlMap.Lookup( hWnd, (void*&)pCtl ) == FALSE )
  599.    {
  600.       // This is not our window, so just apply default processing
  601.       return DefWindowProc( hWnd, uMsg, wParam, lParam ); 
  602.    }
  604.    // Otherwise, let the control to process this message
  605.    return pCtl->WindowProc( uMsg, wParam, lParam );
  606. }
  608. //////////////////////////////////////////////////////////////////////////////
  609. // CCMControl and derived classes
  611. CCoolControlsManager::CCMControl::CCMControl()
  612. {
  613.    m_hWnd = NULL;
  614.    m_oldWndProc = NULL;
  615.    m_nState = dsNormal;
  616.    m_nOldState = dsNormal;
  617. }
  619. void CCoolControlsManager::CCMControl::PrepareDraw( HDC& hDC, RECT& rect )
  620. {
  621.    GetWindowRect( m_hWnd, &rect );         
  622.    OffsetRect( &rect, -rect.left, -rect.top );
  623.    hDC = GetWindowDC( m_hWnd );
  624. }
  626. void CCoolControlsManager::CCMControl::DrawBorder()
  627. {  
  628.    HDC hDC;
  629.    RECT rect;
  630.    PrepareDraw( hDC, rect );
  632.    if ( GetWindowLong( m_hWnd, GWL_EXSTYLE ) & WS_EX_CLIENTEDGE )
  633.    {
  634.       RECT rc;
  635.       GetWindowRect( m_hWnd, &rc );
  636.       POINT point = { 0, 0 };
  637.       ClientToScreen( m_hWnd, &point );
  638.       if ( point.x == rc.left + 3 )
  639.          InflateRect( &rect, -1, -1 );
  640.    }
  642.    if ( IsFocused() == TRUE )
  643.       m_nState |= dsFocus;    
  644.    else
  645.       m_nState &= ~dsFocus;    
  647.    // Single line control looks better when this style is added
  648.    if ( ( rect.bottom - rect.top ) < 30 ) 
  649.       m_nState |= dsAlternate;
  650.    else
  651.       m_nState &= ~dsAlternate;
  653.    if ( ( m_nOldState & dsHover && m_nState & dsHover ) ||
  654.         ( m_nOldState & dsFocus && m_nState & dsFocus ) )
  655.       ; // If previous state is the same as current state, do nothing
  656.    else
  657.    {         
  658.       // Perform control-specific drawing routines                  
  659.       CCM_TRACE( _T( "CCoolControlsManager::DrawBorder, handle: %X state: %dn" ), m_hWnd, m_nState );
  660.       DrawControl( hDC, rect );
  661.    }
  663.    // Update old state
  664.    m_nOldState = m_nState;
  666.    ReleaseDC( WindowFromDC( hDC ), hDC );
  667. }
  669. BOOL CCoolControlsManager::CCMControl::NeedRedraw( const POINT& /*point*/ )
  670. {
  671.    return m_hWnd != m_hWndOld ? TRUE : FALSE;
  672. }
  674. void CCoolControlsManager::CCMCore::Subclass( HWND hWnd, WNDPROC wndNewProc )
  675. {
  676.    ASSERT( hWnd );      // Do you really want to subclass a window that has a NULL handle?
  677.    m_hWnd = hWnd;   
  679.    // Store address of the original window procedure
  680.    m_oldWndProc = (WNDPROC)GetWindowLong( m_hWnd, GWL_WNDPROC );
  682.    // And set the new one
  683.    SetWindowLong( m_hWnd, GWL_WNDPROC, (LONG)wndNewProc );
  684. }
  686. void CCoolControlsManager::CCMCore::Unsubclass()
  687. {
  688.    SetWindowLong( m_hWnd, GWL_WNDPROC, (LONG)m_oldWndProc );
  689. }
  691. LRESULT CCoolControlsManager::CCMControl::WindowProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
  692. {
  693.    switch ( uMsg )
  694.    {      
  695.       // Generic messages
  696.       case WM_KILLFOCUS:         
  697.       case WM_SETFOCUS:
  698.          DrawBorder();
  699.          break;
  701.       case WM_PAINT:
  702.       case WM_NCPAINT:
  703.       case WM_ENABLE:
  704.          CallWindowProc( m_oldWndProc, m_hWnd, uMsg, wParam, lParam );
  705.          DrawBorder();
  706.          return 0;
  708.       case WM_NCDESTROY:
  709.          // Unsubclass window and remove it from the map
  710.          CallWindowProc( m_oldWndProc, m_hWnd, uMsg, wParam, lParam );
  711.          g_ctrlManager.RemoveControl( m_hWnd );
  712.          return 0;
  713.    }
  715.    return CallWindowProc( m_oldWndProc, m_hWnd, uMsg, wParam, lParam );
  716. }
  718. void CCoolControlsManager::CCMControl::DrawControl( HDC hDC, const RECT& rc )
  719. { 
  720.    if ( m_nState & dsHoverMask )
  721.    {
  722.       Draw3dBorder( hDC, rc, COLOR_3DSHADOW, COLOR_3DHIGHLIGHT,
  723.                              COLOR_3DDKSHADOW, COLOR_3DLIGHT );
  724.    }
  725.    else
  726.    {
  727.       if ( IsWindowEnabled( m_hWnd ) == FALSE || m_nState & dsDisabled )
  728.          Draw3dBorder( hDC, rc, COLOR_3DSHADOW, COLOR_3DHIGHLIGHT,
  729.                                 COLOR_3DFACE, COLOR_3DFACE );
  730.       else               
  731.          Draw3dBorder( hDC, rc, COLOR_3DSHADOW, COLOR_3DHIGHLIGHT,
  732.                        m_nState & dsAlternate ? COLOR_3DHIGHLIGHT : COLOR_3DLIGHT, COLOR_3DLIGHT );
  733.    }
  735.    DrawScrollBars( hDC, rc );
  736. }
  738. void CCoolControlsManager::CCMControl::DrawScrollbarThumb( HDC hDC, const RECT& rc )
  739. {
  740.    if ( m_nState & dsHoverMask )
  741.       Draw3dBorder( hDC, rc, COLOR_3DFACE, COLOR_3DDKSHADOW, 
  742.                              COLOR_3DHIGHLIGHT, COLOR_3DSHADOW );
  743.    else
  744.       Draw3dBorder( hDC, rc, COLOR_3DHIGHLIGHT, COLOR_3DSHADOW,
  745.                              COLOR_3DFACE, COLOR_3DFACE );
  746. }
  748. void CCoolControlsManager::CCMControl::DrawScrollBars( HDC hDC, const RECT& rect )
  749. {  
  750.    const int nFrameSize  = GetSystemMetrics( SM_CXEDGE ); 
  751.    const int nScrollSize = GetSystemMetrics( SM_CXHSCROLL );   
  753.    RECT rc; 
  754.    DWORD dwStyle = GetWindowLong( m_hWnd, GWL_STYLE );  
  755.    if ( dwStyle & WS_HSCROLL &&  dwStyle & WS_VSCROLL )
  756.    {
  757.       rc.left = rect.left + nFrameSize; rc.top = rect.bottom - nFrameSize - nScrollSize;
  758.       rc.right = rect.right - nFrameSize - nScrollSize; rc.bottom = rect.bottom - nFrameSize;
  759.       DrawScrollBar( hDC, rc, SB_HORZ );
  761.       rc.left = rect.right - nFrameSize - nScrollSize; rc.top = rect.top + nFrameSize;
  762.       rc.right = rect.right - nFrameSize; rc.bottom = rect.bottom - nFrameSize - nScrollSize;
  763.       DrawScrollBar( hDC, rc, SB_VERT );
  764.    }
  765.    else if ( dwStyle & WS_VSCROLL )
  766.    {
  767.       rc.left = rect.right - nFrameSize - nScrollSize; rc.top = rect.top + nFrameSize;
  768.       rc.right = rect.right - nFrameSize; rc.bottom = rect.bottom - nFrameSize;
  769.       DrawScrollBar( hDC, rc, SB_VERT );
  770.    }
  771.    else if ( dwStyle & WS_HSCROLL )
  772.    {
  773.       rc.left = rect.left + nFrameSize; rc.top = rect.bottom - nFrameSize - nScrollSize;
  774.       rc.right = rect.right - nFrameSize; rc.bottom = rect.bottom - nFrameSize;
  775.       DrawScrollBar( hDC, rc, SB_HORZ );
  776.    }
  777. }
  779. void CCoolControlsManager::CCMControl::DrawScrollBar( HDC hDC, const RECT& rect, 
  780.                                                      int nType, BOOL bScrollbarCtrl )
  781. {   
  782.    int nScrollSize = GetSystemMetrics( SM_CXHSCROLL );
  784.    // The minimal thumb size depends on the system version
  785.    // For Windows 98 minimal thumb size is a half of scrollbar size 
  786.    // and for Windows NT is always 8 pixels regardless of system metrics. 
  787.    // I really don't know why.
  788.    int nMinThumbSize;
  789.    if ( GetVersion() & 0x80000000 ) // Windows 98 code
  790.       nMinThumbSize = nScrollSize / 2;
  791.    else                    
  792.       nMinThumbSize = 8;
  793.    
  794.    // Calculate the arrow rectangles
  795.    RECT rc1 = rect, rc2 = rect;   
  796.    if ( nType == SB_HORZ )
  797.    {
  798.       if ( ( rect.right - rect.left ) < 2 * nScrollSize )
  799.          nScrollSize = ( rect.right - rect.left ) / 2;
  801.       rc1.right = rect.left + nScrollSize;
  802.       rc2.left = rect.right - nScrollSize;
  803.    }
  804.    else // SB_VERT
  805.    {
  806.       if ( ( rect.bottom - rect.top ) < 2 * nScrollSize )
  807.          nScrollSize = ( rect.bottom - rect.top ) / 2;
  809.       rc1.bottom = rect.top + nScrollSize;      
  810.       rc2.top = rect.bottom - nScrollSize;
  811.    }   
  813.    // Draw the scrollbar arrows
  814.    DrawScrollbarThumb( hDC, rc1 );
  815.    DrawScrollbarThumb( hDC, rc2 );
  817.    // Disabled scrollbar never have a thumb
  818.    if ( bScrollbarCtrl == TRUE && IsWindowEnabled( m_hWnd ) == FALSE )
  819.       return;      
  820.  
  821.    SCROLLINFO si;
  822.    si.cbSize = sizeof( SCROLLINFO );
  823.    si.fMask = SIF_ALL;     
  824.    GetScrollInfo( m_hWnd, bScrollbarCtrl ? SB_CTL : nType, &si );
  826.    // Calculate the size and position of the thumb   
  827.    int nRange = si.nMax - si.nMin + 1;      
  828.    if ( nRange )
  829.    {
  830.       int nScrollArea = ( nType == SB_VERT ? ( rect.bottom - rect.top ) : ( rect.right - rect.left ) ) - 2 * nScrollSize;
  832.       int nThumbSize; 
  833.       if ( si.nPage == 0 ) // If nPage is not set then thumb has default size
  834.          nThumbSize = GetSystemMetrics( SM_CXHTHUMB );
  835.       else
  836.          nThumbSize = max( MulDiv( si.nPage ,nScrollArea, nRange ), nMinThumbSize );
  838.       if ( nThumbSize >= nScrollArea )
  839.       {
  840.          nThumbSize = nScrollArea;
  841.          if ( bScrollbarCtrl == FALSE )
  842.             return;
  843.       }
  845.       int nThumbPos;
  846.       if ( UINT( nRange ) == si.nPage )
  847.       {
  848.          nThumbPos = 0;
  849.          nThumbSize--;
  850.       }
  851.       else
  852.          nThumbPos = MulDiv( si.nPos - si.nMin, nScrollArea - nThumbSize, nRange - si.nPage );
  854.       if ( nType == SB_VERT )
  855.       {
  856.          rc1.top += nScrollSize + nThumbPos;
  857.          rc1.bottom = rc1.top + nThumbSize;
  858.       }
  859.       else // SB_HORZ
  860.       {
  861.          rc1.left += nScrollSize + nThumbPos;
  862.          rc1.right = rc1.left + nThumbSize;
  863.       }
  865.       if ( nThumbSize <= nScrollArea ) // Don't draw the thumb when it's larger than the scroll area
  866.          DrawScrollbarThumb( hDC, rc1 );
  867.    }   
  868. }
  870. BOOL CCoolControlsManager::CCMControl::IsFocused()
  871. { 
  872.    return m_hWnd == GetFocus() ? TRUE : FALSE;
  873. }
  875. //////////////////////////////////////////////////////////////////////////////
  876. // CCMEdit class
  878. void CCoolControlsManager::CCMEdit::DrawControl( HDC hDC, const RECT& rc )
  879. {
  880.    RECT rect = rc;
  882.    // Check if edit window has an associated up-down control.
  883.    // If so draw a border around both controls
  884.    HWND hWnd = GetNextWindow( m_hWnd, GW_HWNDNEXT );
  886.    if ( hWnd ) 
  887.    {
  888.       TCHAR szBuf[MAX_CLASSNAME];
  889.       // Retrieve window class name
  890.       GetClassName( hWnd, szBuf, MAX_CLASSNAME );
  891.       if ( lstrcmpi( szBuf, _T( "msctls_updown32" ) ) == 0 )   // Up-down is found
  892.       {
  893.          DWORD dwStyle = GetWindowLong( hWnd, GWL_STYLE );
  894.          if ( ( dwStyle & UDS_ALIGNRIGHT || dwStyle & UDS_ALIGNLEFT ) &&
  895.               SendMessage( hWnd, UDM_GETBUDDY, 0, 0L ) == (LONG)m_hWnd )
  896.          {         
  897.             RECT rc;
  898.             GetWindowRect( hWnd, &rc );
  899.             const int nEdge = GetSystemMetrics( SM_CXEDGE );
  900.             if ( dwStyle & UDS_ALIGNRIGHT )
  901.                rect.right += ( rc.right - rc.left ) - nEdge;
  902.             else // UDS_ALIGNLEFT
  903.                rect.left -= ( rc.right - rc.left ) - nEdge;
  905.             HDC hDC = GetDC( hWnd );   // We must draw the lines onto spin control DC
  907.             COLORREF clr = GetSysColor( m_nState & dsHoverMask ? COLOR_3DDKSHADOW : COLOR_3DHIGHLIGHT );
  908.             if ( !IsWindowEnabled( m_hWnd ) )
  909.                clr = GetSysColor( COLOR_3DFACE );
  910.             FillSolidRect( hDC, 1, 1, rc.right - rc.left - nEdge - 1, 1, clr );
  911.             if ( dwStyle & UDS_ALIGNLEFT )
  912.                FillSolidRect( hDC, 1, 1, 1, rc.bottom - rc.top - nEdge - 1, clr );
  914.             ReleaseDC( hWnd, hDC );
  915.          }
  916.       }
  917.    }
  919.    if ( GetWindowLong( m_hWnd, GWL_STYLE ) & ES_READONLY )
  920.       m_nState |= dsDisabled;
  921.    else
  922.       m_nState &= ~dsDisabled;
  923.    CCMControl::DrawControl( hDC, rect );
  924. }
  926. LRESULT CCoolControlsManager::CCMEdit::WindowProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
  927. {
  928.    switch ( uMsg )
  929.    {      
  930.       case WM_ENABLE:
  931.          {
  932.             CallWindowProc( m_oldWndProc, m_hWnd, uMsg, wParam, lParam );
  933.             DrawBorder();
  934.             HWND hWnd = GetNextWindow( m_hWnd, GW_HWNDNEXT );
  935.             if ( hWnd ) 
  936.             {
  937.                TCHAR szBuf[MAX_CLASSNAME];
  938.                // Retrieve window class name
  939.                GetClassName( hWnd, szBuf, MAX_CLASSNAME );
  940.                if ( lstrcmpi( szBuf, _T( "msctls_updown32" ) ) == 0 &&   // Up-down is found
  941.                   SendMessage( hWnd, UDM_GETBUDDY, 0, 0L ) == (LONG)m_hWnd )
  942.                      SendMessage( hWnd, WM_PAINT, 0, 0L );  // Repaint up-down too
  943.             }         
  944.          }
  945.          return 0;
  947.       default:
  948.          return CCMControl::WindowProc( uMsg, wParam, lParam );
  949.    }
  950. }
  952. //////////////////////////////////////////////////////////////////////////////
  953. // CCMComboBox class
  955. void CCoolControlsManager::CCMComboBox::DrawControl( HDC hDC, const RECT& rect )
  956. {
  957.    // First, draw borders around the control   
  958.    CCMControl::DrawControl( hDC, rect );
  960.    // Now, we have to draw borders around the drop-down arrow
  961.    RECT rc = rect;
  962.    InflateRect( &rc, -2, -2 );
  963.    rc.left = rc.right - GetSystemMetrics( SM_CXHSCROLL );
  964.    
  965.    if ( IsWindowEnabled( m_hWnd ) == TRUE )
  966.    {
  967.       if ( m_nState & dsHoverMask )
  968.          Draw3dBorder( hDC, rc, COLOR_3DFACE, COLOR_3DDKSHADOW,
  969.                                 COLOR_3DHIGHLIGHT, COLOR_3DSHADOW );
  970.       else
  971.          Draw3dBorder( hDC, rc, COLOR_3DHIGHLIGHT, COLOR_3DSHADOW,
  972.                                 COLOR_3DFACE, COLOR_3DFACE );
  973.    }
  974.    else
  975.       Draw3dBorder( hDC, rc, COLOR_3DFACE, COLOR_3DFACE,
  976.                              COLOR_3DFACE, COLOR_3DFACE );
  977. }
  979. BOOL CCoolControlsManager::CCMComboBox::IsFocused()
  980. { 
  981.    // Special case for drop-down and simple ComboBoxes 
  982.    // which contain child edit control and focus always 
  983.    // goes to that edit window   
  984.    if ( ( GetWindowLong( m_hWnd, GWL_STYLE ) & 0x03 ) == CBS_DROPDOWN )
  985.    {
  986.       HWND hWnd = GetTopWindow( m_hWnd );
  987.       if ( hWnd && hWnd == GetFocus() )
  988.          return TRUE;
  989.    }
  991.    return CCMControl::IsFocused();
  992. }
  994. LRESULT CCoolControlsManager::CCMComboBox::WindowProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
  995. {
  996.    switch ( uMsg )
  997.    {      
  998.       // Drop-down ComboBox receives neither WM_SETFOCUS nor WM_KILLFOCUS
  999.       // Instead, it receives these next two messages
  1000.       case WM_LBUTTONUP:      // For kill focus
  1001.          if ( lParam == -1 )
  1002.             DrawBorder();
  1003.          break;
  1005.       case WM_COMMAND:
  1006.          if ( HIWORD( wParam ) == EN_SETFOCUS )
  1007.             DrawBorder();
  1008.          break;
  1010.       default:
  1011.          return CCMControl::WindowProc( uMsg, wParam, lParam );
  1012.    }
  1014.    return CallWindowProc( m_oldWndProc, m_hWnd, uMsg, wParam, lParam );
  1015. }
  1017. //////////////////////////////////////////////////////////////////////////////
  1018. // CCMDateTime class
  1020. void CCoolControlsManager::CCMDateTime::DrawControl( HDC hDC, const RECT& rc )
  1021. {
  1022.    if ( GetWindowLong( m_hWnd, GWL_STYLE ) & DTS_UPDOWN )
  1023.       CCMControl::DrawControl( hDC, rc );
  1024.    else
  1025.       CCMComboBox::DrawControl( hDC, rc );
  1026. }
  1028. //////////////////////////////////////////////////////////////////////////////
  1029. // CCMPushButton class
  1031. void CCoolControlsManager::CCMPushButton::DrawControl( HDC hDC, const RECT& rc )
  1032. {
  1033.    BOOL bDefault = FALSE;
  1034.    // Unfortunately BS_DEFPUSHBUTTON is defined as 0x00000001L,
  1035.    // and BS_OWNERDRAW as 0x0000000BL (see winuser.h) so we cannot
  1036.    // determine the default button for owner-draw controls
  1037.    DWORD dwStyle = GetWindowLong( m_hWnd, GWL_STYLE ) & BS_OWNERDRAW;
  1039.    if ( dwStyle != BS_OWNERDRAW )
  1040.    {
  1041.       if ( dwStyle == BS_DEFPUSHBUTTON && IsWindowEnabled( m_hWnd ) )
  1042.          bDefault = TRUE;
  1043.    }
  1045.    int nCheck = SendMessage( m_hWnd, BM_GETCHECK, 0, 0 );
  1046.    if ( m_nState & dsHoverMask )
  1047.    {
  1048.       if ( bDefault == TRUE )
  1049.       {
  1050.          Draw3dBorder( hDC, rc, COLOR_3DDKSHADOW, COLOR_3DDKSHADOW,
  1051.                                 COLOR_3DHIGHLIGHT, COLOR_3DDKSHADOW,
  1052.                                 COLOR_3DLIGHT, COLOR_3DSHADOW );
  1053.       }
  1054.       else
  1055.       {
  1056.          if ( nCheck )
  1057.             Draw3dBorder( hDC, rc, COLOR_3DDKSHADOW, COLOR_3DHIGHLIGHT,
  1058.                                    COLOR_3DSHADOW, COLOR_3DLIGHT );
  1059.          else
  1060.             Draw3dBorder( hDC, rc, COLOR_3DHIGHLIGHT, COLOR_3DDKSHADOW,
  1061.                                    COLOR_3DLIGHT, COLOR_3DSHADOW,
  1062.                                    COLOR_3DFACE, COLOR_3DFACE );
  1063.       }
  1064.    }
  1065.    else
  1066.    {
  1067.       if ( bDefault == TRUE )
  1068.       {
  1069.          Draw3dBorder( hDC, rc, COLOR_3DDKSHADOW, COLOR_3DDKSHADOW,
  1070.                                 COLOR_3DHIGHLIGHT, COLOR_3DSHADOW,
  1071.                                 COLOR_3DFACE, COLOR_3DFACE );
  1072.       }
  1073.       else
  1074.       {
  1075.          if ( nCheck )
  1076.             Draw3dBorder( hDC, rc, COLOR_3DSHADOW, COLOR_3DHIGHLIGHT,
  1077.                                    COLOR_3DFACE, COLOR_3DFACE );
  1078.          else
  1079.             Draw3dBorder( hDC, rc, COLOR_3DHIGHLIGHT, COLOR_3DSHADOW,
  1080.                                    COLOR_3DFACE, COLOR_3DFACE,
  1081.                                    COLOR_3DFACE, COLOR_3DFACE );
  1082.       }
  1083.    }      
  1084. }
  1086. LRESULT CCoolControlsManager::CCMPushButton::WindowProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
  1087. {
  1088.    switch ( uMsg )
  1089.    {      
  1090.       // Button messages
  1091.       case BM_SETCHECK:
  1092.       case WM_SETTEXT:
  1093.          CallWindowProc( m_oldWndProc, m_hWnd, uMsg, wParam, lParam );
  1094.          DrawBorder();
  1095.          return 0;
  1097.       default:
  1098.          return CCMControl::WindowProc( uMsg, wParam, lParam );
  1099.    }
  1100. }
  1102. //////////////////////////////////////////////////////////////////////////////
  1103. // CCMCheckBox class
  1105. void CCoolControlsManager::CCMCheckBox::DrawControl( HDC hDC, const RECT& rect )
  1106. {
  1107.    DWORD dwStyle = GetWindowLong( m_hWnd, GWL_STYLE );
  1108.    
  1109.    if ( dwStyle & BS_PUSHLIKE )
  1110.    {
  1111.       CCMPushButton::DrawControl( hDC, rect );
  1112.       return;
  1113.    }  
  1115.    RECT rc;
  1116.    
  1117.    // Checkmark square size, hard coded here because I couldn't find any
  1118.    // method to obtain this value from the system.
  1119.    // Maybe someone else knows how to do it? If so, please let me know!
  1120.    const int nCheckSize = 13;
  1121.    
  1122.    if ( ( dwStyle & BS_VCENTER ) == BS_VCENTER )
  1123.       rc.top = rect.top + ( ( rect.bottom - rect.top ) - nCheckSize ) / 2;
  1124.    else if ( dwStyle & BS_TOP )
  1125.       rc.top = rect.top + 1;
  1126.    else if ( dwStyle & BS_BOTTOM )
  1127.       rc.top = rect.bottom - nCheckSize - 2;
  1128.    else  // Default
  1129.       rc.top = rect.top + ( ( rect.bottom - rect.top ) - nCheckSize ) / 2;
  1131.    if ( dwStyle & BS_LEFTTEXT )
  1132.       rc.left = rect.right - nCheckSize;
  1133.    else
  1134.       rc.left = rect.left;
  1136.    rc.right = rc.left + nCheckSize;
  1137.    rc.bottom = rc.top + nCheckSize;
  1139.    if ( m_nState & dsHoverMask )
  1140.    {
  1141.       Draw3dBorder( hDC, rc, COLOR_3DDKSHADOW, COLOR_3DHIGHLIGHT,
  1142.                              COLOR_3DSHADOW, COLOR_3DFACE );
  1143.    }
  1144.    else
  1145.    {            
  1146.       if ( IsWindowEnabled( m_hWnd ) == TRUE ) 
  1147.       {
  1148.          int nState = SendMessage( m_hWnd, BM_GETCHECK, 0, 0L );
  1149.          Draw3dBorder( hDC, rc, COLOR_3DSHADOW, COLOR_3DHIGHLIGHT,
  1150.                                 nState == 2 ? COLOR_3DHIGHLIGHT : COLOR_WINDOW, 
  1151.                                 nState == 2 ? COLOR_3DHIGHLIGHT : COLOR_WINDOW );
  1152.       }
  1153.       else
  1154.          Draw3dBorder( hDC, rc, COLOR_3DSHADOW, COLOR_3DHIGHLIGHT,
  1155.                                 COLOR_3DFACE, COLOR_3DFACE );
  1156.    }
  1157. }
  1159. //////////////////////////////////////////////////////////////////////////////
  1160. // CCMRadioButton class
  1162. void CCoolControlsManager::CCMRadioButton::DrawFrame( POINT* ptArr, int nColor, 
  1163.                                                      HDC hDC, int xOff, int yOff )
  1164. {
  1165.    for ( int i = 0; ; i++ )
  1166.    {
  1167.       if ( !ptArr[i].x && !ptArr[i].y )
  1168.          return;
  1170.       SetPixel( hDC, ptArr[i].x + xOff, ptArr[i].y + yOff, GetSysColor( nColor ) );
  1171.    }
  1172. }
  1174. void CCoolControlsManager::CCMRadioButton::DrawControl( HDC hDC, const RECT& rect )
  1175. {
  1176.    DWORD dwStyle = GetWindowLong( m_hWnd, GWL_STYLE );
  1178.    if ( dwStyle & BS_PUSHLIKE )
  1179.    {
  1180.       CCMPushButton::DrawControl( hDC, rect );
  1181.       return;
  1182.    }  
  1184.    const int nRadioSize = 12;
  1185.    RECT rc;
  1186.    
  1187.    if ( ( dwStyle & BS_VCENTER ) == BS_VCENTER )
  1188.       rc.top = rect.top + ( ( rect.bottom - rect.top ) - nRadioSize - 1 ) / 2;
  1189.    else if ( dwStyle & BS_TOP )
  1190.       rc.top = rect.top + 1;
  1191.    else if ( dwStyle & BS_BOTTOM )
  1192.       rc.top = rect.bottom - nRadioSize - 3;
  1193.    else  // Default
  1194.       rc.top = rect.top + ( ( rect.bottom - rect.top ) - nRadioSize - 1 ) / 2;
  1195.    
  1196.    if ( dwStyle & BS_LEFTTEXT )
  1197.       rc.left = rect.right - nRadioSize;
  1198.    else
  1199.       rc.left = rect.left + 1;
  1201.    rc.right = rc.left + nRadioSize;
  1202.    rc.bottom = rc.top + nRadioSize;
  1204.    POINT pt1[] = { 
  1205.                   { 1,9 },{ 1,8 },
  1206.                   { 0,7 },{ 0,6 },{ 0,5 },{ 0,4 },
  1207.                   { 1,3 },{ 1,2 },
  1208.                   { 2,1 },{ 3,1 },
  1209.                   { 4,0 },{ 5,0 },{ 6,0 },{ 7,0 },
  1210.                   { 8,1 },{ 9,1 },
  1211.                   { 0,0 }
  1212.                };  
  1213.                
  1214.    POINT pt2[] = { 
  1215.                   { 2,8 },
  1216.                   { 1,7 },{ 1,6 },{ 1,5 },{ 1,4 },
  1217.                   { 2,3 },{ 2,2 },
  1218.                   { 3,2 },
  1219.                   { 4,1 },{ 5,1 },{ 6,1 },{ 7,1 },
  1220.                   { 8,2 },{ 9,2 },
  1221.                   { 0,0 }
  1222.                };  
  1225.    POINT pt3[] = { 
  1226.                   { 2,9 },{ 3,9 },
  1227.                   { 4,10 },{ 5,10 },{ 6,10 },{ 7,10 },
  1228.                   { 8,9 },{ 9,9 },
  1229.                   { 9,8 },
  1230.                   { 10,7 },{ 10,6 },{ 10,5 },{ 10,4 },
  1231.                   { 9,3 },
  1232.                   { 0,0 }
  1233.                };  
  1235.    POINT pt4[] = { 
  1236.                   { 2,10 },{ 3,10 },
  1237.                   { 4,11 },{ 5,11 },{ 6,11 },{ 7,11 },
  1238.                   { 8,10 },{ 9,10 },
  1239.                   { 10,9 },{ 10,8 },
  1240.                   { 11,7 },{ 11,6 },{ 11,5 },{ 11,4 },
  1241.                   { 10,3 },{ 10,2 },
  1242.                   { 0,0 }
  1243.                };  
  1245.    if ( m_nState & dsHoverMask )
  1246.    {
  1247.       DrawFrame( pt1, COLOR_3DSHADOW,
  1248.                       hDC, rc.left, rc.top );
  1249.       DrawFrame( pt2, COLOR_3DDKSHADOW,
  1250.                       hDC, rc.left, rc.top );
  1251.       DrawFrame( pt3, COLOR_3DFACE,
  1252.                       hDC, rc.left, rc.top );
  1253.       DrawFrame( pt4, COLOR_WINDOW,
  1254.                       hDC, rc.left, rc.top );
  1255.    }
  1256.    else
  1257.    {
  1258.       if ( IsWindowEnabled( m_hWnd ) == TRUE ) 
  1259.       {  
  1260.          DrawFrame( pt1, COLOR_3DSHADOW,
  1261.                          hDC, rc.left, rc.top );
  1262.          DrawFrame( pt2, COLOR_WINDOW,
  1263.                          hDC, rc.left, rc.top );
  1264.          DrawFrame( pt3, COLOR_3DFACE,
  1265.                          hDC, rc.left, rc.top );
  1266.          DrawFrame( pt4, COLOR_WINDOW,
  1267.                          hDC, rc.left, rc.top );                  
  1268.       }
  1269.       else
  1270.       {
  1271.          DrawFrame( pt1, COLOR_3DSHADOW,
  1272.                          hDC, rc.left, rc.top );
  1273.          DrawFrame( pt2, COLOR_3DFACE,
  1274.                          hDC, rc.left, rc.top );
  1275.          DrawFrame( pt3, COLOR_3DFACE,
  1276.                          hDC, rc.left, rc.top );
  1277.          DrawFrame( pt4, COLOR_3DHIGHLIGHT,
  1278.                          hDC, rc.left, rc.top );
  1279.       }
  1280.    }   
  1281. }
  1283. //////////////////////////////////////////////////////////////////////////////
  1284. // CCMUpDown class
  1286. void CCoolControlsManager::CCMUpDown::DrawButton( HDC hDC, const RECT& rc )
  1287. {
  1288.    // If associated edit control is disabled
  1289.    // draw the up-down as disabled too
  1290.    BOOL bEnabled = IsWindowEnabled( m_hWnd );
  1291.    HWND hWnd = (HWND)SendMessage( m_hWnd, UDM_GETBUDDY, 0, 0L );
  1292.    if ( hWnd )
  1293.       bEnabled = IsWindowEnabled( hWnd );
  1295.    if ( bEnabled && m_nState & dsHoverMask )
  1296.       Draw3dBorder( hDC, rc, COLOR_3DFACE, COLOR_3DDKSHADOW,
  1297.                              COLOR_3DHIGHLIGHT, COLOR_3DSHADOW );
  1298.    else
  1299.       Draw3dBorder( hDC, rc, COLOR_3DHIGHLIGHT, COLOR_3DSHADOW,
  1300.                              COLOR_3DFACE, COLOR_3DFACE );
  1301. }
  1303. void CCoolControlsManager::CCMUpDown::DrawControl( HDC hDC, const RECT& rect )
  1304. {         
  1305.    RECT rc = rect;
  1306.    CCMControl* pCtl = NULL;
  1307.    DWORD dwStyle = GetWindowLong( m_hWnd, GWL_STYLE );
  1308.    HWND hWnd = (HWND)SendMessage( m_hWnd, UDM_GETBUDDY, 0, 0L );
  1309.    if ( hWnd && ( dwStyle & UDS_ALIGNRIGHT || dwStyle & UDS_ALIGNLEFT ) )
  1310.    {
  1311.       if ( dwStyle & UDS_ALIGNLEFT )
  1312.          rc.left += 2;
  1313.       else   // UDS_ALIGNRIGHT
  1314.          rc.right -= 2;
  1315.       rc.top += 2;
  1316.       rc.bottom -= 2;
  1317.                  
  1318.       if ( g_ctrlManager.m_ctrlMap.Lookup( hWnd, (void*&)pCtl ) && 
  1319.            !( pCtl->GetState() & dsHoverMask ) )
  1320.       {
  1321.          COLORREF clr1 = GetSysColor( IsWindowEnabled( hWnd ) ? COLOR_3DHIGHLIGHT : COLOR_3DFACE );
  1322.          COLORREF clr2 = GetSysColor( IsWindowEnabled( hWnd ) ? COLOR_3DLIGHT : COLOR_3DFACE );
  1324.          FillSolidRect( hDC, rc.left, rc.top - 1,
  1325.                              rc.right, 1,
  1326.                              clr1 );
  1327.          FillSolidRect( hDC, rc.left, rc.bottom,
  1328.                              rc.right, 1,                                  
  1329.                              clr2 );
  1331.          if ( dwStyle & UDS_ALIGNLEFT )
  1332.             FillSolidRect( hDC, rc.left - 1, rc.top - 1,
  1333.                                 1, rc.bottom,
  1334.                                 clr1 );
  1335.          else
  1336.             FillSolidRect( hDC, rc.right, rc.top - 1,
  1337.                                 1, rc.bottom,
  1338.                                 clr2 );
  1339.       }
  1340.    }
  1342.    RECT r = rc;
  1343.    if ( dwStyle & UDS_HORZ )
  1344.    {
  1345.       r.right = r.left + ( rc.right - rc.left ) / 2;
  1346.       DrawButton( hDC, r );
  1348.       r.left = r.right + ( rc.right - rc.left ) % 2;
  1349.       r.right = rc.right;
  1350.       DrawButton( hDC, r );
  1351.    }
  1352.    else
  1353.    {
  1354.       r.bottom = r.top + ( rc.bottom - rc.top ) / 2;
  1355.       DrawButton( hDC, r );
  1357.       r.top = r.bottom + ( rc.bottom - rc.top ) % 2;
  1358.       r.bottom = rc.bottom;
  1359.       DrawButton( hDC, r );
  1360.    }
  1362.    if ( pCtl == NULL )  // Get parent (e.g. for datetime with up-down controls)
  1363.    {
  1364.       hWnd = GetParent( m_hWnd );
  1365.       g_ctrlManager.m_ctrlMap.Lookup( hWnd, (void*&)pCtl );
  1366.    }
  1368.    if ( pCtl && IsWindowEnabled( hWnd ) )   // Redraw parent or buddy if neccesary
  1369.    {
  1370.       if ( m_nState & dsHoverMask )
  1371.          pCtl->SetState( 0, dsHover );
  1372.       else
  1373.          pCtl->SetState( dsHover, 0 );
  1374.    }
  1375. }
  1377. //////////////////////////////////////////////////////////////////////////////
  1378. // CCMEditCombo class
  1380. void CCoolControlsManager::CCMEditCombo::PrepareDraw( HDC& hDC, RECT& rect )
  1381. {
  1382.    GetWindowRect( m_hWnd, &rect );
  1383.    InflateRect( &rect, 3, 3 );
  1384.    OffsetRect( &rect, -rect.left, -rect.top );
  1385.    // Draw onto that DC that is most suitable for given class   
  1386.    hDC = GetWindowDC( GetParent( m_hWnd ) );
  1387. }
  1389. //////////////////////////////////////////////////////////////////////////////
  1390. // CCMScrollBar class
  1392. void CCoolControlsManager::CCMScrollBar::DrawControl( HDC hDC, const RECT& rc )
  1393. {  
  1394.    DrawScrollBar( hDC, rc, 
  1395.              ( GetWindowLong( m_hWnd, GWL_STYLE ) & SBS_VERT ) ? SB_VERT : SB_HORZ,
  1396.              TRUE );
  1397. }
  1399. LRESULT CCoolControlsManager::CCMScrollBar::WindowProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
  1400. {
  1401.    switch ( uMsg )
  1402.    {      
  1403.       // Scrollbar messages
  1404.       case SBM_SETPOS:
  1405.          if ( !lParam )  // redraw flag
  1406.             break;
  1408.       case SBM_SETSCROLLINFO:      
  1409.          if ( !wParam )  // redraw flag
  1410.             break;
  1412.       case SBM_SETRANGEREDRAW:
  1413.          CallWindowProc( m_oldWndProc, m_hWnd, uMsg, wParam, lParam );
  1414.          DrawBorder();
  1415.          return 0;
  1417.       default:
  1418.          return CCMControl::WindowProc( uMsg, wParam, lParam );
  1419.    }
  1421.    return CallWindowProc( m_oldWndProc, m_hWnd, uMsg, wParam, lParam );
  1422. }
  1424. //////////////////////////////////////////////////////////////////////////////
  1425. // CCMHeaderCtrl class
  1427. void CCoolControlsManager::CCMHeaderCtrl::DrawButton( HDC hDC, const RECT& rc, int nState )
  1428. {
  1429.    if ( nState & dsHoverMask )
  1430.       Draw3dBorder( hDC, rc, COLOR_3DHIGHLIGHT, COLOR_3DDKSHADOW,
  1431.                              COLOR_3DLIGHT, COLOR_3DSHADOW );
  1432.    else
  1433.       Draw3dBorder( hDC, rc, COLOR_3DHIGHLIGHT, COLOR_3DSHADOW,
  1434.                              COLOR_3DFACE, COLOR_3DFACE );      
  1435. }
  1437. void CCoolControlsManager::CCMHeaderCtrl::DrawControl( HDC hDC, const RECT& /*rc*/ )
  1438. {
  1439.    int nOldItem = m_nOldItem;
  1440.    m_nOldItem = -1;
  1442.    RECT rc;
  1443.    POINT point;
  1444.    GetCursorPos( &point );
  1446.    // This code fails if we will have standalone header control but such cases are rare...
  1447.    HWND hWnd = GetParent( m_hWnd ); 
  1448.    GetClientRect( GetParent( m_hWnd ), &rc );
  1449.    ScreenToClient( GetParent( m_hWnd ), &point );
  1450.    // Test if mouse pointer is within the client area of the list control
  1451.    BOOL bInView = PtInRect( &rc, point );    
  1453.    GetClientRect( m_hWnd, &rc );
  1454.    rc.right = 0;
  1455.    GetCursorPos( &point );
  1456.    ScreenToClient( m_hWnd, &point );
  1457.    hDC = GetDC( m_hWnd );
  1458.    
  1459.    int nState;
  1460.    int nCount = SendMessage( m_hWnd, HDM_GETITEMCOUNT, 0, 0L );   
  1462.    for ( int i = 0; i < nCount; i++ )
  1463.    {
  1464.     #if (_WIN32_IE >= 0x0300)
  1465.       HDITEM hi;
  1466.       hi.mask = HDI_ORDER;
  1467.       SendMessage( m_hWnd, HDM_GETITEM, i, (LPARAM)&hi );
  1468.       SendMessage( m_hWnd, HDM_GETITEMRECT, hi.iOrder, (LPARAM)&rc );
  1469.     #else
  1470.       SendMessage( m_hWnd, HDM_GETITEMRECT, i, (LPARAM)&rc );
  1471.     #endif
  1472.       nState = 0;
  1473.       if ( bInView & PtInRect( &rc, point ) )
  1474.       {
  1475.          nState = dsHover;
  1476.        #if (_WIN32_IE >= 0x0300)
  1477.          m_nOldItem = hi.iOrder;
  1478.        #else
  1479.          m_nOldItem = i;
  1480.        #endif
  1481.       }
  1482.       DrawButton( hDC, rc, nState );
  1483.    }
  1485.    int l = rc.right;
  1486.    GetClientRect( m_hWnd, &rc );
  1487.    rc.left = l;
  1488.    DrawButton( hDC, rc, 0 );
  1490.    // If header is a child of ListView, redraw the list so 
  1491.    // it will indicate proper state      
  1492.    CCMControl* pCtl;   
  1493.    if ( g_ctrlManager.m_ctrlMap.Lookup( hWnd, (void*&)pCtl ) )
  1494.    {
  1495.       if ( m_nOldItem >= 0 )
  1496.          pCtl->SetState( 0, dsHover );
  1497.       else if ( nOldItem >= 0 )
  1498.          pCtl->SetState( dsHover, 0 );
  1499.    }
  1501.    ReleaseDC( m_hWnd, hDC );
  1502. }
  1504. BOOL CCoolControlsManager::CCMHeaderCtrl::NeedRedraw( const POINT& point )
  1505. {
  1506.    RECT rc;
  1507.    GetClientRect( m_hWnd, &rc );
  1508.    rc.right = 0;
  1510.    POINT pt = point;
  1511.    ScreenToClient( m_hWnd, &pt );
  1513.    int nItem = -1;
  1514.    int nCount = SendMessage( m_hWnd, HDM_GETITEMCOUNT, 0, 0L );
  1516.    for ( int i = 0; i < nCount; i++ )
  1517.    {
  1518.       HDITEM hi;
  1519.       hi.mask = HDI_WIDTH;      
  1520.       SendMessage( m_hWnd, HDM_GETITEM, i, (LPARAM)&hi );
  1521.       rc.left = rc.right;
  1522.       rc.right = rc.left + hi.cxy;
  1523.       if ( PtInRect( &rc, pt ) )
  1524.       {
  1525.          nItem = i;
  1526.          break;
  1527.       }
  1528.    }
  1530.    if ( m_hWnd != m_hWndOld || ( m_hWnd == m_hWndOld && m_nOldItem != nItem ) )
  1531.       return TRUE;
  1532.    return FALSE;
  1533. }
  1535. //////////////////////////////////////////////////////////////////////////////
  1536. // CCMTrackbar class
  1538. void CCoolControlsManager::CCMTrackbar::DrawThumb( HDC hDC, const RECT& rc )
  1539. {
  1540.    DWORD dwStyle = GetWindowLong( m_hWnd, GWL_STYLE );
  1542.    if ( dwStyle & TBS_BOTH )
  1543.    {
  1544.       FillSolidRect( hDC, rc, GetSysColor( COLOR_3DFACE ) );
  1545.       if ( m_nState & dsHoverMask )
  1546.          Draw3dBorder( hDC, rc, COLOR_3DHIGHLIGHT, COLOR_3DDKSHADOW,
  1547.                                 COLOR_3DLIGHT, COLOR_3DSHADOW );
  1548.       else
  1549.          Draw3dBorder( hDC, rc, COLOR_3DHIGHLIGHT, COLOR_3DSHADOW,
  1550.                                 COLOR_3DFACE, COLOR_3DFACE );      
  1551.       return;
  1552.    }
  1553.    
  1554.    HPEN penHighlight = CreatePen( PS_SOLID, 1, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1555.    HPEN penLight = CreatePen( PS_SOLID, 1, GetSysColor( m_nState & dsHoverMask ? COLOR_3DLIGHT : COLOR_3DFACE ) );
  1556.    HPEN penDkShadow = CreatePen( PS_SOLID, 1, GetSysColor( m_nState & dsHoverMask ? COLOR_3DDKSHADOW : COLOR_3DSHADOW ) );
  1557.    HPEN penShadow = CreatePen( PS_SOLID, 1, GetSysColor( m_nState & dsHoverMask ? COLOR_3DSHADOW : COLOR_3DFACE ) );
  1559.    int n;
  1560.    if ( dwStyle & TBS_VERT )
  1561.    {
  1562.       if ( dwStyle & TBS_LEFT )
  1563.       {    
  1564.          n = ( rc.bottom - rc.top ) / 2 + 1;
  1566.          FillSolidRect( hDC, rc, GetSysColor( COLOR_3DFACE ) );
  1567.       
  1568.          HPEN hOldPen = (HPEN)SelectObject( hDC, penHighlight );
  1569.          MoveToEx( hDC, rc.right - 2, rc.top, NULL );
  1570.          LineTo( hDC, rc.left + n - 1, rc.top );
  1571.          LineTo( hDC, rc.left, rc.top + n - 1 );         
  1572.          
  1573.          SelectObject( hDC, penDkShadow );
  1574.          LineTo( hDC, rc.left + n - 1, rc.bottom - 1 );
  1575.          LineTo( hDC, rc.right - 1, rc.bottom - 1 );
  1576.          LineTo( hDC, rc.right - 1, rc.top - 1 );
  1578.          SelectObject( hDC, penLight );
  1579.          MoveToEx( hDC, rc.right - 3, rc.top + 1, NULL );
  1580.          LineTo( hDC, rc.left + n - 1, rc.top + 1 );
  1581.          LineTo( hDC, rc.left + 1, rc.top + n - 1 );
  1583.          SelectObject( hDC, penShadow );         
  1584.          LineTo( hDC, rc.left + n - 1, rc.bottom - 2 );
  1585.          LineTo( hDC, rc.right - 2, rc.bottom - 2 );
  1586.          LineTo( hDC, rc.right - 2, rc.top );
  1588.          SelectObject( hDC, hOldPen );         
  1589.       }
  1590.       else // TBS_RIGHT
  1591.       {
  1592.          n = ( rc.bottom - rc.top ) / 2 + 1;
  1594.          FillSolidRect( hDC, rc, GetSysColor( COLOR_3DFACE ) );
  1595.       
  1596.          HPEN hOldPen = (HPEN)SelectObject( hDC, penHighlight );
  1597.          MoveToEx( hDC, rc.left, rc.bottom - 2, NULL );
  1598.          LineTo( hDC, rc.left, rc.top );
  1599.          LineTo( hDC, rc.right - n, rc.top );
  1600.          LineTo( hDC, rc.right - 1, rc.top + n - 1 );
  1602.          SelectObject( hDC, penDkShadow );          
  1603.          MoveToEx( hDC, rc.left, rc.bottom - 1, NULL );
  1604.          LineTo( hDC, rc.right - n, rc.bottom - 1 );
  1605.          LineTo( hDC, rc.right, rc.top + n - 2 );         
  1607.          SelectObject( hDC, penLight );
  1608.          MoveToEx( hDC, rc.left + 1, rc.bottom - 3, NULL );
  1609.          LineTo( hDC, rc.left + 1, rc.top + 1 );
  1610.          LineTo( hDC, rc.right - n, rc.top + 1 );
  1611.          LineTo( hDC, rc.right - 2, rc.top + n - 1 );
  1613.          SelectObject( hDC, penShadow );
  1614.          MoveToEx( hDC, rc.left + 1, rc.bottom - 2, NULL );
  1615.          LineTo( hDC, rc.right - n, rc.bottom - 2 );
  1616.          LineTo( hDC, rc.right - 1, rc.top + n - 2 );         
  1618.          SelectObject( hDC, hOldPen );
  1619.       }      
  1620.    }
  1621.    else
  1622.    {
  1623.       if ( dwStyle & TBS_TOP )
  1624.       {      
  1625.          n = ( rc.right - rc.left ) / 2 + 1;
  1627.          FillSolidRect( hDC, rc, GetSysColor( COLOR_3DFACE ) );
  1628.       
  1629.          HPEN hOldPen = (HPEN)SelectObject( hDC, penHighlight );
  1630.          MoveToEx( hDC, rc.left + n - 2, rc.top + 1, NULL );
  1631.          LineTo( hDC, rc.left, rc.top + n - 1 );
  1632.          LineTo( hDC, rc.left, rc.bottom - 1 );
  1634.          SelectObject( hDC, penDkShadow );          
  1635.          LineTo( hDC, rc.right - 1, rc.bottom - 1 );
  1636.          LineTo( hDC, rc.right - 1, rc.top + n - 1 );
  1637.          LineTo( hDC, rc.left + n - 2, rc.top - 1 );
  1639.          SelectObject( hDC, penLight );
  1640.          MoveToEx( hDC, rc.left + n - 2, rc.top + 2, NULL );
  1641.          LineTo( hDC, rc.left + 1, rc.top + n - 1 );
  1642.          LineTo( hDC, rc.left + 1, rc.bottom - 2 );
  1643.      
  1644.          SelectObject( hDC, penShadow );
  1645.          LineTo( hDC, rc.right - 2, rc.bottom - 2 );
  1646.          LineTo( hDC, rc.right - 2, rc.top + n - 1 );
  1647.          LineTo( hDC, rc.left + n - 2, rc.top );
  1649.          SelectObject( hDC, hOldPen );
  1650.       }
  1651.       else // TBS_BOTTOM
  1652.       {
  1653.          n = ( rc.right - rc.left ) / 2 + 1;
  1655.          FillSolidRect( hDC, rc, GetSysColor( COLOR_3DFACE ) );
  1656.                
  1657.          HPEN hOldPen = (HPEN)SelectObject( hDC, penHighlight );
  1658.          MoveToEx( hDC, rc.left + n - 2, rc.bottom - 2, NULL );
  1659.          LineTo( hDC, rc.left, rc.bottom - n );
  1660.          LineTo( hDC, rc.left, rc.top );
  1661.          LineTo( hDC, rc.right - 1, rc.top );
  1663.          SelectObject( hDC, penDkShadow );          
  1664.          LineTo( hDC, rc.right - 1, rc.bottom - n );
  1665.          LineTo( hDC, rc.left + n - 2, rc.bottom );
  1667.          SelectObject( hDC, penLight );
  1668.          MoveToEx( hDC, rc.left + n - 2, rc.bottom - 3, NULL );
  1669.          LineTo( hDC, rc.left + 1, rc.bottom - n );
  1670.          LineTo( hDC, rc.left + 1, rc.top + 1 );
  1671.          LineTo( hDC, rc.right - 2, rc.top + 1 );
  1672.      
  1673.          SelectObject( hDC, penShadow );
  1674.          LineTo( hDC, rc.right - 2, rc.bottom - n );
  1675.          LineTo( hDC, rc.left + n - 2, rc.bottom - 1 );
  1677.          SelectObject( hDC, hOldPen );
  1678.       }
  1679.    }
  1681.    DeleteObject( penHighlight );
  1682.    DeleteObject( penLight );
  1683.    DeleteObject( penDkShadow );
  1684.    DeleteObject( penShadow );
  1685. }
  1687. void CCoolControlsManager::CCMTrackbar::DrawControl( HDC hDC, const RECT& /*rect*/ )
  1688. {  
  1689.    hDC = GetDC( m_hWnd );
  1690.    DWORD dwStyle = GetWindowLong( m_hWnd, GWL_STYLE );
  1691.    
  1692.    RECT rc;   
  1693.    SendMessage( m_hWnd, TBM_GETCHANNELRECT, 0, (LPARAM)&rc );   
  1695.    // BUG!: Windows incorrectly calculates the channel rectangle for
  1696.    // sliders with TBS_VERT style, so we have to calculate the rectangle
  1697.    // in different manner. This bug appears on all Windows platforms!
  1698.    if ( dwStyle & TBS_VERT )
  1699.    {  
  1700.       int w = ( rc.right - rc.left );
  1701.       int h = ( rc.bottom - rc.top );
  1702.       rc.top = rc.left;
  1703.       rc.bottom = rc.left + w;
  1705.       RECT r;
  1706.       SendMessage( m_hWnd, TBM_GETTHUMBRECT, 0, (LPARAM)&r );         
  1708.       rc.left = r.left + ( ( r.right - r.left ) / 2 + 1 ) - h / 2;
  1709.       if ( dwStyle & TBS_LEFT )
  1710.          ;
  1711.       else if ( dwStyle & TBS_BOTH )
  1712.          rc.left -= 1;
  1713.       else
  1714.          rc.left -= 2;
  1716.       rc.right = rc.left + h;
  1717.    }
  1719.    // Draw the channel rect
  1720.    if ( m_nState & dsHoverMask )
  1721.       Draw3dBorder( hDC, rc, COLOR_3DSHADOW, COLOR_3DHIGHLIGHT,                         
  1722.                              COLOR_3DDKSHADOW, COLOR_3DLIGHT );
  1723.    else
  1724.       Draw3dBorder( hDC, rc, COLOR_3DSHADOW, COLOR_3DHIGHLIGHT,                         
  1725.                              COLOR_3DFACE, COLOR_3DFACE );
  1726.    
  1727.    // Draw the slider thumb
  1728.    if ( !( dwStyle & TBS_NOTHUMB ) )
  1729.    {
  1730.       SetRectEmpty( &rc );
  1731.       SendMessage( m_hWnd, TBM_GETTHUMBRECT, 0, (LPARAM)&rc );
  1732.       DrawThumb( hDC, rc );
  1733.    }
  1735.    ReleaseDC( m_hWnd, hDC );
  1736. }
  1738. //////////////////////////////////////////////////////////////////////////////
  1739. // CCMToolbar class
  1741. void CCoolControlsManager::CCMToolbar::DrawButton( HDC hDC, const RECT& rc, int nState )
  1742. {
  1743.    if ( nState & bsChecked )
  1744.    {
  1745.       if ( nState & bsHover )
  1746.          Draw3dBorder( hDC, rc,
  1747.                        COLOR_3DDKSHADOW, COLOR_3DHIGHLIGHT,
  1748.                        COLOR_3DSHADOW, COLOR_3DSHADOW );
  1749.       else
  1750.          Draw3dBorder( hDC, rc,
  1751.                        COLOR_3DSHADOW, COLOR_3DHIGHLIGHT,
  1752.                        COLOR_3DFACE, COLOR_3DFACE );
  1753.    }
  1754.    else
  1755.    {
  1756.       if ( nState & bsHover )
  1757.          Draw3dBorder( hDC, rc,
  1758.                        COLOR_3DHIGHLIGHT, COLOR_3DDKSHADOW,
  1759.                        COLOR_3DLIGHT, COLOR_3DSHADOW );
  1760.       else
  1761.          Draw3dBorder( hDC, rc,
  1762.                        COLOR_3DHIGHLIGHT, COLOR_3DSHADOW,
  1763.                        COLOR_3DFACE, COLOR_3DFACE );
  1764.    }
  1765. }
  1767. void CCoolControlsManager::CCMToolbar::DrawControl( HDC hDC, const RECT& /*rc*/ )
  1768. {
  1769.    if ( GetWindowLong( m_hWnd, GWL_STYLE ) & TBSTYLE_FLAT ) // Skip flat toolbars
  1770.       return;
  1771.       
  1772.    int nCount = SendMessage( m_hWnd, TB_BUTTONCOUNT, 0, 0L );
  1774.    hDC = GetDC( m_hWnd );  // We will draw toolbar buttons on the client DC
  1776.    POINT point;
  1777.    GetCursorPos( &point );
  1778.    ScreenToClient( m_hWnd, &point );
  1779.    
  1780.    m_nOldItem = -1;
  1781.    int nState = 0;
  1782.            
  1783.    for ( int i = 0; i < nCount; i++ )
  1784.    {     
  1785.       RECT rc;       
  1786.       TBBUTTON ti;
  1787.       SendMessage( m_hWnd, TB_GETBUTTON, i, (LPARAM)&ti );
  1788.       SendMessage( m_hWnd, TB_GETITEMRECT, i, (LPARAM)&rc );
  1790.       if ( !( ti.fsStyle & TBSTYLE_SEP ) )
  1791.       {                  
  1792.          nState = ( ti.fsState & TBSTATE_CHECKED ) ? bsChecked : bsNormal;
  1793.          if ( PtInRect( &rc, point ) == TRUE )
  1794.          {
  1795.             if ( ti.fsState & TBSTATE_ENABLED )
  1796.                nState |= bsHover;
  1797.             m_nOldItem = i;
  1798.          }         
  1799.          DrawButton( hDC, rc, nState );
  1800.       }
  1801.    }
  1802.       
  1803.    ReleaseDC( m_hWnd, hDC );
  1804. }
  1806. BOOL CCoolControlsManager::CCMToolbar::NeedRedraw( const POINT& point )
  1807. {
  1808.    int nCount = SendMessage( m_hWnd, TB_BUTTONCOUNT, 0, 0L );
  1810.    POINT pt = point;
  1811.    ScreenToClient( m_hWnd, &pt );
  1812.    int nItem = -1;                
  1813.    for ( int i = 0; i < nCount; i++ )
  1814.    {            
  1815.       TBBUTTON ti;      
  1816.       SendMessage( m_hWnd, TB_GETBUTTON, i, (LPARAM)&ti );
  1818.       if ( !( ti.fsStyle & TBSTYLE_SEP ) )
  1819.       {
  1820.          RECT rc;         
  1821.          SendMessage( m_hWnd, TB_GETITEMRECT, i, (LPARAM)&rc );
  1822.          if ( PtInRect( &rc, pt ) )
  1823.          {
  1824.             nItem = i;
  1825.             break;
  1826.          }
  1827.       }
  1828.    }
  1830.    if ( m_hWnd != m_hWndOld || ( m_hWnd == m_hWndOld && m_nOldItem != nItem ) )
  1831.       return TRUE;
  1832.    return FALSE;
  1833. }
  1835. LRESULT CCoolControlsManager::CCMToolbar::WindowProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
  1836. {
  1837.    switch ( uMsg )
  1838.    {  
  1839.       case WM_PAINT:
  1840.       case WM_NCPAINT:
  1841.          m_nOldItem = -1;   // Redraw the whole toolbar unconditionally
  1843.       default:
  1844.          return CCMControl::WindowProc( uMsg, wParam, lParam );
  1845.    }
  1846. }
  1848. //////////////////////////////////////////////////////////////////////////////
  1849. // CCMTabControl class
  1851. void CCoolControlsManager::CCMTabControl::DrawTab( HDC hDC, const RECT& rect, 
  1852.                                                    int nItem, int nState )
  1853. {
  1854.    RECT rc = rect;
  1855.    int nCurSel = SendMessage( m_hWnd, TCM_GETCURSEL, 0, 0L );
  1856.    if ( nCurSel == -1 )
  1857.       nCurSel = -2;
  1859.    switch ( GetOrientation() )
  1860.    {
  1861.       case tabLeft:
  1862.          if ( nState & bsChecked )
  1863.          {
  1864.             rc.top -= 2;
  1865.             rc.bottom += 2;
  1866.             rc.left -= 2;
  1867.             rc.right += 1;
  1868.          }
  1870.          if ( nState & bsHover )
  1871.          {
  1872.             if ( nCurSel != nItem - 1 )
  1873.             {
  1874.                FillSolidRect( hDC, rc.left+2, rc.top, rc.right-rc.left-2, 1, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1875.                FillSolidRect( hDC, rc.left+2, rc.top+1, rc.right-rc.left-2, 1, GetSysColor( COLOR_3DLIGHT ) );
  1876.                SetPixel( hDC, rc.left+1, rc.top+1, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1877.             }
  1879.             FillSolidRect( hDC, rc.left, rc.top+2, 1, rc.bottom-rc.top-4, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1880.             FillSolidRect( hDC, rc.left+1, rc.top+2, 1, rc.bottom-rc.top-4, GetSysColor( COLOR_3DLIGHT ) );
  1882.             if ( nCurSel != nItem + 1 )
  1883.             {
  1884.                FillSolidRect( hDC, rc.left+2, rc.bottom-1, rc.right-rc.left-2, 1, GetSysColor( COLOR_3DDKSHADOW ) );
  1885.                FillSolidRect( hDC, rc.left+2, rc.bottom-2, rc.right-rc.left-2, 1, GetSysColor( COLOR_3DSHADOW ) );                        
  1886.                SetPixel( hDC, rc.left+1, rc.bottom-2, GetSysColor( COLOR_3DDKSHADOW ) );
  1887.             }
  1888.          }
  1889.          else
  1890.          {
  1891.             if ( nCurSel != nItem - 1 )
  1892.             {
  1893.                FillSolidRect( hDC, rc.left+2, rc.top, rc.right-rc.left-2, 1, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1894.                FillSolidRect( hDC, rc.left+2, rc.top+1, rc.right-rc.left-2, 1, GetSysColor( COLOR_3DFACE ) );
  1895.                SetPixel( hDC, rc.left+1, rc.top+1, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1896.             }
  1898.             FillSolidRect( hDC, rc.left, rc.top+2, 1, rc.bottom-rc.top-4, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1899.             FillSolidRect( hDC, rc.left+1, rc.top+2, 1, rc.bottom-rc.top-4, GetSysColor( COLOR_3DFACE ) );
  1901.             if ( nCurSel != nItem + 1 )
  1902.             {
  1903.                FillSolidRect( hDC, rc.left+2, rc.bottom-1, rc.right-rc.left-2, 1, GetSysColor( COLOR_3DSHADOW ) );
  1904.                FillSolidRect( hDC, rc.left+2, rc.bottom-2, rc.right-rc.left-2, 1, GetSysColor( COLOR_3DFACE ) );                        
  1905.                SetPixel( hDC, rc.left+1, rc.bottom-2, GetSysColor( COLOR_3DSHADOW ) );
  1906.             }
  1907.          }       
  1908.          break;
  1910.       case tabTop:
  1911.          if ( nState & bsChecked )
  1912.          {
  1913.             rc.top -= 2;
  1914.             rc.bottom += 1;
  1915.             rc.left -= 2;
  1916.             rc.right += 2;
  1917.          }
  1919.          if ( nState & bsHover )
  1920.          {
  1921.             if ( nCurSel != nItem - 1 )
  1922.             {
  1923.                FillSolidRect( hDC, rc.left, rc.top+2, 1, rc.bottom-rc.top-2, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1924.                FillSolidRect( hDC, rc.left+1, rc.top+2, 1, rc.bottom-rc.top-2, GetSysColor( COLOR_3DLIGHT ) );
  1925.                SetPixel( hDC, rc.left+1, rc.top+1, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1926.             }
  1928.             FillSolidRect( hDC, rc.left+2, rc.top, rc.right-rc.left-4, 1, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1929.             FillSolidRect( hDC, rc.left+2, rc.top+1, rc.right-rc.left-4, 1, GetSysColor( COLOR_3DLIGHT ) );
  1931.             if ( nCurSel != nItem + 1 )
  1932.             {
  1933.                FillSolidRect( hDC, rc.right-1, rc.top+2, 1, rc.bottom-rc.top-2, GetSysColor( COLOR_3DDKSHADOW ) );
  1934.                FillSolidRect( hDC, rc.right-2, rc.top+2, 1, rc.bottom-rc.top-2, GetSysColor( COLOR_3DSHADOW ) );            
  1935.                SetPixel( hDC, rc.right-2, rc.top+1, GetSysColor( COLOR_3DDKSHADOW ) );
  1936.             }                       
  1937.          }
  1938.          else
  1939.          {
  1940.             if ( nCurSel != nItem - 1 )
  1941.             {
  1942.                FillSolidRect( hDC, rc.left, rc.top+2, 1, rc.bottom-rc.top-2, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1943.                FillSolidRect( hDC, rc.left+1, rc.top+2, 1, rc.bottom-rc.top-2, GetSysColor( COLOR_3DFACE ) );
  1944.                SetPixel( hDC, rc.left+1, rc.top+1, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1945.             }
  1947.             FillSolidRect( hDC, rc.left+2, rc.top, rc.right-rc.left-4, 1, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1948.             FillSolidRect( hDC, rc.left+2, rc.top+1, rc.right-rc.left-4, 1, GetSysColor( COLOR_3DFACE ) );
  1950.             if ( nCurSel != nItem + 1 )
  1951.             {
  1952.                FillSolidRect( hDC, rc.right-1, rc.top+2, 1, rc.bottom-rc.top-2, GetSysColor( COLOR_3DSHADOW ) );
  1953.                FillSolidRect( hDC, rc.right-2, rc.top+2, 1, rc.bottom-rc.top-2, GetSysColor( COLOR_3DFACE ) );                        
  1954.                SetPixel( hDC, rc.right-2, rc.top+1, GetSysColor( COLOR_3DSHADOW ) );
  1955.             }
  1956.          }       
  1957.          break;
  1958.       
  1959.       case tabRight:
  1960.          if ( nState & bsChecked )
  1961.          {
  1962.             rc.top -= 2;
  1963.             rc.bottom += 2;
  1964.             rc.right += 2;
  1965.             rc.left -= 1;
  1966.          }
  1968.          if ( nState & bsHover )
  1969.          {
  1970.             if ( nCurSel != nItem - 1 )
  1971.             {
  1972.                FillSolidRect( hDC, rc.left, rc.top, rc.right-rc.left-2, 1, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1973.                FillSolidRect( hDC, rc.left, rc.top+1, rc.right-rc.left-2, 1, GetSysColor( COLOR_3DLIGHT ) );
  1974.                SetPixel( hDC, rc.right-2, rc.top+1, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1975.             }
  1977.             FillSolidRect( hDC, rc.right-1, rc.top+2, 1, rc.bottom-rc.top-4, GetSysColor( COLOR_3DDKSHADOW ) );
  1978.             FillSolidRect( hDC, rc.right-2, rc.top+2, 1, rc.bottom-rc.top-4, GetSysColor( COLOR_3DSHADOW ) );
  1980.             if ( nCurSel != nItem + 1 )
  1981.             {
  1982.                FillSolidRect( hDC, rc.left, rc.bottom-2, rc.right-rc.left-2, 1, GetSysColor( COLOR_3DSHADOW ) );
  1983.                FillSolidRect( hDC, rc.left, rc.bottom-1, rc.right-rc.left-2, 1, GetSysColor( COLOR_3DDKSHADOW ) );
  1984.                SetPixel( hDC, rc.right-2, rc.bottom-2, GetSysColor( COLOR_3DDKSHADOW ) );
  1985.             }
  1986.          }
  1987.          else
  1988.          {
  1989.             if ( nCurSel != nItem - 1 )
  1990.             {
  1991.                FillSolidRect( hDC, rc.left, rc.top, rc.right-rc.left-2, 1, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1992.                FillSolidRect( hDC, rc.left, rc.top+1, rc.right-rc.left-2, 1, GetSysColor( COLOR_3DFACE ) );
  1993.                SetPixel( hDC, rc.right-2, rc.top+1, GetSysColor( COLOR_3DHIGHLIGHT ) );
  1994.             }
  1996.             FillSolidRect( hDC, rc.right-1, rc.top+2, 1, rc.bottom-rc.top-4, GetSysColor( COLOR_3DSHADOW ) );
  1997.             FillSolidRect( hDC, rc.right-2, rc.top+2, 1, rc.bottom-rc.top-4, GetSysColor( COLOR_3DFACE ) );            
  1999.             if ( nCurSel != nItem + 1 )
  2000.             {
  2001.                FillSolidRect( hDC, rc.left, rc.bottom-1, rc.right-rc.left-2, 1, GetSysColor( COLOR_3DSHADOW ) );            
  2002.                FillSolidRect( hDC, rc.left, rc.bottom-2, rc.right-rc.left-2, 1, GetSysColor( COLOR_3DFACE ) );
  2003.                SetPixel( hDC, rc.right-2, rc.bottom-2, GetSysColor( COLOR_3DSHADOW ) );
  2004.             }                        
  2005.          }       
  2006.          break;
  2008.       case tabBottom:
  2009.          if ( nState & bsChecked )
  2010.          {
  2011.             rc.bottom += 2;
  2012.             rc.left -= 2;
  2013.             rc.right += 2;
  2014.             rc.top -=1;
  2015.          }
  2017.          if ( nState & bsHover )
  2018.          {
  2019.             if ( nCurSel != nItem - 1 )
  2020.             {
  2021.                FillSolidRect( hDC, rc.left, rc.top, 1, rc.bottom-rc.top-2, GetSysColor( COLOR_3DHIGHLIGHT ) );
  2022.                FillSolidRect( hDC, rc.left+1, rc.top, 1, rc.bottom-rc.top-2, GetSysColor( COLOR_3DLIGHT ) );
  2023.                SetPixel( hDC, rc.left+1, rc.bottom-2, GetSysColor( COLOR_3DHIGHLIGHT ) );
  2024.             }
  2026.             FillSolidRect( hDC, rc.left+2, rc.bottom-1, rc.right-rc.left-4, 1, GetSysColor( COLOR_3DDKSHADOW ) );
  2027.             FillSolidRect( hDC, rc.left+2, rc.bottom-2, rc.right-rc.left-4, 1, GetSysColor( COLOR_3DSHADOW ) );
  2029.             if ( nCurSel != nItem + 1 )
  2030.             {
  2031.                FillSolidRect( hDC, rc.right-1, rc.top, 1, rc.bottom-rc.top-2, GetSysColor( COLOR_3DDKSHADOW ) );
  2032.                FillSolidRect( hDC, rc.right-2, rc.top, 1, rc.bottom-rc.top-2, GetSysColor( COLOR_3DSHADOW ) );                        
  2033.                SetPixel( hDC, rc.right-2, rc.bottom-2, GetSysColor( COLOR_3DDKSHADOW ) );
  2034.             }
  2035.          }
  2036.          else
  2037.          {
  2038.             if ( nCurSel != nItem - 1 )
  2039.             {
  2040.                FillSolidRect( hDC, rc.left, rc.top, 1, rc.bottom-rc.top-2, GetSysColor( COLOR_3DHIGHLIGHT ) );
  2041.                FillSolidRect( hDC, rc.left+1, rc.top, 1, rc.bottom-rc.top-2, GetSysColor( COLOR_3DFACE ) );
  2042.                SetPixel( hDC, rc.left+1, rc.bottom-2, GetSysColor( COLOR_3DHIGHLIGHT ) );
  2043.             }
  2045.             FillSolidRect( hDC, rc.left+2, rc.bottom-1, rc.right-rc.left-4, 1, GetSysColor( COLOR_3DSHADOW ) );
  2046.             FillSolidRect( hDC, rc.left+2, rc.bottom-2, rc.right-rc.left-4, 1, GetSysColor( COLOR_3DFACE ) );
  2048.             if ( nCurSel != nItem + 1 )
  2049.             {
  2050.                FillSolidRect( hDC, rc.right-1, rc.top, 1, rc.bottom-rc.top-2, GetSysColor( COLOR_3DSHADOW ) );
  2051.                FillSolidRect( hDC, rc.right-2, rc.top, 1, rc.bottom-rc.top-2, GetSysColor( COLOR_3DFACE ) );
  2052.                SetPixel( hDC, rc.right-2, rc.bottom-2, GetSysColor( COLOR_3DSHADOW ) );
  2053.             }
  2054.          }       
  2055.          break;
  2056.    }
  2057. }
  2059. CCoolControlsManager::CCMTabControl::OrientationsEnum CCoolControlsManager::CCMTabControl::GetOrientation() const
  2060. {
  2061.    DWORD dwStyle = GetWindowLong( m_hWnd, GWL_STYLE );
  2062.    if ( dwStyle & TCS_BOTTOM )
  2063.    {
  2064.       if ( dwStyle & TCS_VERTICAL )
  2065.          return tabRight;
  2066.       else
  2067.          return tabBottom;               
  2068.    }
  2069.    else  
  2070.    { 
  2071.       if ( dwStyle & TCS_VERTICAL )
  2072.          return tabLeft;
  2073.       else
  2074.          return tabTop;
  2075.    }
  2076. }
  2078. void CCoolControlsManager::CCMTabControl::DrawControl( HDC hDC, const RECT& rect )
  2079. {
  2080.    DWORD dwStyle = GetWindowLong( m_hWnd, GWL_STYLE );
  2081.    if ( dwStyle & TCS_BUTTONS ) // Skip button-like tab controls
  2082.       return;
  2083.       
  2084.    hDC = GetDC( m_hWnd );  // We will draw on the client DC
  2086.    RECT rc = rect;
  2087.    SendMessage( m_hWnd, TCM_ADJUSTRECT, FALSE, (LPARAM)&rc );   
  2088.    InflateRect( &rc, 4, 4 );
  2090.    RECT rcSel;
  2091.    int nCurSel = SendMessage( m_hWnd, TCM_GETCURSEL, 0, 0L );
  2092.    SendMessage( m_hWnd, TCM_GETITEMRECT, nCurSel, (LPARAM)&rcSel );
  2094.    switch ( GetOrientation() )
  2095.    {
  2096.       case tabLeft:
  2097.          rc.left += 2;
  2098.          FillSolidRect( hDC, rc.left, rc.bottom, rc.right-rc.left, -1, GetSysColor( COLOR_3DSHADOW ) );
  2099.          FillSolidRect( hDC, rc.right, rc.top, -1, rc.bottom-rc.top, GetSysColor( COLOR_3DSHADOW ) );         
  2100.          break;
  2102.       case tabTop:
  2103.          rc.top += 2;                  
  2104.          FillSolidRect( hDC, rc.left, rc.bottom, rc.right-rc.left, -1, GetSysColor( COLOR_3DSHADOW ) );
  2105.          FillSolidRect( hDC, rc.right, rc.top, -1, rc.bottom-rc.top, GetSysColor( COLOR_3DSHADOW ) );
  2106.          break;
  2108.       case tabRight:
  2109.          rc.right -= 2;         
  2110.          FillSolidRect( hDC, rc.left, rc.bottom, rc.right-rc.left, -1, GetSysColor( COLOR_3DSHADOW ) );
  2111.          FillSolidRect( hDC, rc.right, rc.top, -1, rcSel.top-rc.top, GetSysColor( COLOR_3DSHADOW ) );
  2112.          FillSolidRect( hDC, rc.right, rcSel.bottom, -1, rc.bottom-rcSel.bottom, GetSysColor( COLOR_3DSHADOW ) );
  2113.          break;
  2115.       case tabBottom:
  2116.          rc.bottom -= 2;         
  2117.          FillSolidRect( hDC, rc.left, rc.bottom, rcSel.left-rc.left, -1, GetSysColor( COLOR_3DSHADOW ) );
  2118.          FillSolidRect( hDC, rcSel.right, rc.bottom, rc.right-rcSel.right, -1, GetSysColor( COLOR_3DSHADOW ) );
  2119.          FillSolidRect( hDC, rc.right, rc.top, -1, rc.bottom-rc.top, GetSysColor( COLOR_3DSHADOW ) );
  2120.          break;
  2121.    }
  2123.    Draw3dRect( hDC, rc.left+1, rc.top+1, rc.right-rc.left-2, rc.bottom-rc.top-2, 
  2124.                GetSysColor( COLOR_3DFACE ), GetSysColor( COLOR_3DFACE ) );
  2126.    m_nOldItem = -1;
  2127.    int nState = 0;   
  2128.    POINT point;
  2129.    GetCursorPos( &point );
  2130.    ScreenToClient( m_hWnd, &point );
  2131.    int nCount = SendMessage( m_hWnd, TCM_GETITEMCOUNT, 0, 0L );
  2132.       
  2133.    for ( int i = 0; i < nCount; i++ )
  2134.    {     
  2135.       SendMessage( m_hWnd, TCM_GETITEMRECT, i, (LPARAM)&rc );
  2136.    
  2137.       nState = bsNormal;
  2138.       if ( nCurSel != i )
  2139.       {
  2140.          if ( PtInRect( &rc, point ) == TRUE )
  2141.          {
  2142.             nState |= bsHover;
  2143.             m_nOldItem = i;
  2144.          }         
  2145.          DrawTab( hDC, rc, i, nState );
  2146.       }
  2147.    }
  2148.       
  2149.    nState = bsChecked;
  2150.    if ( PtInRect( &rcSel, point ) == TRUE )
  2151.    {
  2152.       nState |= bsHover;
  2153.       m_nOldItem = nCurSel;
  2154.    }         
  2155.    DrawTab( hDC, rcSel, nCurSel, nState );
  2156.    
  2157.    if ( nCurSel != 0 )
  2158.       switch ( GetOrientation() )
  2159.       {
  2160.          case tabTop:
  2161.             FillSolidRect( hDC, rect.left, rect.top, 2, rcSel.bottom-rcSel.top+2, GetSysColor( COLOR_3DFACE ) );
  2162.             break;
  2163.          case tabBottom:
  2164.             FillSolidRect( hDC, rect.left, rect.bottom, 2, -rcSel.bottom+rcSel.top-2, GetSysColor( COLOR_3DFACE ) );
  2165.             break;
  2166.       }
  2168.    ReleaseDC( m_hWnd, hDC );
  2169. }
  2171. BOOL CCoolControlsManager::CCMTabControl::NeedRedraw( const POINT& point )
  2172. {   
  2173.    int nCount = SendMessage( m_hWnd, TCM_GETITEMCOUNT, 0, 0L );                  
  2175.    TCHITTESTINFO thti;
  2176.    thti.pt = point;
  2177.    ScreenToClient( m_hWnd, &thti.pt );
  2178.    int nItem = SendMessage( m_hWnd, TCM_HITTEST, 0, (LPARAM)&thti );
  2180.    if ( m_hWnd != m_hWndOld || ( m_hWnd == m_hWndOld && m_nOldItem != nItem ) )
  2181.       return TRUE;
  2182.    return FALSE;
  2183. }
  2185. LRESULT CCoolControlsManager::CCMTabControl::WindowProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
  2186. {
  2187.    switch ( uMsg )
  2188.    {  
  2189.       case WM_PAINT:
  2190.       case WM_NCPAINT:
  2191.          m_nOldItem = -1;   // Redraw the whole control unconditionally
  2192.          break;
  2193.    }
  2194.    return CCMControl::WindowProc( uMsg, wParam, lParam );
  2195. }
  2197. //////////////////////////////////////////////////////////////////////////////
  2198. // CCMIPAddress class
  2200. BOOL CCoolControlsManager::CCMIPAddress::IsFocused()
  2201. {
  2202.    HWND hWnd = GetTopWindow( m_hWnd );
  2203.    while ( hWnd )
  2204.    {
  2205.       if ( hWnd == GetFocus() )
  2206.          return TRUE;
  2207.       hWnd = GetNextWindow( hWnd, GW_HWNDNEXT );
  2208.    }
  2210.    return FALSE;
  2211. }
  2213. LRESULT CCoolControlsManager::CCMIPAddress::WindowProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
  2214. {
  2215.    switch ( uMsg )
  2216.    {      
  2217.       case WM_COMMAND:
  2218.          if ( HIWORD( wParam ) == EN_SETFOCUS || HIWORD( wParam ) == EN_KILLFOCUS )
  2219.             DrawBorder();
  2220.          break;
  2222.       default:
  2223.          return CCMControl::WindowProc( uMsg, wParam, lParam );
  2224.    }
  2226.    return CallWindowProc( m_oldWndProc, m_hWnd, uMsg, wParam, lParam );
  2227. }
  2229. //////////////////////////////////////////////////////////////////////////////
  2230. // CCMDialog class
  2232. LRESULT CCoolControlsManager::CCMDialog::WindowProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
  2233. {
  2234.    switch ( uMsg )
  2235.    {      
  2236.       case WM_PARENTNOTIFY:         
  2237.          if ( LOWORD( wParam ) == WM_CREATE )   // Add dynamically created controls to the map
  2238.             g_ctrlManager.AddControl( (HWND)lParam );
  2239.          break;
  2241.       case WM_NCDESTROY:
  2242.          // Unsubclass window and remove it from the map
  2243.          CallWindowProc( m_oldWndProc, m_hWnd, uMsg, wParam, lParam );
  2244.          g_ctrlManager.RemoveDialog( m_hWnd );
  2245.          return 0;
  2246.    }
  2248.    return CallWindowProc( m_oldWndProc, m_hWnd, uMsg, wParam, lParam );
  2249. }
  2251. ///////////////////////////////////////////////////////////////////////////////////
  2252. // Helper functions for drawing 3D frames (borrowed from CDC class)
  2254. void CCoolControlsManager::CCMControl::FillSolidRect( HDC hDC, int x, int y, int cx, int cy, COLORREF clr )
  2255. {
  2256.    SetBkColor( hDC, clr );
  2257.    RECT rect;
  2258.    SetRect( &rect, x, y, x + cx, y + cy );
  2259.    ExtTextOut( hDC, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL );
  2260. }
  2262. void CCoolControlsManager::CCMControl::FillSolidRect( HDC hDC, const RECT& rect, COLORREF clr )
  2263. {
  2264.    SetBkColor( hDC, clr );
  2265.    ExtTextOut( hDC, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL );
  2266. }
  2268. void CCoolControlsManager::CCMControl::Draw3dRect( HDC hDC, int x, int y, int cx, int cy,
  2269.                                                   COLORREF clrTopLeft, COLORREF clrBottomRight )
  2270. {
  2271.    FillSolidRect( hDC, x, y, cx - 1, 1, clrTopLeft );
  2272.    FillSolidRect( hDC, x, y, 1, cy - 1, clrTopLeft );
  2273.    FillSolidRect( hDC, x + cx, y, -1, cy, clrBottomRight );
  2274.    FillSolidRect( hDC, x, y + cy, cx, -1, clrBottomRight );
  2275. }
  2277. void CCoolControlsManager::CCMControl::Draw3dRect( HDC hDC, const RECT& rect,
  2278.                                                   COLORREF clrTopLeft, COLORREF clrBottomRight )
  2279. {
  2280.    Draw3dRect( hDC, rect.left, rect.top, rect.right - rect.left,
  2281.                     rect.bottom - rect.top, clrTopLeft, clrBottomRight );
  2282. }
  2284. void CCoolControlsManager::CCMControl::Draw3dBorder( HDC hDC, const RECT& rc, 
  2285.                                                     int nColor1, int nColor2,
  2286.                                                     int nColor3, int nColor4 )
  2287. {
  2288.    Draw3dRect( hDC, rc, GetSysColor( nColor1 ), GetSysColor( nColor2 ) );
  2290.    Draw3dRect( hDC, rc.left + 1, rc.top + 1, rc.right - rc.left - 2, rc.bottom - rc.top - 2, 
  2291.                         GetSysColor( nColor3 ), GetSysColor( nColor4 ) );
  2292. }
  2294. void CCoolControlsManager::CCMControl::Draw3dBorder( HDC hDC, const RECT& rc, 
  2295.                                                     int nColor1, int nColor2,
  2296.                                                     int nColor3, int nColor4,
  2297.                                                     int nColor5, int nColor6 )
  2298. {
  2299.    Draw3dRect( hDC, rc, GetSysColor( nColor1 ), GetSysColor( nColor2 ) );
  2301.    Draw3dRect( hDC, rc.left + 1, rc.top + 1, rc.right - rc.left - 2, rc.bottom - rc.top - 2, 
  2302.                         GetSysColor( nColor3 ), GetSysColor( nColor4 ) );
  2303.    Draw3dRect( hDC, rc.left + 2, rc.top + 2, rc.right - rc.left - 4, rc.bottom - rc.top - 4, 
  2304.                   GetSysColor( nColor5 ), GetSysColor( nColor6 ) );
  2305. }