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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
VisualFx.cpp
资源名称：(vc).rar　[点击查看]
上传用户：wpp2016
上传日期：2010-02-01
资源大小：1250k
文件大小：63k
源码类别：

Telnet服务器

开发平台：

Visual C++

VisualFx.cpp：源码内容
  1. /*#############################################################################
  2. # VISUALFX.CPP
  3. #
  4. # SCA Software International S.A.
  5. # http://www.scasoftware.com
  6. # scaadmin@scasoftware.com
  7. #
  8. # Copyright (c) 1999 SCA Software International S.A.
  9. #
  10. # Date: 03.01.2000
  11. # Author: Zoran M.Todorovic
  12. #
  13. # This software is provided "AS IS", without a warranty of any kind.
  14. # You are free to use/modify this code but leave this header intact.
  15. #
  16. #############################################################################*/
  18. #include "stdafx.h"
  19. #include <afxpriv.h>        // Needed for WM_SIZEPARENT
  21. #include "VisualFx.h"
  23. #ifdef _DEBUG
  24. #undef THIS_FILE
  25. static char THIS_FILE[] = __FILE__;
  26. #endif
  28. #ifdef _DEBUG
  29. #define new DEBUG_NEW
  30. #endif
  32. //=============================================================================
  33. // class TTabItem
  34. //
  35. //=============================================================================
  37. // Create a tab item 
  38. TTabItem::TTabItem(CWnd *pParent, LPCTSTR szLabel)
  39. {
  40.   m_pWnd = NULL;
  41.   m_nMinX = m_nMaxX = 0;
  42.   m_bVisible = TRUE;
  43.   m_bEnabled = TRUE;
  44.   m_bWndEnabled = TRUE;
  45.   RECT rect;
  46.   ::ZeroMemory(&rect,sizeof(RECT));
  47.   m_pCaption = new CStatic;
  48.   ASSERT(m_pCaption);
  49.   m_pCaption->Create(szLabel, WS_CHILD|SS_CENTER|WS_VISIBLE,rect,pParent);
  50. }
  52. TTabItem::TTabItem(const TTabItem& obj)
  53. {
  54.   *this = obj;
  55. }
  57. TTabItem& TTabItem::operator=(const TTabItem& obj)
  58. {
  59.   m_pWnd = obj.m_pWnd;
  60.   m_pCaption = obj.m_pCaption;
  61.   m_bWndEnabled = obj.m_bWndEnabled;
  62.   m_bEnabled = obj.m_bEnabled;
  63.   m_bVisible = obj.m_bVisible;
  64.   m_nMinX = obj.m_nMinX;
  65.   m_nMaxX = obj.m_nMaxX;
  66.   return *this;
  67. }
  69. TTabItem::~TTabItem()
  70. {
  71.   // This is done in TVisualFramework::Destroy()
  72.   //if (m_pWnd->IsKindOf(RUNTIME_CLASS(CSplitterWnd)))
  73.   //  delete m_pWnd;
  74.   ASSERT(m_pCaption);
  75.   delete m_pCaption;
  76. }
  78. // Set rectangle for tab caption
  79. void TTabItem::SetRect(CRect& rect)
  80. {
  81.   ASSERT(m_pCaption);
  82.   m_pCaption->MoveWindow(&rect);
  83. }
  85. // Set font for tab caption
  86. void TTabItem::SetFont(CFont *pFont)
  87. {
  88.   ASSERT(m_pCaption);
  89.   ASSERT(pFont);
  90.   m_pCaption->SetFont(pFont,FALSE);
  91. }
  93. // Get tab caption text
  94. CString TTabItem::GetText(void)
  95. {
  96.   ASSERT(m_pCaption);
  97.   CString str;
  98.   m_pCaption->GetWindowText(str);
  99.   return str;
  100. }
  102. int TTabItem::GetLength(void)
  103. {
  104.   return m_nMaxX - m_nMinX;
  105. }
  107. // Set tab caption text
  108. void TTabItem::SetText(LPCTSTR szLabel)
  109. {
  110.   ASSERT(m_pCaption);
  111.   ASSERT(szLabel);
  112.   m_pCaption->SetWindowText(szLabel);
  113. }
  115. // Enable/disable a window
  116. void TTabItem::Enable(BOOL bEnable)
  117. {
  118.   m_bWndEnabled = bEnable;
  119. }
  121. // Enable/disable tab caption
  122. void TTabItem::EnableTab(BOOL bEnable)
  123. {
  124.   ASSERT(m_pCaption);
  125.   m_bEnabled = bEnable;
  126.   m_pCaption->EnableWindow(m_bEnabled);
  127. }
  129. // Show/hide tab caption
  130. void TTabItem::ShowTab(BOOL bShow)
  131. {
  132.   ASSERT(m_pCaption);
  133.   m_bVisible = bShow;
  134.   m_pCaption->ShowWindow(bShow ? SW_SHOW : SW_HIDE);
  135. }
  137. CWnd *TTabItem::GetSafeWnd(void)
  138. {
  139.   return (m_pWnd && ::IsWindow(m_pWnd->m_hWnd)) ? m_pWnd : NULL;
  140. }
  142. //=============================================================================
  143. // class TTabWnd
  144. //
  145. //=============================================================================
  147. #define TABWND_DEFAULT_ID 0x2578
  148. #define TABWND_HEIGHT     30    // Height of the gray border between the toolbar 
  149.                                 // and the client area
  150. #define TAB_HEIGHT        20    // Height on the normal tab
  151. #define TABSEL_HEIGHT     20    // Height of the selected tab
  152. #define TAB_SPACE         6     // Add to tab caption text width
  153. #define TAB_DEPL          4     // Distance between the tabs and the client area
  154. #define TAB_MAXLEN        200
  156. IMPLEMENT_DYNCREATE(TTabWnd,CWnd)
  158. BEGIN_MESSAGE_MAP(TTabWnd, CWnd)
  159.   //{{AFX_MSG_MAP(TTabWnd)
  160.   ON_MESSAGE(WM_SIZEPARENT, OnSizeParent)
  161.   ON_WM_ERASEBKGND()
  162.   ON_WM_PAINT()
  163.   ON_WM_LBUTTONUP()
  164.   ON_WM_DESTROY()
  165.   ON_WM_SIZE()
  166. ON_WM_CREATE()
  167. //}}AFX_MSG_MAP
  168. END_MESSAGE_MAP()
  170. TTabWnd::TTabWnd()
  171. {
  172.   m_nSelectedTab = 0;
  173.   m_bLockFlag = FALSE;
  174.   m_nTabPos = TP_BOTTOM;
  175.   // cache most used resources
  176.   m_BrushBlack.CreateSolidBrush(RGB(0,0,0));
  177.   m_BrushLGray.CreateSolidBrush(::GetSysColor(COLOR_BTNFACE));
  178.   m_PenBlack.CreatePen(PS_SOLID, 1, (COLORREF)0);
  179.   m_PenLGray.CreatePen(PS_SOLID, 1, ::GetSysColor(COLOR_BTNFACE));
  180.   m_PenWhite.CreatePen(PS_SOLID, 1, ::GetSysColor(COLOR_BTNHIGHLIGHT));
  181.   m_PenWhite2.CreatePen(PS_SOLID, 2, ::GetSysColor(COLOR_BTNHIGHLIGHT));
  182.   m_PenDGray.CreatePen(PS_SOLID, 1, ::GetSysColor(COLOR_BTNSHADOW));
  183.   m_PenDGray2.CreatePen(PS_SOLID, 2, ::GetSysColor(COLOR_BTNSHADOW));
  184. }
  186. TTabWnd::~TTabWnd()
  187. {
  188. }
  190. // Find a tab within this tab window
  191. TTabItem *TTabWnd::findTabItem(int nIndex)
  192. {
  193.   int nNdx = 0;
  194.   TTabItemList::iterator iterator;
  195.   for (iterator = m_TabList.begin(); iterator != m_TabList.end(); iterator++) {
  196.     if (nNdx == nIndex)
  197.       return (*iterator);
  198.     nNdx ++;
  199.   }
  200.   return NULL;
  201. }
  203. // Create a tab window
  204. BOOL TTabWnd::Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, 
  205.                      DWORD dwStyle, const RECT& prect, CWnd* pParentWnd, 
  206.                      UINT nID, CCreateContext *pContext)
  207. {
  208.   ASSERT(pParentWnd);
  210.   dwStyle &= ~WS_BORDER;
  211.   CRect rect(prect);
  212.   if (!CWnd::Create(NULL, lpszWindowName, dwStyle, rect, pParentWnd, nID, pContext))
  213.     return FALSE;
  214.   if (pParentWnd->IsKindOf(RUNTIME_CLASS(CFrameWnd))) {
  215.     ((CFrameWnd*)pParentWnd)->ModifyStyleEx(WS_EX_CLIENTEDGE,0,SWP_FRAMECHANGED);
  216.     ((CFrameWnd*)pParentWnd)->RecalcLayout();
  217.   }
  218.   ResizeTab();
  219.   return TRUE;
  220. }
  222. int TTabWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  223. {
  224. if (CWnd::OnCreate(lpCreateStruct) == -1)
  225. return -1;
  227.   createFont();
  228. return 0;
  229. }
  231. void TTabWnd::OnDestroy() 
  232. {
  233.   CWnd::OnDestroy();
  234.   TTabItemList::iterator iterator;
  235.   for (iterator = m_TabList.begin(); iterator != m_TabList.end(); iterator ++) {
  236.     delete (*iterator);
  237.   }
  238.   m_TabList.clear();
  239.   // This is done in TVisualFramework
  240.   //if (GetParent()->IsKindOf(RUNTIME_CLASS(CSplitterWnd)))
  241.   //  delete this;
  242. }
  244. // Virtual function to check whether switch to new tab can be done
  245. BOOL TTabWnd::CanSetActivePane(CWnd *pOldPane, CWnd *pNewPane)
  246. {
  247.   return TRUE;
  248. }
  250. // Virtual function (after the switch is done)
  251. void TTabWnd::OnSetActivePane(CWnd *pOldPane, CWnd *pNewPane)
  252. {
  253. }
  255. // Create fonts for tab labels
  256. void TTabWnd::createFont()
  257. {
  258. NONCLIENTMETRICS metrics;
  259. metrics.cbSize = sizeof(metrics);
  260.   ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &metrics, 0);
  262.   CWindowDC wdc(NULL);
  263.   int nLPixY = GetDeviceCaps(wdc.m_hDC, LOGPIXELSY);
  265. m_Font.CreateFontIndirect(&metrics.lfStatusFont);
  266. }
  268. // Add a tab to this window
  269. TTabItem *TTabWnd::addTab(CWnd *pWnd, LPCTSTR szLabel)
  270. {
  271.   ASSERT(pWnd);
  272.   ASSERT(szLabel);
  274.   TTabItem *pItem = new TTabItem(this,szLabel);
  275.   pItem->m_pWnd = pWnd;
  276.   m_TabList.insert(m_TabList.end(), pItem);
  277.   return pItem;
  278. }
  280. int TTabWnd::GetTabLength()
  281. {
  282.   int nLength = 0;
  283.   TTabItemList::iterator iterator;
  284.   for (iterator = m_TabList.begin(); iterator != m_TabList.end(); iterator++) {
  285.     nLength += (*iterator)->GetLength();
  286.   }
  287.   return nLength;
  288. }
  290. // Get index of currently selected tab
  291. int TTabWnd::GetTabIndex(void)
  292. {
  293.   return m_nSelectedTab;
  294. }
  296. // Get number of tabs
  297. int TTabWnd::GetTabCount(void)
  298. {
  299.   return m_TabList.size();
  300. }
  302. // Get index of the tab associated with specified window
  303. int TTabWnd::GetTabIndex(CWnd *pWnd)
  304. {
  305.   ASSERT(pWnd);
  307.   int nIndex = 0;
  308.   TTabItem *pItem;
  309.   TTabItemList::iterator iterator;
  310.   for (iterator = m_TabList.begin(); iterator != m_TabList.end(); iterator++) {
  311.     pItem = *iterator;
  312.     if (pItem->m_pWnd == pWnd)
  313.       return nIndex;
  314.     nIndex ++;
  315.   }
  316.   return -1;
  317. }
  319. // Get pointer to window associated with the specified tab index
  320. CWnd *TTabWnd::GetTabWnd(int index)
  321. {
  322.   TTabItem *pItem = findTabItem(index);
  323.   ASSERT(pItem);
  324.   return ::IsWindow(pItem->m_pWnd->m_hWnd) ? pItem->m_pWnd : NULL;
  325. }
  327. // Get tab caption text of the specified tab
  328. CString TTabWnd::GetTabLabel(int nIndex)
  329. {
  330.   TTabItem *pItem = findTabItem(nIndex);
  331.   ASSERT(pItem);
  332.   return pItem->GetText();
  333. }
  335. // Set text of tab caption
  336. void TTabWnd::SetTabLabel(int nIndex, LPCTSTR szLabel)
  337. {
  338.   ASSERT(szLabel);
  339.   TTabItem *pItem = findTabItem(nIndex);
  340.   ASSERT(pItem);
  341.   pItem->SetText(szLabel);
  342.   invalidateTabArea();
  343. }
  345. // Enable/disable a view
  346. void TTabWnd::Enable(int nIndex, BOOL bEnable)
  347. {
  348.   TTabItem *pItem = findTabItem(nIndex);
  349.   ASSERT(pItem);
  350.   pItem->Enable(bEnable);
  351.   //pItem->m_pWnd->EnableWindow(bEnable);
  352. }
  354. // Cannot disable currently selected tab
  355. void TTabWnd::EnableTab(int nIndex, BOOL bEnable)
  356. {
  357.   ASSERT(nIndex != m_nSelectedTab);
  358.   TTabItem *pItem = findTabItem(nIndex);
  359.   ASSERT(pItem);
  360.   pItem->EnableTab(bEnable);
  361.   invalidateTabArea();
  362. }
  364. // Cannot make invisible currently selected tab
  365. void TTabWnd::ShowTab(int nIndex, BOOL bShow)
  366. {
  367.   ASSERT(nIndex != m_nSelectedTab);
  368.   TTabItem *pItem = findTabItem(nIndex);
  369.   ASSERT(pItem);
  370.   pItem->ShowTab(bShow);
  371.   invalidateTabArea();
  372. }
  374. // Is tab enabled
  375. BOOL TTabWnd::IsTabEnabled(int nIndex)
  376. {
  377.   TTabItem *pItem = findTabItem(nIndex);
  378.   ASSERT(pItem);
  379.   return pItem->m_bEnabled;
  380. }
  382. // Is tab visible
  383. BOOL TTabWnd::IsTabVisible(int nIndex)
  384. {
  385.   TTabItem *pItem = findTabItem(nIndex);
  386.   ASSERT(pItem);
  387.   return pItem->m_bVisible;
  388. }
  390. // Set font
  391. void TTabWnd::SetFont(CFont *pFont)
  392. {
  393.   ASSERT(pFont);
  394.   CWnd::SetFont(pFont);
  395.   m_Font.DeleteObject();
  396.   LOGFONT lf;
  397.   pFont->GetLogFont(&lf);
  398.   m_Font.CreateFontIndirect(&lf);
  399.   invalidateTabArea();
  400. }
  402. // Set position of tabs (top or bottom)
  403. void TTabWnd::SetTabPos(TTabPos nTabPos)
  404. {
  405.   m_nTabPos = nTabPos;
  406. }
  408. // Invalidate rectangle to redraw tabs
  409. void TTabWnd::invalidateTabArea(void)
  410. {
  411.   CRect rect;
  412.   switch (m_nTabPos) {
  413.   case TP_TOP: 
  414.     InvalidateRect(&CRect(0, 0, 32000, TABWND_HEIGHT)); 
  415.     break;
  416.   case TP_BOTTOM:
  417.     GetClientRect(&rect);
  418.     InvalidateRect(&CRect(CPoint(0,rect.Height()-TABWND_HEIGHT), 
  419.                           CSize(32000,TABWND_HEIGHT)));
  420.     break;
  421.   };
  422. }
  424. // Draws a selected tab and returns its height
  425. int TTabWnd::drawSelTabTop(CDC *pDC, int x, CRect& client, TTabItem *pItem)
  426. {
  427.   ASSERT(pItem);
  428.   ASSERT(pDC);
  430.   CString str = pItem->GetText();
  431.   CSize textSize = pDC->GetTextExtent(str);
  432.   textSize.cx += 10;
  433.   if (textSize.cx > TAB_MAXLEN)
  434.     textSize.cx = TAB_MAXLEN;
  435.   int y = TABWND_HEIGHT - TABSEL_HEIGHT - TAB_DEPL;
  437.   // black border, no bottom line
  438.   pDC->SelectObject(&m_PenBlack);
  439.   pDC->MoveTo(x,y+TABSEL_HEIGHT-1);
  440.   pDC->LineTo(x,y);
  441.   pDC->LineTo(x+textSize.cx+TAB_SPACE-1, y);
  442.   pDC->LineTo(x+textSize.cx+TAB_SPACE-1, y+TABSEL_HEIGHT);
  444.   // left and upper border in white, double line
  445.   pDC->SelectObject(&m_PenWhite2);
  446.   pDC->MoveTo(x+2,y+TABSEL_HEIGHT-1);
  447.   pDC->LineTo(x+2,y+2);
  448.   pDC->LineTo(x+textSize.cx+TAB_SPACE-4, y+2);
  450.   // right border, dark gray, double line
  451.   pDC->SelectObject(&m_PenDGray2);
  452.   pDC->MoveTo(x+textSize.cx+TAB_SPACE-2, y+2);
  453.   pDC->LineTo(x+textSize.cx+TAB_SPACE-2, y+TABSEL_HEIGHT-1);
  455.   // clean up
  456.   pDC->SelectObject(&m_PenLGray);
  457.   pDC->MoveTo(x-1, y+TABSEL_HEIGHT);
  458.   pDC->LineTo(x+textSize.cx+TAB_SPACE, y+TABSEL_HEIGHT);
  459.   pDC->MoveTo(x-1, y+TABSEL_HEIGHT+1);
  460.   pDC->LineTo(x+textSize.cx+TAB_SPACE, y+TABSEL_HEIGHT+1);
  462.   // a black line to far left and right
  463.   pDC->SelectObject(&m_PenBlack);
  464.   pDC->MoveTo(0, y+TABSEL_HEIGHT-1);
  465.   pDC->LineTo(x, y+TABSEL_HEIGHT-1);
  466.   pDC->MoveTo(x+textSize.cx+TAB_SPACE+1, y+TABSEL_HEIGHT-1);
  467.   pDC->LineTo(client.right, y+TABSEL_HEIGHT-1);
  469.   // and a white double line
  470.   pDC->SelectObject(&m_PenWhite2);
  471.   if (x!=0) {
  472.     pDC->MoveTo(0, y+TABSEL_HEIGHT+1);
  473.     pDC->LineTo(x, y+TABSEL_HEIGHT+1);
  474.   }
  475.   pDC->MoveTo(x+textSize.cx+TAB_SPACE, y+TABSEL_HEIGHT+1);
  476.   pDC->LineTo(client.right, y+TABSEL_HEIGHT+1);
  478.   // gray inside
  479.   pDC->FillSolidRect(x+3, y+3,textSize.cx+TAB_SPACE-6, TABSEL_HEIGHT, 
  480.                   ::GetSysColor(COLOR_BTNFACE));
  482.   CRect rect(CPoint(x+TAB_SPACE/2, y+(TAB_HEIGHT-textSize.cy)/2+1), textSize);
  483.   pItem->SetFont(&m_Font);
  484.   pItem->SetRect(rect);
  485.   
  486.   return textSize.cx+TAB_SPACE;
  487. }
  489. // Draw a selected tab at the bottom
  490. int TTabWnd::drawSelTabBottom(CDC *pDC, int x, CRect& client, TTabItem *pItem)
  491. {
  492.   ASSERT(pItem);
  493.   ASSERT(pDC);
  495.   CString str = pItem->GetText();
  496.   CSize textSize = pDC->GetTextExtent(str);
  497.   textSize.cx += 10;
  498.   if (textSize.cx > TAB_MAXLEN)
  499.     textSize.cx = TAB_MAXLEN;
  501.   int y = client.Height() - TABWND_HEIGHT + TAB_DEPL;
  503.   // black border, no bottom line
  504.   pDC->SelectObject(&m_PenBlack);
  505.   pDC->MoveTo(x,y);
  506.   pDC->LineTo(x,y+TABSEL_HEIGHT);
  507.   pDC->LineTo(x+textSize.cx+TAB_SPACE-1, y+TABSEL_HEIGHT);
  508.   pDC->LineTo(x+textSize.cx+TAB_SPACE-1, y);
  510.   // left border in white, double line
  511.   pDC->SelectObject(&m_PenWhite2);
  512.   pDC->MoveTo(x+2,y);
  513.   pDC->LineTo(x+2,y+TABSEL_HEIGHT-1);
  515.   // right and bottom border, dark gray, double line
  516.   pDC->SelectObject(&m_PenDGray2);
  517.   pDC->LineTo(x+textSize.cx+TAB_SPACE-4, y+TABSEL_HEIGHT-1);
  518.   pDC->MoveTo(x+textSize.cx+TAB_SPACE-2, y);
  519.   pDC->LineTo(x+textSize.cx+TAB_SPACE-2, y+TABSEL_HEIGHT-1);
  521.   // a black line to far left and right
  522.   pDC->SelectObject(&m_PenBlack);
  523.   pDC->MoveTo(0, y);
  524.   pDC->LineTo(x, y);
  525.   pDC->MoveTo(x+textSize.cx+TAB_SPACE, y);
  526.   pDC->LineTo(client.right, y);
  528.   // and a gray line to far left and right
  529.   pDC->SelectObject(&m_PenDGray);
  530.   if (x != 0) {
  531.     pDC->MoveTo(0, y-1);
  532.     pDC->LineTo(x, y-1);
  533.   }
  534.   pDC->MoveTo(x+textSize.cx+TAB_SPACE-2, y-1);
  535.   pDC->LineTo(client.right, y-1);
  537.   // gray inside
  538.   pDC->FillSolidRect(x+3,y,textSize.cx+TAB_SPACE-6, TABSEL_HEIGHT-2, 
  539.                     ::GetSysColor(COLOR_BTNFACE));
  541.   CRect rect(CPoint(x+TAB_SPACE/2, y+(TAB_HEIGHT-textSize.cy)/2), textSize);
  542.   pItem->SetFont(&m_Font);
  543.   pItem->SetRect(rect);
  544.   
  545.   return textSize.cx+TAB_SPACE;
  546. }
  548. // Draws an unselected tab and returs its height
  549. int TTabWnd::drawTabTop(CDC *pDC, int x, CRect& client, TTabItem *pItem)
  550. {
  551.   ASSERT(pItem);
  552.   ASSERT(pDC);
  554.   CString str = pItem->GetText();
  555.   CSize textSize = pDC->GetTextExtent(str);
  556.   textSize.cx += 10;
  557.   if (textSize.cx > TAB_MAXLEN)
  558.     textSize.cx = TAB_MAXLEN;
  560.   int y = TABWND_HEIGHT-TAB_HEIGHT-TAB_DEPL;
  561.   
  562.   // black border
  563.   pDC->FrameRect(&CRect(CPoint(x,y), CSize(textSize.cx+TAB_SPACE, TAB_HEIGHT)), 
  564.                   &m_BrushBlack);
  566.   pDC->SelectObject(&m_PenWhite);
  567.   pDC->MoveTo(x+1, y+1);
  568.   pDC->LineTo(x+1, y+TAB_HEIGHT-1);
  569.   pDC->MoveTo(x+1, y+1);
  570.   pDC->LineTo(x+textSize.cx+TAB_SPACE-2, y+1);
  572.   pDC->SelectObject(&m_PenDGray);
  573.   pDC->MoveTo(x+textSize.cx+TAB_SPACE-2, y+1);
  574.   pDC->LineTo(x+textSize.cx+TAB_SPACE-2, y+TAB_HEIGHT-1);
  576.   pDC->FillRect(&CRect(CPoint(x+2,y+2), CSize(textSize.cx+TAB_SPACE-4, TAB_HEIGHT-3)), 
  577.                 &m_BrushLGray);
  579.   // clean up
  580.   int dy = TABSEL_HEIGHT-TAB_HEIGHT;
  581.   pDC->FillSolidRect(x, y-dy, textSize.cx+TAB_SPACE, dy, GetSysColor(COLOR_BTNFACE));
  583.   CRect rect(CPoint(x+TAB_SPACE/2, y+(TAB_HEIGHT-textSize.cy)/2+1), textSize);
  584.   pItem->SetFont(&m_Font);
  585.   pItem->SetRect(rect);
  586.   
  587.   return textSize.cx+TAB_SPACE;
  588. }
  590. // Draw an unselected tab at the bottom
  591. int TTabWnd::drawTabBottom(CDC *pDC, int x, CRect& client, TTabItem *pItem)
  592. {
  593.   ASSERT(pItem);
  594.   ASSERT(pDC);
  596.   CString str = pItem->GetText();
  597.   CSize textSize = pDC->GetTextExtent(str);
  598.   textSize.cx += 10;
  599.   if (textSize.cx > TAB_MAXLEN)
  600.     textSize.cx = TAB_MAXLEN;
  602.   int y = client.Height() - TABWND_HEIGHT + TAB_DEPL;
  604.   // black border
  605.   pDC->FrameRect(&CRect(CPoint(x,y), CSize(textSize.cx+TAB_SPACE, TAB_HEIGHT+1)), 
  606.                   &m_BrushBlack);
  608.   // Gray border bottom and right side
  609.   pDC->SelectObject(&m_PenDGray);
  610.   pDC->MoveTo(x+1, y+TAB_HEIGHT-1);
  611.   pDC->LineTo(x+textSize.cx+TAB_SPACE-2, y+TAB_HEIGHT-1);
  612.   pDC->MoveTo(x+textSize.cx+TAB_SPACE-2, y);
  613.   pDC->LineTo(x+textSize.cx+TAB_SPACE-2, y+TAB_HEIGHT-1);
  615.   pDC->FillRect(&CRect(CPoint(x+1,y+1), CSize(textSize.cx+TAB_SPACE-4, TAB_HEIGHT-3)), 
  616.                 &m_BrushLGray);
  618.   CRect rect(CPoint(x+TAB_SPACE/2, y+(TAB_HEIGHT-textSize.cy)/2), textSize);
  619.   pItem->SetFont(&m_Font);
  620.   pItem->SetRect(rect);
  621.   
  622.   return textSize.cx+TAB_SPACE;
  623. }
  625. // Draw edge arround client area
  626. void TTabWnd::drawClient(CDC *pDc, CRect& rect)
  627. {
  628.   ASSERT(pDc);
  630.   CWnd *pParent = GetParent();
  631.   ASSERT(pParent);
  632.   switch (m_nTabPos) {
  633.   case TP_TOP:
  634.     if (pParent->IsKindOf(RUNTIME_CLASS(CFrameWnd))) {
  635.       pDc->DrawEdge(&rect, EDGE_ETCHED, BF_TOP);
  636.     }
  637.     pDc->Draw3dRect(0,TABWND_HEIGHT, rect.right, rect.bottom-TABWND_HEIGHT,
  638.                    ::GetSysColor(COLOR_BTNSHADOW), ::GetSysColor(COLOR_BTNHIGHLIGHT));
  639.     pDc->Draw3dRect(1,TABWND_HEIGHT+1, rect.right-2, rect.bottom-TABWND_HEIGHT-2,
  640.                     0, ::GetSysColor(COLOR_3DLIGHT));
  641.     break;
  642.   case TP_BOTTOM:
  643.     if (pParent->IsKindOf(RUNTIME_CLASS(CFrameWnd))) {
  644.       pDc->DrawEdge(&rect, EDGE_ETCHED, BF_BOTTOM);
  645.     }
  646.     pDc->Draw3dRect(0,0, rect.right, rect.bottom-TABWND_HEIGHT+1,
  647.                    ::GetSysColor(COLOR_BTNSHADOW), ::GetSysColor(COLOR_BTNHIGHLIGHT));
  648.     pDc->Draw3dRect(1,1, rect.right-2, rect.bottom-TABWND_HEIGHT-1,
  649.                     0, ::GetSysColor(COLOR_3DLIGHT));
  650.     break;
  651.   }
  652. }
  654. void TTabWnd::OnPaint()
  655. {
  656.   CPaintDC dc(this); // device context for painting
  657.   CRect client;
  659.   GetClientRect(&client);
  660.   drawClient(&dc, client);
  662.   int x = 0, nIndex = 0;
  663.   TTabItemList::iterator iterator;
  664.   for (iterator = m_TabList.begin(); iterator != m_TabList.end(); iterator++) {
  665.     TTabItem *pItem = *iterator;
  666.     ASSERT(pItem != NULL);
  667.     if (pItem->m_bVisible) {
  668.       pItem->m_nMinX = x;
  669.       if (nIndex != m_nSelectedTab) {
  670.         switch (m_nTabPos) {
  671.         case TP_TOP: x += drawTabTop(&dc, x, client, pItem); break;
  672.         case TP_BOTTOM: x += drawTabBottom(&dc, x, client, pItem); break;
  673.         }
  674.       } else {
  675.         switch (m_nTabPos) {
  676.         case TP_TOP: x += drawSelTabTop(&dc, x, client, pItem); break;
  677.         case TP_BOTTOM: x += drawSelTabBottom(&dc, x, client, pItem); break;
  678.         }
  679.       }
  680.     }
  681.     pItem->m_nMaxX = x;
  682.     nIndex ++;
  683.   }
  684. }
  686. // Returns tab index that holds specified point
  687. int TTabWnd::HitTest(CPoint& point)
  688. {
  689.   return HitTest(point.x,point.y);
  690. }
  692. // Returns tab index that holds specified point
  693. int TTabWnd::HitTest(int x, int y)
  694. {
  695.   int notsel_y_min, sel_y_min, y_max;
  696.   CRect rect;
  698.   GetClientRect(&rect);
  699.   switch (m_nTabPos) {
  700.   case TP_TOP:
  701.     notsel_y_min = TABWND_HEIGHT - TAB_HEIGHT - TAB_DEPL;
  702.     sel_y_min = TABWND_HEIGHT - TABSEL_HEIGHT - TAB_DEPL;
  703.     y_max = TABWND_HEIGHT - TAB_DEPL;
  704.     break;
  705.   case TP_BOTTOM:
  706.     notsel_y_min = rect.Height() - TABWND_HEIGHT + TAB_DEPL;
  707.     sel_y_min = rect.Height() - TABWND_HEIGHT + TAB_DEPL;
  708.     y_max = rect.Height() - TABWND_HEIGHT + TAB_DEPL + TAB_HEIGHT;
  709.     break;
  710.   };
  712.   int nIndex = 0;
  713.   TTabItemList::iterator iterator;
  714.   for (iterator = m_TabList.begin(); iterator != m_TabList.end(); iterator++) {
  715.     TTabItem *pItem = (*iterator);
  716.     if (pItem->m_bEnabled && pItem->m_bVisible) {
  717.       if (nIndex != m_nSelectedTab && (y < notsel_y_min || y > y_max)) 
  718.         continue;
  719.       if (nIndex == m_nSelectedTab && (y < sel_y_min || y > y_max)) 
  720.         continue;
  721.       if (x >= pItem->m_nMinX && x <= pItem->m_nMaxX)
  722.         return nIndex;
  723.     }
  724.     nIndex++;
  725.   }
  726.   return -1;
  727. }
  729. // Switch focus to specified tab index
  730. BOOL TTabWnd::SetActivePane(int nIndex, BOOL bActivate)
  731. {
  732.   if (nIndex == -1)
  733.     return FALSE;
  734.   if (nIndex == m_nSelectedTab)
  735.     return TRUE;
  737.   TTabItem *pNewPane = findTabItem(nIndex);
  738.   if (!pNewPane->m_bEnabled || !pNewPane->m_bVisible)
  739.     return FALSE;
  740.   TTabItem *pOldPane = NULL;
  741.   if (m_nSelectedTab != -1)
  742.     pOldPane = findTabItem(m_nSelectedTab);
  743.   if (CanSetActivePane(pOldPane ? pOldPane->m_pWnd : NULL, pNewPane->m_pWnd)) {
  744.     // Deactivate old pane
  745.     if (m_nSelectedTab != -1) {
  746.       pOldPane->m_pWnd->EnableWindow(FALSE);
  747.       pOldPane->m_pWnd->ShowWindow(SW_HIDE);
  748.     }
  749.     // Activate new pane
  750.     pNewPane->m_pWnd->EnableWindow(pNewPane->m_bWndEnabled ? TRUE : FALSE);
  751.     pNewPane->m_pWnd->ShowWindow(SW_SHOW);
  752.     pNewPane->m_pWnd->SetFocus();
  753.     // Save index of new pane
  754.     m_nSelectedTab = nIndex;
  755.     // Invalidate tab
  756.     invalidateTabArea();
  757.     // Inform derived class
  758.     OnSetActivePane(pOldPane ? pOldPane->m_pWnd : NULL, pNewPane->m_pWnd);
  759.     // Update frame window
  760.     if (bActivate) {
  761.       CWnd *pParent = GetParent();
  762.       while (pParent && !pParent->IsKindOf(RUNTIME_CLASS(CFrameWnd)))
  763.         pParent = pParent->GetParent();
  764.       ASSERT(pParent != NULL);
  765.       updateFrame((CFrameWnd*)pParent, pNewPane->m_pWnd);
  766.     }
  767.     return TRUE;
  768.   }
  769.   return FALSE;
  770. }
  772. // Update frame window active view based on newly selected tab item
  773. BOOL TTabWnd::updateFrame(CFrameWnd *pFrame, CWnd *pWnd)
  774. {
  775.   ASSERT(pFrame);
  776.   ASSERT(pWnd);
  778.   if (pWnd->IsKindOf(RUNTIME_CLASS(CView))) {
  779.     // New tab item is a view
  780.     pFrame->SetActiveView((CView*)pWnd);
  781.     return TRUE;
  782.   } else if (pWnd->IsKindOf(RUNTIME_CLASS(CSplitterWnd))) {
  783.     CSplitterWnd *pSplitter = (CSplitterWnd*)pWnd;
  784.     CWnd *pView = pSplitter->GetActivePane();
  785.     if (pView == NULL) {
  786.       CWnd *pTmpView;
  787.       for (int x = 0; x < pSplitter->GetRowCount(); x ++) {
  788.         for (int y = 0; y < pSplitter->GetColumnCount(); y ++) {
  789.           pTmpView = pSplitter->GetPane(x,y);
  790.           if (pTmpView->IsWindowEnabled()) {
  791.             if (updateFrame(pFrame, pTmpView))
  792.               return TRUE;
  793.           }
  794.         }
  795.       }
  796.     }
  797.     if (pView == NULL)
  798.       pView = pSplitter->GetPane(0,0);
  799.     pFrame->SetActiveView((CView*)pView);
  800.   } else if (pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
  801.     TTabWnd *pTab = (TTabWnd*)pWnd;
  802.     int nIndex = pTab->GetTabIndex();
  803.     CWnd *pTabWnd = pTab->GetTabWnd(nIndex);
  804.     if (updateFrame(pFrame, pTabWnd))
  805.       return TRUE;
  806.   }
  807.   return FALSE;
  808. }
  810. // Resize tab
  811. void TTabWnd::ResizeTab(int cx, int cy)
  812. {
  813.   CRect rect;
  814.   CWnd *pParent = (CWnd*)GetParent();
  815.   ASSERT(pParent);
  816.   pParent->GetClientRect(&rect); 
  818.   if (pParent->IsKindOf(RUNTIME_CLASS(CSplitterWnd))) {
  819.     CSplitterWnd *splitter = (CSplitterWnd*)pParent;
  820.     ASSERT(pParent);
  821.     int row,col;
  822.     splitter->IsChildPane(this,row,col);
  823.     splitter->RecalcLayout();
  824.   } else if (pParent->IsKindOf(RUNTIME_CLASS(CFrameWnd))) {
  825.     m_bLockFlag = TRUE;
  826.     pParent->RepositionBars(0, 0xFFFF, AFX_IDW_PANE_FIRST, CWnd::reposQuery, &rect);
  827.     MoveWindow(rect.left,rect.top,rect.Width(),rect.Height());
  828.     m_bLockFlag = FALSE;
  829.   }
  831.   m_bLockFlag = TRUE; // reentrancy check (might get called recursivly from OnSize)
  832.   CWnd *pWnd;
  833.   TTabItemList::iterator iterator;
  834.   for (iterator = m_TabList.begin(); iterator != m_TabList.end(); iterator++) {
  835.     pWnd = (*iterator)->m_pWnd;
  836.     if (cx == -1 && cy == -1) {
  837.       switch (m_nTabPos) {
  838.       case TP_TOP:
  839.         pWnd->MoveWindow(1, TABWND_HEIGHT+1, 
  840.                          rect.Width()-2, rect.Height()-TABWND_HEIGHT-2);
  841.         break;
  842.       case TP_BOTTOM:
  843.         pWnd->MoveWindow(1, 0, rect.Width()-2, rect.Height()-TABWND_HEIGHT);
  844.         break;
  845.       }
  846.     } else {
  847.       switch (m_nTabPos) {
  848.       case TP_TOP:
  849.         pWnd->MoveWindow(1, TABWND_HEIGHT+1, cx, cy-TABWND_HEIGHT-2);
  850.         break;
  851.       case TP_BOTTOM:
  852.         pWnd->MoveWindow(1, 0, cx, cy-TABWND_HEIGHT);
  853.         break;
  854.       }
  855.     }
  856.   }
  857.   m_bLockFlag=FALSE;
  858. }
  860. // Erase area where the tabs are displayed
  861. BOOL TTabWnd::OnEraseBkgnd(CDC* pDC)
  862. {
  863.   ASSERT(pDC);
  865.   CRect rect;
  866.   GetClientRect(&rect);
  867.   switch (m_nTabPos) {
  868.   case TP_TOP:
  869.     pDC->FillSolidRect(&CRect(0, 0, rect.right, TABWND_HEIGHT), 
  870.                       ::GetSysColor(COLOR_BTNFACE));
  871.     break;
  872.   case TP_BOTTOM:
  873.     pDC->FillSolidRect(&CRect(0, rect.bottom-TABWND_HEIGHT-3, rect.right, rect.bottom), 
  874.                       ::GetSysColor(COLOR_BTNFACE));
  875.     break;
  876.   }
  877.   return TRUE;
  878. }
  880. // Handle couse click on tabs
  881. void TTabWnd::OnLButtonUp(UINT nFlags, CPoint point)
  882. {
  883.   int nNewTab = HitTest(point.x, point.y);
  884.   SetActivePane(nNewTab);
  885.   CWnd::OnLButtonUp(nFlags, point);
  886. }
  888. // Handle resize
  889. LRESULT TTabWnd::OnSizeParent(WPARAM, LPARAM lParam)
  890. {
  891.   if (m_bLockFlag)
  892.     return 0;
  893.   ResizeTab();
  894.   return 0;
  895. }
  897. // Handle resize
  898. void TTabWnd::OnSize(UINT nType, int cx, int cy) 
  899. {
  900.   CWnd::OnSize(nType, cx, cy);
  901.   ResizeTab(cx,cy);
  902. }
  904. // Create a CView derived class as a tab
  905. TTabItem *TTabWnd::CreatePane(LPCTSTR lpszLabel, CRuntimeClass *pViewClass, 
  906.                                  CCreateContext *pContext)
  907. {
  908.   CRect rect, client;
  909.   ASSERT(pViewClass && pContext);
  911.   CWnd *pWnd = (CWnd*)pViewClass->CreateObject();
  912.   if (!pWnd) 
  913.     return NULL;
  914.   
  915.   GetClientRect(&client);
  916.   rect.left = 0;
  917.   rect.top = TABWND_HEIGHT+2;
  918.   rect.right = client.right;
  919.   rect.bottom = client.bottom;
  921.   int dwStyle = AFX_WS_DEFAULT_VIEW;
  922.   if (GetParent()->IsKindOf(RUNTIME_CLASS(CSplitterWnd))) {
  923.     dwStyle &= ~WS_BORDER;
  924.   }
  926.   if (!pWnd->Create(NULL, NULL, dwStyle, rect, this, 13576+m_TabList.size(), pContext))
  927.   {
  928.     TRACE0("Warning: couldn't create client area for tab viewn");
  929.     // pWnd will be cleaned up by PostNcDestroy
  930.     return NULL;
  931.   }
  933.   // Insert new tab object into the list
  934.   TTabItem *pTab = addTab(pWnd,lpszLabel);
  935.   ASSERT(pTab);
  936.   if (m_TabList.size() != 1) {
  937.     pWnd->EnableWindow(FALSE);
  938.     pWnd->ShowWindow(SW_HIDE);
  939.   /*
  940.   // Framework is responsible to set the active view
  941.   } else {
  942.     CWnd *pParent = GetParent();
  943.     if (pParent->IsKindOf(RUNTIME_CLASS(CFrameWnd))) {
  944.       ((CFrameWnd*)pParent)->SetActiveView((CView*)pWnd);
  945.     } else if (pParent->IsKindOf(RUNTIME_CLASS(CSplitterWnd))) {
  946.       ((CSplitterWnd*)pParent)->SetActivePane(0,0,pWnd);
  947.     }
  948.   */
  949.   }
  950.   return pTab;
  951. }
  953. // Create a splitter window as a tab
  954. TTabItem *TTabWnd::CreatePane(LPCTSTR lpszLabel, int nRows, int nCols, 
  955.                                  CWnd *pWnd, UINT nID)
  956. {
  957.   ASSERT(pWnd);
  958.   ASSERT(pWnd->IsKindOf(RUNTIME_CLASS(CSplitterWnd)));
  960.   // Moved to TVisualFramework to handle creation of CSplitterWnd derived classes
  961.   //CSplitterWnd *pWnd = new CSplitterWnd;
  962.   //if (!pWnd) 
  963.   //  return NULL;
  965.   int dwStyle = AFX_WS_DEFAULT_VIEW;
  966.   dwStyle &= ~WS_BORDER;
  968.   CSplitterWnd *pSplitter = (CSplitterWnd*)pWnd;
  969.   if (!pSplitter->CreateStatic(this, nRows, nCols, dwStyle, nID)) {
  970.     TRACE0("Warning: couldn't create client area for tab viewn");
  971.     // pWnd will be cleaned up by PostNcDestroy
  972.     return NULL;
  973.   }
  975.   TTabItem *pTab = addTab(pWnd,lpszLabel);
  976.   ASSERT(pTab);
  977.   if (m_TabList.size() != 1) {
  978.     pWnd->EnableWindow(FALSE);
  979.     pWnd->ShowWindow(SW_HIDE);
  980.   } 
  982.   /*
  983.   // Framework will set the active view
  984.   CWnd *paneWnd = pWnd->GetActivePane();
  985.   if (paneWnd) {
  986.     ((CFrameWnd*)GetParent())->SetActiveView((CView*)paneWnd);
  987.   } else {
  988.     paneWnd = pWnd->GetPane(0,0);
  989.     pWnd->SetActivePane(0,0);
  990.     ((CFrameWnd*)GetParent())->SetActiveView((CView*)paneWnd);
  991.   }
  992.   */
  994.   return pTab;
  995. }
  997. //=============================================================================
  998. // class TVisualObject
  999. //
  1000. //=============================================================================
  1002. // Private constructor
  1003. TVisualObject::TVisualObject()
  1004. {
  1005. }
  1007. // Create a plain view
  1008. TVisualObject::TVisualObject(DWORD dwId, CCreateContext *pContext, 
  1009.                        CRuntimeClass *pClass)
  1010. {
  1011.   ASSERT(pContext);
  1012.   ASSERT(pClass);
  1013.   ASSERT(pClass->IsDerivedFrom(RUNTIME_CLASS(CView)));
  1015.   zeroAll();
  1016.   m_dwId = dwId;
  1017.   m_nObjectType = OT_VIEW;
  1018.   m_pContext = pContext;
  1019.   m_pRuntimeClass = pClass;
  1020.   checkStyle();
  1021. }
  1023. // Create a view within a tab window or a tab window
  1024. TVisualObject::TVisualObject(DWORD dwId, LPCTSTR szTitle, CCreateContext *pContext, 
  1025.                        CRuntimeClass *pClass, DWORD dwStyle)
  1026. {
  1027.   ASSERT(szTitle);
  1028.   ASSERT(pContext);
  1029.   ASSERT(pClass);
  1031.   zeroAll();
  1032.   m_dwId = dwId;
  1033.   if (pClass->IsDerivedFrom(RUNTIME_CLASS(TTabWnd))) {
  1034.     m_nObjectType = OT_TAB;
  1035.   } else if (pClass->IsDerivedFrom(RUNTIME_CLASS(CView))) {
  1036.     m_nObjectType = OT_TABVIEW;
  1037.   } else {
  1038.     ASSERT(FALSE);
  1039.   }
  1040.   m_strTitle = szTitle;
  1041.   m_pContext = pContext;
  1042.   m_pRuntimeClass = pClass;
  1043.   m_dwStyle = dwStyle;
  1044.   checkStyle();
  1045. }
  1047. // Create a splitter window
  1048. TVisualObject::TVisualObject(DWORD dwId, LPCTSTR szTitle, int nRows, int nCols, 
  1049.                        CCreateContext *pContext, DWORD dwStyle)
  1050. {
  1051.   ASSERT(szTitle);
  1052.   ASSERT(pContext);
  1053.   ASSERT(nRows);
  1054.   ASSERT(nCols);
  1056.   zeroAll();
  1057.   m_dwId = dwId;
  1058.   m_nObjectType = OT_SPLITTER;
  1059.   m_strTitle = szTitle;
  1060.   m_pContext = pContext;
  1061.   m_nRows = nRows;
  1062.   m_nCols = nCols;
  1063.   m_dwStyle = dwStyle;
  1064.   checkStyle();
  1065. }
  1067. // Create a view within a splitter window
  1068. TVisualObject::TVisualObject(DWORD dwId, int nRow, int nCol, CCreateContext *pContext, 
  1069.                        CRuntimeClass *pClass, CSize size, DWORD dwStyle)
  1070. {
  1071.   ASSERT(pContext);
  1072.   ASSERT(pClass);
  1073.   ASSERT(pClass->IsDerivedFrom(RUNTIME_CLASS(CView)) ||
  1074.          pClass->IsDerivedFrom(RUNTIME_CLASS(TTabWnd)));
  1076.   zeroAll();
  1077.   m_dwId = dwId;
  1078.   m_nObjectType = OT_SPLITTERVIEW;
  1079.   m_pContext = pContext;
  1080.   m_pRuntimeClass = pClass;
  1081.   m_nRowIndex = nRow;
  1082.   m_nColIndex = nCol;
  1083.   m_Size = size;
  1084.   m_dwStyle = dwStyle;
  1085.   checkStyle();
  1086. }
  1088. // Create a splitter within a splitter window
  1089. TVisualObject::TVisualObject(DWORD dwId, int nRow, int nCol, int nRows, int nCols, 
  1090.                        CCreateContext *pContext, DWORD dwStyle)
  1091. {
  1092.   ASSERT(pContext);
  1093.   ASSERT(nRows);
  1094.   ASSERT(nCols);
  1096.   zeroAll();
  1097.   m_dwId = dwId;
  1098.   m_nObjectType = OT_SPLITTERSPLITTER;
  1099.   m_pContext = pContext;
  1100.   m_nRowIndex = nRow;
  1101.   m_nColIndex = nCol;
  1102.   m_nRows = nRows;
  1103.   m_nCols = nCols;
  1104.   m_dwStyle = dwStyle;
  1105.   checkStyle();
  1106. }
  1108. TVisualObject::TVisualObject(const TVisualObject& obj)
  1109. {
  1110.   zeroAll();
  1111.   *this = obj;
  1112. }
  1114. TVisualObject::~TVisualObject()
  1115. {
  1116. }
  1118. TVisualObject& TVisualObject::operator=(const TVisualObject& obj)
  1119. {
  1120.   // No need to copy m_ObjectList since it is populated after
  1121.   // this code is executed in STL container
  1122.   m_nObjectType = obj.m_nObjectType;
  1123.   m_dwId = obj.m_dwId;
  1124.   m_pWnd = obj.m_pWnd;
  1125.   m_pParent = obj.m_pParent;
  1126.   m_strTitle = obj.m_strTitle;
  1127.   m_nRows = obj.m_nRows;
  1128.   m_nCols = obj.m_nCols;
  1129.   m_nRowIndex = obj.m_nRowIndex;
  1130.   m_nColIndex = obj.m_nColIndex;
  1131.   m_pContext = obj.m_pContext;
  1132.   m_pRuntimeClass = obj.m_pRuntimeClass;
  1133.   m_Size = obj.m_Size;
  1134.   m_bEnabled = obj.m_bEnabled;
  1135.   m_dwStyle = obj.m_dwStyle;
  1136.   m_cHotKey = obj.m_cHotKey;
  1137.   m_pOwner = obj.m_pOwner;
  1138.   m_pFramework = obj.m_pFramework;
  1139.   return *this;
  1140. }
  1142. void TVisualObject::zeroAll(void)
  1143. {
  1144.   // No need to zero m_ObjectList since it is already empty
  1145.   m_nObjectType = OT_UNKNOWN;
  1146.   m_dwId = 0;
  1147.   m_pWnd = NULL;
  1148.   m_pParent = NULL;
  1149.   m_strTitle = _T("");
  1150.   m_nRows = 0;
  1151.   m_nCols = 0;
  1152.   m_nRowIndex = 0;
  1153.   m_nColIndex = 0;
  1154.   m_pContext = NULL;
  1155.   m_pRuntimeClass = NULL;
  1156.   m_Size = CSize(0,0);
  1157.   m_bEnabled = TRUE;
  1158.   m_dwStyle = 0;
  1159.   m_cHotKey = 0;
  1160.   m_pOwner = NULL;
  1161.   m_pFramework = NULL;
  1162. }
  1164. // Check if style is valid
  1165. void TVisualObject::checkStyle(void)
  1166. {
  1167.   if ((m_dwStyle & TOS_TABTOP) || (m_dwStyle & TOS_TABBOTTOM)) {
  1168.     ASSERT(m_pRuntimeClass);
  1169.     // Tab position valid only for tab window derived classes
  1170.     ASSERT(m_pRuntimeClass->IsDerivedFrom(RUNTIME_CLASS(TTabWnd)));
  1171.   }
  1172.   if (m_dwStyle & TOS_SELECTED) {
  1173.     // Selected valid only for tab panes that are not splitters and tabs
  1174.     // In this case, use TVisualFramework::SetActivePane() to set the active pane
  1175.     // once the framework is created
  1176.     if (m_pRuntimeClass == NULL) {
  1177.       // Splitters canot be dynamically create (m_pRuntimeClass is NULL)
  1178.       ASSERT((m_nObjectType != OT_SPLITTER) && (m_nObjectType != OT_SPLITTERVIEW));
  1179.     } else {
  1180.       ASSERT(!m_pRuntimeClass->IsDerivedFrom(RUNTIME_CLASS(TTabWnd)));
  1181.     }
  1182.   }
  1183. }
  1185. // Delete the window pointer and optionally destroy the window
  1186. void TVisualObject::Destroy(BOOL bDestroyWindow)
  1187. {
  1188.   if (m_pWnd) {
  1189.     if (bDestroyWindow)
  1190.       m_pWnd->DestroyWindow();
  1191.     delete m_pWnd;
  1192.     m_pWnd = NULL;
  1193.   }
  1194. }
  1196. // If this object is a tab window or splitter window that it 
  1197. // cannot be focused
  1198. BOOL TVisualObject::CanFocus(void)
  1199. {
  1200.   ASSERT(m_pWnd);
  1202.   if (m_pWnd->IsKindOf(RUNTIME_CLASS(CSplitterWnd)) ||
  1203.       m_pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd)))
  1204.   {
  1205.     return FALSE;
  1206.   }
  1207.   return TRUE;
  1208. }
  1210. // Set hot key for this tab object
  1211. void TVisualObject::SetHotKey(CHAR cHotKey)
  1212. {
  1213.   m_cHotKey = cHotKey;
  1214. }
  1216. // Optional: Set description 
  1217. void TVisualObject::SetDescription(LPCTSTR szDesc)
  1218. {
  1219.   m_strDescription = szDesc;
  1220. }
  1222. // Set this object as active pane
  1223. BOOL TVisualObject::SetActivePane(void)
  1224. {
  1225.   ASSERT(m_pFramework);
  1226.   return m_pFramework->SetActivePane(this);
  1227. }
  1229. // Set this tab to be active tab (not the active pane)
  1230. BOOL TVisualObject::SetActiveTab(void)
  1231. {
  1232.   ASSERT(m_pFramework);
  1233.   return m_pFramework->SetActiveTab(this);
  1234. }
  1236. // Enable/disable this object
  1237. BOOL TVisualObject::Enable(BOOL bEnable)
  1238. {
  1239.   ASSERT(m_pFramework);
  1240.   return m_pFramework->Enable(this,bEnable);
  1241. }
  1243. // Enable/disable tab
  1244. BOOL TVisualObject::EnableTab(BOOL bEnable)
  1245. {
  1246.   ASSERT(m_pFramework);
  1247.   return m_pFramework->EnableTab(this,bEnable);
  1248. }
  1250. // SHow/hide this object
  1251. BOOL TVisualObject::ShowTab(BOOL bShow)
  1252. {
  1253.   ASSERT(m_pFramework);
  1254.   return m_pFramework->ShowTab(this,bShow);
  1255. }
  1257. // Is this object enabled
  1258. BOOL TVisualObject::IsEnabled(BOOL& bEnabled)
  1259. {
  1260.   ASSERT(m_pFramework);
  1261.   return m_pFramework->IsEnabled(this,bEnabled);
  1262. }
  1264. // Is this object enabled
  1265. BOOL TVisualObject::IsTabEnabled(BOOL& bEnabled)
  1266. {
  1267.   ASSERT(m_pFramework);
  1268.   return m_pFramework->IsTabEnabled(this,bEnabled);
  1269. }
  1271. // Is this object visible
  1272. BOOL TVisualObject::IsTabVisible(BOOL& bVisible)
  1273. {
  1274.   ASSERT(m_pFramework);
  1275.   return m_pFramework->IsTabVisible(this,bVisible);
  1276. }
  1278. // Returns TRUE if this object is a tab within a tab window
  1279. BOOL TVisualObject::IsTabPane(void)
  1280. {
  1281.   ASSERT(m_pFramework);
  1282.   return m_pFramework->IsTabPane(this);
  1283. }
  1285. // Returns TRUE if this object is a tab window
  1286. BOOL TVisualObject::IsTabWindow(void)
  1287. {
  1288.   ASSERT(m_pFramework);
  1289.   return m_pFramework->IsTabWindow(this);
  1290. }
  1292. // Returns TRUE if this object is a pane within a splitter window
  1293. BOOL TVisualObject::IsSplitterPane(void)
  1294. {
  1295.   ASSERT(m_pFramework);
  1296.   return m_pFramework->IsSplitterPane(this);
  1297. }
  1299. // Returns TRUE if this object is a splitter window
  1300. BOOL TVisualObject::IsSplitterWindow(void)
  1301. {
  1302.   ASSERT(m_pFramework);
  1303.   return m_pFramework->IsSplitterWindow(this);
  1304. }
  1306. // Returns TRUE if this object is derived from CView 
  1307. BOOL TVisualObject::IsView(void)
  1308. {
  1309.   ASSERT(m_pFramework);
  1310.   return m_pFramework->IsView(this);
  1311. }
  1313. // Get object ID
  1314. #ifdef _DEBUG
  1315. DWORD TVisualObject::GetID(void)
  1316. {
  1317.   return m_dwId;
  1318. }
  1319. #endif
  1321. // Get object window
  1322. #ifdef _DEBUG
  1323. CWnd *TVisualObject::GetWnd(void)
  1324. {
  1325.   return m_pWnd;
  1326. }
  1327. #endif
  1329. // Get safe object window
  1330. #ifdef _DEBUG
  1331. CWnd *TVisualObject::GetSafeWnd(void)
  1332. {
  1333.   return ::IsWindow(m_pWnd->m_hWnd) ? m_pWnd : NULL;
  1334. }
  1335. #endif
  1337. #ifdef _DEBUG
  1338. CString TVisualObject::GetTitle(void)
  1339. {
  1340.   return m_strTitle;
  1341. }
  1342. #endif
  1344. #ifdef _DEBUG
  1345. CString TVisualObject::GetDescription(void)
  1346. {
  1347.   return m_strDescription;
  1348. }
  1349. #endif
  1351. #ifdef _DEBUG
  1352. CWnd *TVisualObject::GetParentWnd(void)
  1353. {
  1354.   return m_pParent;
  1355. }
  1356. #endif
  1358. #ifdef _DEBUG
  1359. TVisualFramework *TVisualObject::GetFramework(void)
  1360. {
  1361.   return m_pFramework;
  1362. }
  1363. #endif
  1365. #ifdef _DEBUG
  1366. TVisualObject *TVisualObject::GetOwner(void)
  1367. {
  1368.   return m_pOwner;
  1369. }
  1370. #endif
  1372. //=============================================================================
  1373. // class TVisualFramework
  1374. //
  1375. //=============================================================================
  1377. IMPLEMENT_DYNCREATE(TVisualFramework, CCmdTarget)
  1379. BEGIN_MESSAGE_MAP(TVisualFramework, CCmdTarget)
  1380. //{{AFX_MSG_MAP(TVisualFramework)
  1381. //}}AFX_MSG_MAP
  1382. END_MESSAGE_MAP()
  1384. TVisualFramework::TVisualFramework()
  1385. {
  1386.   m_pOwner = NULL;
  1387.   m_bEnableCtrlTab = TRUE;
  1388. }
  1390. TVisualFramework::~TVisualFramework()
  1391. {
  1392.   if (m_ObjectMap.size() && m_ObjectList.size()) {
  1393.     TRACE0(_T(">>> TVisualFramework::Destroy() called in TVisualFramework destructorn"));
  1394.     TRACE0(_T(">>>   It must be called in CFrameWnd derived class OnDestroy() message handlern"));
  1395.     Destroy();
  1396.   }
  1397. }
  1399. // Find an object in the map with the specified unique id
  1400. TVisualObject *TVisualFramework::findObject(DWORD dwId)
  1401. {
  1402.   TVisualObjectMap::iterator iterator;
  1403.   for (iterator = m_ObjectMap.begin(); iterator != m_ObjectMap.end(); iterator++) {
  1404.     if (dwId == iterator->first)
  1405.       return iterator->second;
  1406.   }
  1407.   return NULL;
  1408. }
  1410. // Find an object in the map with the specified window
  1411. TVisualObject *TVisualFramework::findObject(CWnd *pWnd)
  1412. {
  1413.   TVisualObjectMap::iterator iterator;
  1414.   for (iterator = m_ObjectMap.begin(); iterator != m_ObjectMap.end(); iterator++) {
  1415.     if (pWnd == iterator->second->m_pWnd)
  1416.       return iterator->second;
  1417.   }
  1418.   return NULL;
  1419. }
  1421. // Add object to the container (this is a root level object)
  1422. // There is only one root level object (either splitter or tab)
  1423. BOOL TVisualFramework::Add(TVisualObject *pObject)
  1424. {
  1425.   ASSERT(pObject);
  1426.   ASSERT(m_ObjectList.size() == 0);   // Only one root level object allowed
  1428.   // Root level object is either a view, splitter or a tab
  1429.   ASSERT((pObject->m_nObjectType == TVisualObject::OT_TAB) || 
  1430.          (pObject->m_nObjectType == TVisualObject::OT_VIEW) || 
  1431.          (pObject->m_nObjectType == TVisualObject::OT_SPLITTER));
  1433.   if (findObject(pObject->m_dwId) == NULL) {
  1434.     m_ObjectList.insert(m_ObjectList.end(), pObject);
  1435.     pObject->m_pFramework = this;
  1436.     m_ObjectMap[pObject->m_dwId] = pObject;
  1437.     return TRUE;
  1438.   }
  1439.   ASSERT(FALSE);    // Duplicate object Id
  1440.   return FALSE;
  1441. }
  1443. // Add child object to the specified object
  1444. BOOL TVisualFramework::Add(TVisualObject *pOwner, TVisualObject *pObject)
  1445. {
  1446.   ASSERT(pObject);
  1448.   #ifdef _DEBUG
  1449.   // Validate definition
  1450.   if (pOwner->m_nObjectType == TVisualObject::OT_TAB) {
  1451.     if ((pObject->m_nObjectType != TVisualObject::OT_TABVIEW) && 
  1452.         (pObject->m_nObjectType != TVisualObject::OT_SPLITTER) &&
  1453.         (pObject->m_nObjectType != TVisualObject::OT_TAB))
  1454.     {
  1455.       ASSERT(FALSE);
  1456.     }
  1457.   } else if (pOwner->m_nObjectType == TVisualObject::OT_SPLITTER) {
  1458.     if ((pObject->m_nObjectType != TVisualObject::OT_SPLITTERVIEW) && 
  1459.         (pObject->m_nObjectType != TVisualObject::OT_SPLITTERSPLITTER))
  1460.     {
  1461.       ASSERT(FALSE);
  1462.     }
  1463.   } else if (pOwner->m_nObjectType == TVisualObject::OT_SPLITTERSPLITTER) {
  1464.     if ((pObject->m_nObjectType != TVisualObject::OT_SPLITTERVIEW) && 
  1465.         (pObject->m_nObjectType != TVisualObject::OT_SPLITTERSPLITTER))
  1466.     {
  1467.       ASSERT(FALSE);
  1468.     }
  1469.   } else if (pOwner->m_nObjectType == TVisualObject::OT_TABVIEW) {
  1470.     if ((pObject->m_nObjectType != TVisualObject::OT_SPLITTER))
  1471.     {
  1472.       ASSERT(FALSE);
  1473.     }
  1474.   }
  1476.   #endif
  1478.   if (findObject(pObject->m_dwId) == NULL) {
  1479.     pOwner->m_ObjectList.insert(pOwner->m_ObjectList.end(), pObject);
  1480.     pObject->m_pOwner = pOwner;
  1481.     pObject->m_pFramework = this;
  1482.     m_ObjectMap[pObject->m_dwId] = pObject;
  1483.     return TRUE;
  1484.   }
  1485.   ASSERT(FALSE);    // Duplicate object Id
  1486.   return FALSE;
  1487. }
  1489. // Create all objects within the framework
  1490. BOOL TVisualFramework::Create(CWnd *pWnd)
  1491. {
  1492.   ASSERT(pWnd);
  1493.   ASSERT(pWnd->IsKindOf(RUNTIME_CLASS(CFrameWnd)));
  1495.   // Save owner for later
  1496.   m_pOwner = pWnd;
  1498.   // Disable Ctrl+Tab for MDI applications
  1499.   if (pWnd->IsKindOf(RUNTIME_CLASS(CMDIChildWnd)))
  1500.     m_bEnableCtrlTab = FALSE;
  1502.   // Walk thru visual object hierarchy and create windows
  1503.   BOOL rc;
  1504.   TVisualObject *pObject;
  1505.   TVisualObjectList::iterator it;
  1506.   for (it = m_ObjectList.begin(); it != m_ObjectList.end(); it++) {
  1507.     pObject = *it;
  1508.     rc = execCreate(pWnd, pObject);
  1509.     if (rc == FALSE) {
  1510.       TRACE0(_T("Create visual object failed!n"));
  1511.       return FALSE;
  1512.     }
  1513.   }
  1514.   
  1515.   // Walk thru the map and find first object that can be focused
  1516.   // Then set focus
  1517.   TVisualObjectMap::iterator mapit;
  1518.   for (mapit = m_ObjectMap.begin(); mapit != m_ObjectMap.end(); mapit ++) {
  1519.     pObject = mapit->second;
  1520.     if (pObject->CanFocus()) {
  1521.       SetActivePane(pObject);
  1522.       break;
  1523.     }
  1524.   }
  1526.   return TRUE;
  1527. }
  1529. // Destroy all objects in the framework
  1530. void TVisualFramework::Destroy(void)
  1531. {
  1532.   TVisualObject *pObject;
  1534.   // Recursive delete of all objects
  1535.   TVisualObjectList::iterator it;
  1536.   for (it = m_ObjectList.begin(); it != m_ObjectList.end(); it++) {
  1537.     pObject = *it;
  1538.     execDestroy(pObject);
  1539.   }
  1541.   // Delete pointers in object map
  1542.   TVisualObjectMap::iterator mapit;
  1543.   for (mapit = m_ObjectMap.begin(); mapit != m_ObjectMap.end(); mapit++) {
  1544.     pObject = mapit->second;
  1545.     delete pObject;
  1546.   }
  1548.   // Empty all containers (for check in destructor)
  1549.   m_ObjectMap.clear();
  1550.   m_ObjectList.clear();
  1551. }
  1553. // Recursive function to delete all object windows. Does not delete views since
  1554. // they are destroyed by frame.
  1555. void TVisualFramework::execDestroy(TVisualObject *pObject)
  1556. {
  1557.   if (pObject->m_pWnd && ::IsWindow(pObject->m_pWnd->m_hWnd)) {
  1558.     if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
  1559.       TVisualObject *pObj;
  1560.       TVisualObjectList::iterator it;
  1561.       for (it = pObject->m_ObjectList.begin(); it != pObject->m_ObjectList.end(); it++) {
  1562.         pObj = *it;
  1563.         execDestroy(pObj);
  1564.       }
  1565.       pObject->Destroy(TRUE);
  1566.     } else if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(CSplitterWnd))) {
  1567.       TVisualObject *pObj;
  1568.       TVisualObjectList::iterator it;
  1569.       for (it = pObject->m_ObjectList.begin(); it != pObject->m_ObjectList.end(); it++) {
  1570.         pObj = *it;
  1571.         execDestroy(pObj);
  1572.       }
  1573.       pObject->Destroy(TRUE);
  1574.     } 
  1575.   }
  1576. }
  1578. // Create specified object and all its childs
  1579. BOOL TVisualFramework::execCreate(CWnd *pWnd, TVisualObject *pObject)
  1580. {
  1581.   ASSERT(pWnd);
  1582.   ASSERT(pObject);
  1583.   
  1584.   BOOL rc = FALSE;
  1585.   switch (pObject->m_nObjectType) {
  1586.   case (TVisualObject::OT_SPLITTER): 
  1587.     rc = execCreateSplitter(pWnd,pObject);
  1588.     break;
  1589.   case (TVisualObject::OT_SPLITTERVIEW): 
  1590.     rc = execCreateSplitterView(pWnd, pObject);
  1591.     break;
  1592.   case (TVisualObject::OT_SPLITTERSPLITTER):
  1593.     rc = execCreateSplitterSplitter(pWnd, pObject);
  1594.     break;
  1595.   case (TVisualObject::OT_TAB):
  1596.     rc = execCreateTabWnd(pWnd, pObject);
  1597.     break;
  1598.   case (TVisualObject::OT_TABVIEW):
  1599.     rc = execCreateTabView(pWnd, pObject);
  1600.     break;
  1601.   case (TVisualObject::OT_VIEW):
  1602.     rc = execCreateView(pWnd, pObject);
  1603.     break;
  1604.   }
  1605.   return rc;
  1606. }
  1608. // Create a simple view 
  1609. BOOL TVisualFramework::execCreateView(CWnd *pWnd, TVisualObject *pObject)
  1610. {
  1611.   ASSERT(pWnd);
  1612.   ASSERT(pWnd->IsKindOf(RUNTIME_CLASS(CFrameWnd)));
  1613.   ASSERT(pObject);
  1614.   ASSERT(pObject->m_pContext);
  1615.   ASSERT(pObject->m_pRuntimeClass);
  1617.   CFrameWnd *pFrame = (CFrameWnd*)pWnd;
  1618.   pObject->m_pContext->m_pNewViewClass = pObject->m_pRuntimeClass;
  1619.   pObject->m_pWnd = pFrame->CreateView(pObject->m_pContext);
  1620.   ASSERT(pObject->m_pWnd);
  1621.   ASSERT(::IsWindow(pObject->m_pWnd->m_hWnd));
  1622.   
  1623.   pObject->m_pParent = pFrame;
  1624.   setTabWndProperties(pObject);
  1625.   
  1626.   return TRUE;
  1627. }
  1629. // Create a view within a tab window
  1630. BOOL TVisualFramework::execCreateTabView(CWnd *pWnd, TVisualObject *pObject)
  1631. {
  1632.   ASSERT(pWnd);
  1633.   ASSERT(pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd)));
  1634.   ASSERT(pObject);
  1635.   ASSERT(pObject->m_pContext);
  1636.   ASSERT(pObject->m_pRuntimeClass);
  1637.   ASSERT(!pObject->m_strTitle.IsEmpty());
  1639.   TTabWnd *pTab = (TTabWnd*)pWnd;
  1640.   TTabItem *pItem;
  1641.   pItem = pTab->CreatePane(pObject->m_strTitle, pObject->m_pRuntimeClass, 
  1642.                             pObject->m_pContext);
  1643.   ASSERT(pItem);
  1644.   pObject->m_pWnd = pItem->GetSafeWnd();
  1645.   ASSERT(pObject->m_pWnd);
  1646.   ASSERT(::IsWindow(pObject->m_pWnd->m_hWnd));
  1647.   pObject->m_pParent = pTab;
  1648.   setTabWndProperties(pObject);
  1649.   return TRUE;
  1650. }
  1652. // Create a splitter window
  1653. BOOL TVisualFramework::execCreateSplitter(CWnd *pWnd, TVisualObject *pObject)
  1654. {
  1655.   ASSERT(pWnd);
  1656.   ASSERT(pObject);
  1658.   // Cannot use pObject->m_pRuntimeClass->CreateObject() since splitters 
  1659.   // do not support dynamic creation
  1660.   pObject->m_pWnd = CreateSplitter(pObject->m_dwId);
  1661.   ASSERT(pObject->m_pWnd);
  1662.   ASSERT(pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(CSplitterWnd)));
  1664.   if (pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
  1665.     TTabWnd *pTab = (TTabWnd*)pWnd;
  1666.     TTabItem *pItem = pTab->CreatePane(pObject->m_strTitle, pObject->m_nRows, 
  1667.                                        pObject->m_nCols, pObject->m_pWnd);
  1668.     ASSERT(::IsWindow(pObject->m_pWnd->m_hWnd));
  1669.     pObject->m_pParent = pWnd;
  1670.   } else if (pWnd->IsKindOf(RUNTIME_CLASS(CFrameWnd))) {
  1671.     ((CSplitterWnd*)pObject->m_pWnd)->CreateStatic(pWnd,pObject->m_nRows,pObject->m_nCols);
  1672.     ASSERT(::IsWindow(pObject->m_pWnd->m_hWnd));
  1673.     pObject->m_pParent = pWnd;
  1674.   }
  1675.   setTabWndProperties(pObject);
  1676.   TVisualObjectList::iterator it;
  1677.   for (it = pObject->m_ObjectList.begin(); it != pObject->m_ObjectList.end(); it++) {
  1678.     execCreate(pObject->m_pWnd, *it);
  1679.   }
  1680.   return TRUE;
  1681. }
  1683. // Create a view within a splitter. Then create all childs of this view.
  1684. BOOL TVisualFramework::execCreateSplitterView(CWnd *pWnd, TVisualObject *pObject)
  1685. {
  1686.   ASSERT(pWnd);
  1687.   ASSERT(pWnd->IsKindOf(RUNTIME_CLASS(CSplitterWnd)));
  1688.   ASSERT(pObject);
  1689.   
  1690.   CSplitterWnd *pSplitter = (CSplitterWnd*)pWnd;
  1691.   pSplitter->CreateView(pObject->m_nRowIndex, pObject->m_nColIndex, 
  1692.                         pObject->m_pRuntimeClass, pObject->m_Size, 
  1693.                         pObject->m_pContext);
  1694.   pObject->m_pWnd = pSplitter->GetPane(pObject->m_nRowIndex, pObject->m_nColIndex);
  1695.   ASSERT(pObject->m_pWnd);
  1696.   ASSERT(::IsWindow(pObject->m_pWnd->m_hWnd));
  1697.   pObject->m_pParent = pSplitter;
  1698.   setTabWndProperties(pObject);
  1699.   TVisualObjectList::iterator it;
  1700.   for (it = pObject->m_ObjectList.begin(); it != pObject->m_ObjectList.end(); it++) {
  1701.     execCreate(pObject->m_pWnd, *it);
  1702.   }
  1703.   return TRUE;
  1704. }
  1706. // Create a nested splitter window
  1707. BOOL TVisualFramework::execCreateSplitterSplitter(CWnd *pWnd, TVisualObject *pObject)
  1708. {
  1709.   ASSERT(pWnd);
  1710.   ASSERT(pWnd->IsKindOf(RUNTIME_CLASS(CSplitterWnd)));
  1711.   
  1712.   CSplitterWnd *pParent = (CSplitterWnd*)pWnd;
  1713.   // Cannot use pObject->m_pRuntimeClass->CreateObject() since splitters 
  1714.   // do not support dynamic creation
  1715.   pObject->m_pWnd = CreateSplitter(pObject->m_dwId);
  1716.   ASSERT(pObject->m_pWnd);
  1717.   ASSERT(pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(CSplitterWnd)));
  1718.   CSplitterWnd *pSplitter = (CSplitterWnd*)pObject->m_pWnd;
  1719.   pSplitter->CreateStatic(pParent, pObject->m_nRows, pObject->m_nCols, 
  1720.                           WS_CHILD|WS_VISIBLE|WS_BORDER, 
  1721.                           pParent->IdFromRowCol(pObject->m_nRowIndex,pObject->m_nColIndex));
  1722.   ASSERT(::IsWindow(pSplitter->m_hWnd));
  1723.   pObject->m_pParent = pParent;
  1724.   TVisualObjectList::iterator it;
  1725.   for (it = pObject->m_ObjectList.begin(); it != pObject->m_ObjectList.end(); it++) {
  1726.     execCreate(pObject->m_pWnd, *it);
  1727.   }
  1728.   return TRUE;
  1729. }
  1731. // Create a tab window and all its childs (tabs)
  1732. BOOL TVisualFramework::execCreateTabWnd(CWnd *pWnd, TVisualObject *pObject)
  1733. {
  1734.   ASSERT(pWnd);
  1735.   ASSERT(pObject);
  1736.   
  1737.   if (pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
  1738.     TTabWnd *pTab = (TTabWnd*)pWnd;
  1739.     TTabItem *pItem = pTab->CreatePane(pObject->m_strTitle, pObject->m_pRuntimeClass,
  1740.                                        pObject->m_pContext);
  1741.     ASSERT(pItem);
  1742.     pObject->m_pWnd = pItem->GetSafeWnd();
  1743.     ASSERT(pObject->m_pWnd);
  1744.     ASSERT(::IsWindow(pObject->m_pWnd->m_hWnd));
  1745.     pObject->m_pParent = pWnd;
  1746.     setTabWndProperties(pObject);
  1747.   } else {
  1748.     CRect rect;
  1749.     pObject->m_pWnd = (CWnd*)pObject->m_pRuntimeClass->CreateObject();
  1750.     ASSERT(pObject->m_pWnd);
  1751.     pObject->m_pParent = pWnd;
  1752.     pObject->m_pWnd->Create(NULL,_T(""),WS_VISIBLE|WS_CHILD,
  1753.                                 rect,pWnd,TABWND_DEFAULT_ID);
  1754.     ASSERT(::IsWindow(pObject->m_pWnd->m_hWnd));
  1755.     setTabWndProperties(pObject);
  1756.   }
  1757.   TVisualObject *pObj;
  1758.   TVisualObjectList::iterator it;
  1759.   for (it = pObject->m_ObjectList.begin(); it != pObject->m_ObjectList.end(); it++) {
  1760.     pObj = *it;
  1761.     execCreate(pObject->m_pWnd, pObj);
  1762.   }
  1763.   return TRUE;
  1764. }
  1766. // Set properties of tab window
  1767. void TVisualFramework::setTabWndProperties(TVisualObject *pObject)
  1768. {
  1769.   ASSERT(pObject);
  1770.   ASSERT(pObject->m_pWnd != NULL);
  1772.   // If this is a tab window then set the position of tabs
  1773.   if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
  1774.     TTabWnd *pTab = (TTabWnd*)pObject->m_pWnd;
  1775.     if (pObject->m_dwStyle & TVisualObject::TOS_TABTOP)
  1776.       pTab->SetTabPos(TTabWnd::TP_TOP);
  1777.     else if (pObject->m_dwStyle & TVisualObject::TOS_TABBOTTOM)
  1778.       pTab->SetTabPos(TTabWnd::TP_BOTTOM);
  1779.   }
  1780.   
  1781.   // If this is a pane within a tab then check if this pane
  1782.   // should be a selected pane
  1783.   ASSERT(pObject->m_pParent);
  1784.   if (pObject->m_pParent->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
  1785.     TTabWnd *pTab = (TTabWnd*)pObject->m_pParent;
  1786.     if (pObject->m_dwStyle & TVisualObject::TOS_SELECTED) {
  1787.       int nIndex = pTab->GetTabIndex(pObject->m_pWnd);
  1788.       pTab->SetActivePane(nIndex);
  1789.     }
  1790.   }
  1791. }
  1793. // Get owner pointer (CFrameWnd derived class)
  1794. CWnd *TVisualFramework::GetWnd(void)
  1795. {
  1796.   return m_pOwner;
  1797. }
  1799. // Get safe owner pointer (CFrameWnd derived class)
  1800. CWnd *TVisualFramework::GetSafeWnd(void)
  1801. {
  1802.   if (m_pOwner && ::IsWindow(m_pOwner->m_hWnd))
  1803.     return m_pOwner;
  1804.   return NULL;
  1805. }
  1807. // Get window associated with the visual object specified with its id
  1808. // Can be any object (view, splitter or tab window)
  1809. CWnd *TVisualFramework::GetObject(DWORD dwId)
  1810. {
  1811.   TVisualObject *pObject = findObject(dwId);
  1812.   if (pObject == NULL)
  1813.     return NULL;
  1814.   return pObject->m_pWnd;
  1815. }
  1817. // Get ID associated with the visual object specified with its window pointer
  1818. // Can be any object (view, splitter or tab window)
  1819. DWORD TVisualFramework::GetObject(CWnd *pWnd)
  1820. {
  1821.   ASSERT(pWnd);
  1822.   TVisualObject *pObject = findObject(pWnd);
  1823.   if (pObject == NULL)
  1824.     return NULL;
  1825.   return pObject->m_dwId;
  1826. }
  1828. // Return a visual object with the specified id
  1829. TVisualObject *TVisualFramework::Get(DWORD dwId)
  1830. {
  1831.   return findObject(dwId);
  1832. }
  1834. // Return a visual object with the specified window
  1835. TVisualObject *TVisualFramework::Get(CWnd *pWnd)
  1836. {
  1837.   return findObject(pWnd);
  1838. }
  1840. // Returns an object that represents the currently active tab within the
  1841. // supplied tab window object. This may not be the active pane
  1842. TVisualObject *TVisualFramework::GetActiveTab(TVisualObject *pObject)
  1843. {
  1844.   ASSERT(pObject);
  1845.   ASSERT(pObject->m_pWnd);
  1847.   if (!pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd)))
  1848.     return NULL;
  1850.   TTabWnd *pTab = (TTabWnd*)pObject->m_pWnd;
  1851.   int nIndex = pTab->GetTabIndex();
  1852.   CWnd *pWnd = pTab->GetTabWnd(nIndex);
  1853.   ASSERT(pWnd);
  1854.   
  1855.   return Get(pWnd);
  1856. }
  1858. // Set the active tab of the parent tab window. This will not activate the
  1859. // pane associated with the active tab.
  1860. BOOL TVisualFramework::SetActiveTab(TVisualObject *pObject)
  1861. {
  1862.   ASSERT(pObject);
  1863.   ASSERT(pObject->m_pWnd);
  1864.   ASSERT(pObject->m_pParent);
  1866.   if (!pObject->m_pParent->IsKindOf(RUNTIME_CLASS(TTabWnd)))
  1867.     return FALSE;
  1869.   TTabWnd *pTab = (TTabWnd*)pObject->m_pParent;
  1870.   int nIndex = pTab->GetTabIndex(pObject->m_pWnd);
  1871.   return pTab->SetActivePane(nIndex,FALSE);
  1872. }
  1874. // Returns TRUE if object is a tab within a tab window
  1875. BOOL TVisualFramework::IsTabPane(TVisualObject* pObject)
  1876. {
  1877.   ASSERT(pObject);
  1878.   ASSERT(pObject->m_pWnd);
  1879.   ASSERT(pObject->m_pParent);
  1881.   if (pObject->m_pParent->IsKindOf(RUNTIME_CLASS(TTabWnd)))
  1882.     return TRUE;
  1883.   return FALSE;
  1884. }
  1886. // Returns TRUE if object is a tab window
  1887. BOOL TVisualFramework::IsTabWindow(TVisualObject* pObject)
  1888. {
  1889.   ASSERT(pObject);
  1890.   ASSERT(pObject->m_pWnd);
  1892.   if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd)))
  1893.     return TRUE;
  1894.   return FALSE;
  1895. }
  1897. // Returns TRUE if object is a pane within a splitter window
  1898. BOOL TVisualFramework::IsSplitterPane(TVisualObject* pObject)
  1899. {
  1900.   ASSERT(pObject);
  1901.   ASSERT(pObject->m_pWnd);
  1902.   ASSERT(pObject->m_pParent);
  1904.   if (pObject->m_pParent->IsKindOf(RUNTIME_CLASS(CSplitterWnd)))
  1905.     return TRUE;
  1906.   return FALSE;
  1907. }
  1909. // Returns TRUE if object is a pane within a splitter window
  1910. BOOL TVisualFramework::IsSplitterWindow(TVisualObject* pObject)
  1911. {
  1912.   ASSERT(pObject);
  1913.   ASSERT(pObject->m_pWnd);
  1915.   if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(CSplitterWnd)))
  1916.     return TRUE;
  1917.   return FALSE;
  1918. }
  1920. // Returns TRUE if object is derived from CView
  1921. BOOL TVisualFramework::IsView(TVisualObject *pObject)
  1922. {
  1923.   ASSERT(pObject);
  1924.   ASSERT(pObject->m_pWnd);
  1926.   if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(CView)))
  1927.     return TRUE;
  1928.   return FALSE;
  1929. }
  1931. // Get the count of visual objects
  1932. int TVisualFramework::GetCount(void)
  1933. {
  1934.   return m_ObjectMap.size();
  1935. }
  1937. // Set font for complete framework
  1938. void TVisualFramework::SetFont(CFont *pFont)
  1939. {
  1940.   ASSERT(pFont);
  1941.   
  1942.   TVisualObject *pObject;
  1943.   TVisualObjectMap::iterator mapit;
  1944.   for (mapit = m_ObjectMap.begin(); mapit != m_ObjectMap.end(); mapit ++) {
  1945.     pObject = mapit->second;
  1946.     if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
  1947.       ((TTabWnd*)pObject->m_pWnd)->SetFont(pFont);
  1948.     } else if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(TVisualFormView))) {
  1949.       ((TVisualFormView*)pObject->m_pWnd)->SetFont(pFont);
  1950.     } else {
  1951.       pObject->m_pWnd->SetFont(pFont);
  1952.     }
  1953.   }
  1954. }
  1956. // Enable/disable CtrlTab for tab window
  1957. void TVisualFramework::EnableCtrlTab(BOOL bEnable)
  1958. {
  1959.   // If framework is used in an MDI application, then Ctrl+Tab is used to switch
  1960.   // among open windows. If it is enabled, Ctrl+Tab will then switch among 
  1961.   // tab panes within the MDI child frame window (this disables default Ctrl+Tab
  1962.   // for MDI windows).
  1963.   // Ctrl+Tab works only if CWinApp derived class overloads PreTranslateMessage
  1964.   // and calles ProcessMessage() of the active TVisualFramework object
  1965.   m_bEnableCtrlTab = bEnable;
  1966. }
  1968. // Since CSplitterWnd does not support dynamic creation, this is a chance for
  1969. // derived class to supply CSplitterWnd derived class instead of CSplitterWnd
  1970. CSplitterWnd *TVisualFramework::CreateSplitter(DWORD dwId)
  1971. {
  1972.   return new CSplitterWnd;
  1973. }
  1975. // Set focus to visual object 
  1976. BOOL TVisualFramework::SetActivePane(TVisualObject *pObject)
  1977. {
  1978.   ASSERT(pObject);
  1980.   // Cannot set focus to splitter or tab window
  1981.   if (!pObject->CanFocus())
  1982.     return FALSE;
  1984.   // Cannot set focus to disabled window
  1985.   BOOL bEnabled;
  1986.   if (pObject->IsEnabled(bEnabled) && !bEnabled)
  1987.     return FALSE;
  1989.   // Build a list that walks thru the object hierarchy from specified 
  1990.   // object to the root
  1991.   TVisualObjectList list;
  1992.   TVisualObject *pObj = pObject;
  1993.   while (pObj) {
  1994.     list.insert(list.end(),pObj);
  1995.     pObj = pObj->m_pOwner;
  1996.   }
  1997.   
  1998.   // Reverse the list so that we can walk from root to the desired object
  1999.   list.reverse();
  2000.   
  2001.   // Now, walk thru the list and set focus as desired
  2002.   TVisualObjectList::iterator it;
  2003.   for (it = list.begin(); it != list.end(); it ++) {
  2004.     pObj = *it;
  2005.     if (pObj->m_pOwner && pObj->m_pOwner->m_pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
  2006.       TTabWnd *pTab = (TTabWnd*)pObj->m_pOwner->m_pWnd;
  2007.       int nIndex = pTab->GetTabIndex(pObj->m_pWnd);
  2008.       if (!pTab->SetActivePane(nIndex)) 
  2009.         return FALSE;
  2010.     }
  2011.   }
  2013.   // Update framework owner
  2014.   CFrameWnd *pFrame = (CFrameWnd*)m_pOwner;
  2015.   pFrame->SetActiveView((CView*)pObject->m_pWnd);
  2017.   return TRUE;
  2018. }
  2020. // Return a pointer to visual object that represents the currently active pane
  2021. TVisualObject *TVisualFramework::GetActivePane(void)
  2022. {
  2023.   CFrameWnd *pFrame = (CFrameWnd*)m_pOwner;
  2024.   ASSERT(pFrame);
  2025.   CView *pView = pFrame->GetActiveView();
  2026.   ASSERT(pView);
  2027.   return findObject(pView);
  2028. }
  2030. // Enable/disable a view. Returns TRUE if sucessful
  2031. BOOL TVisualFramework::Enable(TVisualObject *pObject, BOOL bEnable)
  2032. {
  2033.   ASSERT(pObject);
  2034.   ASSERT(pObject->m_pWnd);
  2036.   if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(CView))) {
  2037.     pObject->m_bEnabled = bEnable;
  2038.     pObject->m_pWnd->EnableWindow(bEnable);
  2039.     if (pObject->m_pParent->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
  2040.       TTabWnd *pTab = (TTabWnd*)pObject->m_pParent;
  2041.       int nIndex = pTab->GetTabIndex(pObject->m_pWnd);
  2042.       pTab->Enable(nIndex, bEnable);
  2043.     }
  2044.     return TRUE;
  2045.   }
  2046.   return FALSE;
  2047. }
  2049. // Enable/disable a tab
  2050. BOOL TVisualFramework::EnableTab(TVisualObject *pObject, BOOL bEnable)
  2051. {
  2052.   ASSERT(pObject);
  2053.   ASSERT(pObject->m_pWnd);
  2054.   ASSERT(pObject->m_pParent);
  2056.   // Check if parent is a tab window
  2057.   if (pObject->m_pParent->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
  2058.     TTabWnd *pTab = (TTabWnd*)pObject->m_pParent;
  2059.     int nIndex = pTab->GetTabIndex(pObject->m_pWnd);
  2060.     if (nIndex == pTab->GetTabIndex())
  2061.       return FALSE;
  2062.     pTab->EnableTab(nIndex, bEnable);
  2063.     pObject->m_bEnabled = bEnable;
  2064.     return TRUE;
  2065.   }
  2066.   return FALSE;
  2067. }
  2069. // Show/hide a tab
  2070. BOOL TVisualFramework::ShowTab(TVisualObject *pObject, BOOL bShow)
  2071. {
  2072.   ASSERT(pObject);
  2073.   ASSERT(pObject->m_pWnd);
  2074.   ASSERT(pObject->m_pParent);
  2076.   if (!pObject->m_pParent->IsKindOf(RUNTIME_CLASS(TTabWnd)))
  2077.     return FALSE;
  2079.   TTabWnd *pTab = (TTabWnd*)pObject->m_pParent;
  2080.   int nIndex = pTab->GetTabIndex(pObject->m_pWnd);
  2081.   if (nIndex == pTab->GetTabIndex())
  2082.     return FALSE;
  2084.   pTab->ShowTab(nIndex, bShow);
  2085.   return TRUE;
  2086. }
  2088. // Is object enabled. Returns FALSE if this is not a valid call for the supplied
  2089. // object. If return code is TRUE, check bEnabled
  2090. BOOL TVisualFramework::IsEnabled(TVisualObject *pObject, BOOL& bEnabled)
  2091. {
  2092.   ASSERT(pObject);
  2093.   ASSERT(pObject->m_pWnd);
  2095.   bEnabled = pObject->m_bEnabled;
  2096.   return TRUE;
  2097.   /*
  2098.   if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(CView))) {
  2099.     bEnabled = pObject->m_pWnd->IsWindowEnabled();
  2100.     return TRUE;
  2101.   }
  2102.   return FALSE;
  2103.   */
  2104. }
  2106. // Is tab enabled. Returns FALSE if this is not a valid call for the supplied
  2107. // object. If return code is TRUE, check bEnabled
  2108. BOOL TVisualFramework::IsTabEnabled(TVisualObject *pObject, BOOL& bEnabled)
  2109. {
  2110.   ASSERT(pObject);
  2111.   ASSERT(pObject->m_pWnd);
  2112.   ASSERT(pObject->m_pParent);
  2114.   if (pObject->m_pParent->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
  2115.     TTabWnd *pTab = (TTabWnd*)pObject->m_pParent;
  2116.     int nIndex = pTab->GetTabIndex(pObject->m_pWnd);
  2117.     bEnabled = pTab->IsTabEnabled(nIndex);
  2118.     return TRUE;
  2119.   }
  2120.   return FALSE;
  2121. }
  2123. // Is tab visible. Returns FALSE if this is not a valid call for the supplied
  2124. // object. If return code is TRUE then check bVisible.
  2125. BOOL TVisualFramework::IsTabVisible(TVisualObject *pObject, BOOL& bVisible)
  2126. {
  2127.   ASSERT(pObject);
  2128.   ASSERT(pObject->m_pWnd);
  2129.   ASSERT(pObject->m_pParent);
  2131.   if (pObject->m_pParent->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
  2132.     TTabWnd *pTab = (TTabWnd*)pObject->m_pParent;
  2133.     int nIndex = pTab->GetTabIndex(pObject->m_pWnd);
  2134.     bVisible = pTab->IsTabVisible(nIndex);
  2135.     return TRUE;
  2136.   }
  2137.   return FALSE;
  2138. }
  2140. // This should be called from CWinApp derived PreTranslateMessage to handle
  2141. // any framework related messages
  2142. BOOL TVisualFramework::ProcessMessage(MSG *pMsg)
  2143. {
  2144.   ASSERT(pMsg);
  2145.   if (pMsg->message == WM_KEYDOWN) {
  2146.     // Handle Ctrl+Tab for tab windows
  2147.     if (m_bEnableCtrlTab) {
  2148.       if ((pMsg->wParam == VK_TAB) && (::GetAsyncKeyState(VK_CONTROL) != 0)) {
  2149.         CWnd *pWnd = CWnd::FromHandle(pMsg->hwnd);
  2150.         ASSERT(pWnd);
  2151.         if (pWnd->IsKindOf(RUNTIME_CLASS(CFrameWnd)))
  2152.           return FALSE;
  2153.         // If we are in form view then pWnd is a control
  2154.         while (pWnd && !pWnd->IsKindOf(RUNTIME_CLASS(CView)))
  2155.           pWnd = pWnd->GetParent();
  2156.         // Find object for this window
  2157.         //if (!pWnd) return FALSE;//jojo
  2158. ASSERT(pWnd);
  2159.         TVisualObject *pObject = findObject(pWnd);
  2160. //if (pObject==NULL) return FALSE;//jojo
  2161.         ASSERT(pObject != NULL);
  2162.         while (pObject && !pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd)))
  2163.           pObject = pObject->m_pOwner;
  2164.         if (pObject) {
  2165.           TTabWnd *pTab = (TTabWnd*)pObject->m_pWnd;
  2166.           BOOL bShift = (::GetAsyncKeyState(VK_SHIFT) != 0);
  2167.           int nIndex = pTab->GetTabIndex();
  2168.           int nNdx = nIndex;
  2169.           // Switch to new pane (skip invisible and disabled)
  2170.           do {
  2171.             if (bShift) {
  2172.               // Does not work
  2173.               nNdx--;
  2174.               if (nNdx < 0)
  2175.                 nNdx = pTab->GetTabCount()-1;
  2176.             } else {
  2177.               nNdx ++;
  2178.               if (nNdx == pTab->GetTabCount())
  2179.                 nNdx = 0;
  2180.             }
  2181.           } while (!pTab->SetActivePane(nNdx) && (nNdx != nIndex));
  2182.           return TRUE;
  2183.         }
  2184.       }
  2185.     }
  2186.   } else if (pMsg->message == WM_SYSKEYDOWN) {
  2187.     // Handle hot keys for views (if defined)
  2188.     TVisualObject *pObject;
  2189.     TVisualObjectMap::iterator mapit;
  2190.     for (mapit = m_ObjectMap.begin(); mapit != m_ObjectMap.end(); mapit ++) {
  2191.       pObject = mapit->second;
  2192.       if (pObject->m_cHotKey == pMsg->wParam) {
  2193.         if (SetActivePane(pObject))
  2194.           return TRUE;
  2195.       }
  2196.     }
  2197.   }
  2199.   return FALSE;
  2200. }
  2202. BOOL TVisualFramework::OnCmdMsg(UINT nID, int nCode, void* pExtra, 
  2203.                              AFX_CMDHANDLERINFO* pHandlerInfo) 
  2204. {
  2205. // TODO: Add your specialized code here and/or call the base class
  2207. return CCmdTarget::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
  2208. }
  2210. //=============================================================================
  2211. // class TVisualFormView
  2212. //
  2213. // This class implements the code to set the font for all child controls.
  2214. // If it belongs to the visual framework (as a pane) then setting the font
  2215. // for the framework's panes will automatically set the font for all child
  2216. // controls in the form view.
  2217. //=============================================================================
  2219. static BOOL __stdcall setChildFont(HWND hwnd, LPARAM lparam);
  2220. static BOOL __stdcall setChildEnabled(HWND hwnd, LPARAM lparam);
  2222. IMPLEMENT_DYNAMIC(TVisualFormView, CFormView)
  2224. BEGIN_MESSAGE_MAP(TVisualFormView, CFormView)
  2225. //{{AFX_MSG_MAP(TVisualFormView)
  2226. ON_WM_ENABLE()
  2227. //}}AFX_MSG_MAP
  2228. END_MESSAGE_MAP()
  2230. TVisualFormView::TVisualFormView(LPCTSTR lpszTemplateName)
  2231. : CFormView(lpszTemplateName)
  2232. {
  2233. }
  2235. TVisualFormView::TVisualFormView(UINT nIDTemplate)
  2236. : CFormView(nIDTemplate)
  2237. {
  2238. }
  2240. void TVisualFormView::SetFont(CFont *pFont)
  2241. {
  2242.   ASSERT(pFont);
  2243.   ::EnumChildWindows(m_hWnd, ::setChildFont, (LPARAM)pFont);
  2244. }
  2246. void TVisualFormView::OnEnable(BOOL bEnable) 
  2247. {
  2248. CFormView::OnEnable(bEnable);
  2249.   ::EnumChildWindows(m_hWnd, ::setChildEnabled, (LPARAM)bEnable);
  2250. }
  2252. // lParam is a pointer to CFont object
  2253. BOOL __stdcall setChildFont(HWND hwnd, LPARAM lparam)
  2254. {
  2255.   CFont *pFont = (CFont*)lparam;
  2256.   ASSERT(pFont);
  2257.   CWnd *pWnd = CWnd::FromHandle(hwnd);
  2258.   ASSERT(pWnd);
  2259.   pWnd->SetFont(pFont);
  2260.   return TRUE;
  2261. }
  2263. // lParam is a BOOL
  2264. BOOL __stdcall setChildEnabled(HWND hwnd, LPARAM lparam)
  2265. {
  2266.   BOOL bEnabled = (BOOL)lparam;
  2267.   CWnd *pWnd = CWnd::FromHandle(hwnd);
  2268.   ASSERT(pWnd);
  2269.   pWnd->EnableWindow(bEnabled);
  2270.   return TRUE;
  2271. }
  2273. /*#############################################################################
  2274. # End of file VISUALFX.CPP
  2275. #############################################################################*/