pTab->SetActivePane(nIndex);
    }
  }
}

// Get owner pointer (CFrameWnd derived class)
CWnd *TVisualFramework::GetWnd(void)
{
  return m_pOwner;
}

// Get safe owner pointer (CFrameWnd derived class)
CWnd *TVisualFramework::GetSafeWnd(void)
{
  if (m_pOwner && ::IsWindow(m_pOwner->m_hWnd))
    return m_pOwner;
  return NULL;
}

// Get window associated with the visual object specified with its id
// Can be any object (view, splitter or tab window)
CWnd *TVisualFramework::GetObject(DWORD dwId)
{
  TVisualObject *pObject = findObject(dwId);
  if (pObject == NULL)
    return NULL;
  return pObject->m_pWnd;
}

// Get ID associated with the visual object specified with its window pointer
// Can be any object (view, splitter or tab window)
DWORD TVisualFramework::GetObject(CWnd *pWnd)
{
  ASSERT(pWnd);
  TVisualObject *pObject = findObject(pWnd);
  if (pObject == NULL)
    return NULL;
  return pObject->m_dwId;
}

// Return a visual object with the specified id
TVisualObject *TVisualFramework::Get(DWORD dwId)
{
  return findObject(dwId);
}

// Return a visual object with the specified window
TVisualObject *TVisualFramework::Get(CWnd *pWnd)
{
  return findObject(pWnd);
}

// Returns an object that represents the currently active tab within the
// supplied tab window object. This may not be the active pane
TVisualObject *TVisualFramework::GetActiveTab(TVisualObject *pObject)
{
  ASSERT(pObject);
  ASSERT(pObject->m_pWnd);

  if (!pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd)))
    return NULL;

  TTabWnd *pTab = (TTabWnd*)pObject->m_pWnd;
  int nIndex = pTab->GetTabIndex();
  CWnd *pWnd = pTab->GetTabWnd(nIndex);
  ASSERT(pWnd);
  
  return Get(pWnd);
}

// Set the active tab of the parent tab window. This will not activate the
// pane associated with the active tab.
BOOL TVisualFramework::SetActiveTab(TVisualObject *pObject)
{
  ASSERT(pObject);
  ASSERT(pObject->m_pWnd);
  ASSERT(pObject->m_pParent);

  if (!pObject->m_pParent->IsKindOf(RUNTIME_CLASS(TTabWnd)))
    return FALSE;

  TTabWnd *pTab = (TTabWnd*)pObject->m_pParent;
  int nIndex = pTab->GetTabIndex(pObject->m_pWnd);
  return pTab->SetActivePane(nIndex,FALSE);
}

// Returns TRUE if object is a tab within a tab window
BOOL TVisualFramework::IsTabPane(TVisualObject* pObject)
{
  ASSERT(pObject);
  ASSERT(pObject->m_pWnd);
  ASSERT(pObject->m_pParent);

  if (pObject->m_pParent->IsKindOf(RUNTIME_CLASS(TTabWnd)))
    return TRUE;
  return FALSE;
}

// Returns TRUE if object is a tab window
BOOL TVisualFramework::IsTabWindow(TVisualObject* pObject)
{
  ASSERT(pObject);
  ASSERT(pObject->m_pWnd);

  if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd)))
    return TRUE;
  return FALSE;
}

// Returns TRUE if object is a pane within a splitter window
BOOL TVisualFramework::IsSplitterPane(TVisualObject* pObject)
{
  ASSERT(pObject);
  ASSERT(pObject->m_pWnd);
  ASSERT(pObject->m_pParent);

  if (pObject->m_pParent->IsKindOf(RUNTIME_CLASS(CSplitterWnd)))
    return TRUE;
  return FALSE;
}

// Returns TRUE if object is a pane within a splitter window
BOOL TVisualFramework::IsSplitterWindow(TVisualObject* pObject)
{
  ASSERT(pObject);
  ASSERT(pObject->m_pWnd);

  if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(CSplitterWnd)))
    return TRUE;
  return FALSE;
}

// Returns TRUE if object is derived from CView
BOOL TVisualFramework::IsView(TVisualObject *pObject)
{
  ASSERT(pObject);
  ASSERT(pObject->m_pWnd);

  if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(CView)))
    return TRUE;
  return FALSE;
}

// Get the count of visual objects
int TVisualFramework::GetCount(void)
{
  return m_ObjectMap.size();
}

// Set font for complete framework
void TVisualFramework::SetFont(CFont *pFont)
{
  ASSERT(pFont);
  
  TVisualObject *pObject;
  TVisualObjectMap::iterator mapit;
  for (mapit = m_ObjectMap.begin(); mapit != m_ObjectMap.end(); mapit ++) {
    pObject = mapit->second;
    if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
      ((TTabWnd*)pObject->m_pWnd)->SetFont(pFont);
    } else if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(TVisualFormView))) {
      ((TVisualFormView*)pObject->m_pWnd)->SetFont(pFont);
    } else {
      pObject->m_pWnd->SetFont(pFont);
    }
  }
}

// Enable/disable CtrlTab for tab window
void TVisualFramework::EnableCtrlTab(BOOL bEnable)
{
  // If framework is used in an MDI application, then Ctrl+Tab is used to switch
  // among open windows. If it is enabled, Ctrl+Tab will then switch among 
  // tab panes within the MDI child frame window (this disables default Ctrl+Tab
  // for MDI windows).
  // Ctrl+Tab works only if CWinApp derived class overloads PreTranslateMessage
  // and calles ProcessMessage() of the active TVisualFramework object
  m_bEnableCtrlTab = bEnable;
}

// Since CSplitterWnd does not support dynamic creation, this is a chance for
// derived class to supply CSplitterWnd derived class instead of CSplitterWnd
CSplitterWnd *TVisualFramework::CreateSplitter(DWORD dwId)
{
  return new CSplitterWnd;
}

// Set focus to visual object 
BOOL TVisualFramework::SetActivePane(TVisualObject *pObject)
{
  ASSERT(pObject);

  // Cannot set focus to splitter or tab window
  if (!pObject->CanFocus())
    return FALSE;

  // Cannot set focus to disabled window
  BOOL bEnabled;
  if (pObject->IsEnabled(bEnabled) && !bEnabled)
    return FALSE;

  // Build a list that walks thru the object hierarchy from specified 
  // object to the root
  TVisualObjectList list;
  TVisualObject *pObj = pObject;
  while (pObj) {
    list.insert(list.end(),pObj);
    pObj = pObj->m_pOwner;
  }
  
  // Reverse the list so that we can walk from root to the desired object
  list.reverse();
  
  // Now, walk thru the list and set focus as desired
  TVisualObjectList::iterator it;
  for (it = list.begin(); it != list.end(); it ++) {
    pObj = *it;
    if (pObj->m_pOwner && pObj->m_pOwner->m_pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
      TTabWnd *pTab = (TTabWnd*)pObj->m_pOwner->m_pWnd;
      int nIndex = pTab->GetTabIndex(pObj->m_pWnd);
      if (!pTab->SetActivePane(nIndex)) 
        return FALSE;
    }
  }

  // Update framework owner
  CFrameWnd *pFrame = (CFrameWnd*)m_pOwner;
  pFrame->SetActiveView((CView*)pObject->m_pWnd);

  return TRUE;
}

// Return a pointer to visual object that represents the currently active pane
TVisualObject *TVisualFramework::GetActivePane(void)
{
  CFrameWnd *pFrame = (CFrameWnd*)m_pOwner;
  ASSERT(pFrame);
  CView *pView = pFrame->GetActiveView();
  ASSERT(pView);
  return findObject(pView);
}

// Enable/disable a view. Returns TRUE if sucessful
BOOL TVisualFramework::Enable(TVisualObject *pObject, BOOL bEnable)
{
  ASSERT(pObject);
  ASSERT(pObject->m_pWnd);

  if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(CView))) {
    pObject->m_bEnabled = bEnable;
    pObject->m_pWnd->EnableWindow(bEnable);
    if (pObject->m_pParent->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
      TTabWnd *pTab = (TTabWnd*)pObject->m_pParent;
      int nIndex = pTab->GetTabIndex(pObject->m_pWnd);
      pTab->Enable(nIndex, bEnable);
    }
    return TRUE;
  }
  return FALSE;
}

// Enable/disable a tab
BOOL TVisualFramework::EnableTab(TVisualObject *pObject, BOOL bEnable)
{
  ASSERT(pObject);
  ASSERT(pObject->m_pWnd);
  ASSERT(pObject->m_pParent);

  // Check if parent is a tab window
  if (pObject->m_pParent->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
    TTabWnd *pTab = (TTabWnd*)pObject->m_pParent;
    int nIndex = pTab->GetTabIndex(pObject->m_pWnd);
    if (nIndex == pTab->GetTabIndex())
      return FALSE;
    pTab->EnableTab(nIndex, bEnable);
    pObject->m_bEnabled = bEnable;
    return TRUE;
  }
  return FALSE;
}

// Show/hide a tab
BOOL TVisualFramework::ShowTab(TVisualObject *pObject, BOOL bShow)
{
  ASSERT(pObject);
  ASSERT(pObject->m_pWnd);
  ASSERT(pObject->m_pParent);

  if (!pObject->m_pParent->IsKindOf(RUNTIME_CLASS(TTabWnd)))
    return FALSE;

  TTabWnd *pTab = (TTabWnd*)pObject->m_pParent;
  int nIndex = pTab->GetTabIndex(pObject->m_pWnd);
  if (nIndex == pTab->GetTabIndex())
    return FALSE;

  pTab->ShowTab(nIndex, bShow);
  return TRUE;
}

// Is object enabled. Returns FALSE if this is not a valid call for the supplied
// object. If return code is TRUE, check bEnabled
BOOL TVisualFramework::IsEnabled(TVisualObject *pObject, BOOL& bEnabled)
{
  ASSERT(pObject);
  ASSERT(pObject->m_pWnd);

  bEnabled = pObject->m_bEnabled;
  return TRUE;
  /*
  if (pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(CView))) {
    bEnabled = pObject->m_pWnd->IsWindowEnabled();
    return TRUE;
  }
  return FALSE;
  */
}

// Is tab enabled. Returns FALSE if this is not a valid call for the supplied
// object. If return code is TRUE, check bEnabled
BOOL TVisualFramework::IsTabEnabled(TVisualObject *pObject, BOOL& bEnabled)
{
  ASSERT(pObject);
  ASSERT(pObject->m_pWnd);
  ASSERT(pObject->m_pParent);

  if (pObject->m_pParent->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
    TTabWnd *pTab = (TTabWnd*)pObject->m_pParent;
    int nIndex = pTab->GetTabIndex(pObject->m_pWnd);
    bEnabled = pTab->IsTabEnabled(nIndex);
    return TRUE;
  }
  return FALSE;
}

// Is tab visible. Returns FALSE if this is not a valid call for the supplied
// object. If return code is TRUE then check bVisible.
BOOL TVisualFramework::IsTabVisible(TVisualObject *pObject, BOOL& bVisible)
{
  ASSERT(pObject);
  ASSERT(pObject->m_pWnd);
  ASSERT(pObject->m_pParent);

  if (pObject->m_pParent->IsKindOf(RUNTIME_CLASS(TTabWnd))) {
    TTabWnd *pTab = (TTabWnd*)pObject->m_pParent;
    int nIndex = pTab->GetTabIndex(pObject->m_pWnd);
    bVisible = pTab->IsTabVisible(nIndex);
    return TRUE;
  }
  return FALSE;
}

// This should be called from CWinApp derived PreTranslateMessage to handle
// any framework related messages
BOOL TVisualFramework::ProcessMessage(MSG *pMsg)
{
  ASSERT(pMsg);
  if (pMsg->message == WM_KEYDOWN) {
    // Handle Ctrl+Tab for tab windows
    if (m_bEnableCtrlTab) {
      if ((pMsg->wParam == VK_TAB) && (::GetAsyncKeyState(VK_CONTROL) != 0)) {
        CWnd *pWnd = CWnd::FromHandle(pMsg->hwnd);
        ASSERT(pWnd);
        if (pWnd->IsKindOf(RUNTIME_CLASS(CFrameWnd)))
          return FALSE;
        // If we are in form view then pWnd is a control
        while (pWnd && !pWnd->IsKindOf(RUNTIME_CLASS(CView)))
          pWnd = pWnd->GetParent();
        // Find object for this window
        ASSERT(pWnd);
        TVisualObject *pObject = findObject(pWnd);
        ASSERT(pObject != NULL);
        while (pObject && !pObject->m_pWnd->IsKindOf(RUNTIME_CLASS(TTabWnd)))
          pObject = pObject->m_pOwner;
        if (pObject) {
          TTabWnd *pTab = (TTabWnd*)pObject->m_pWnd;
          BOOL bShift = (::GetAsyncKeyState(VK_SHIFT) != 0);
          int nIndex = pTab->GetTabIndex();
          int nNdx = nIndex;
          // Switch to new pane (skip invisible and disabled)
          do {
            if (bShift) {
              // Does not work
              nNdx--;
              if (nNdx < 0)
                nNdx = pTab->GetTabCount()-1;
            } else {
              nNdx ++;
              if (nNdx == pTab->GetTabCount())
                nNdx = 0;
            }
          } while (!pTab->SetActivePane(nNdx) && (nNdx != nIndex));
          return TRUE;
        }
      }
    }
  } else if (pMsg->message == WM_SYSKEYDOWN) {
    // Handle hot keys for views (if defined)
    TVisualObject *pObject;
    TVisualObjectMap::iterator mapit;
    for (mapit = m_ObjectMap.begin(); mapit != m_ObjectMap.end(); mapit ++) {
      pObject = mapit->second;
      if (pObject->m_cHotKey == pMsg->wParam) {
        if (SetActivePane(pObject))
          return TRUE;
      }
    }
  }

  return FALSE;
}

BOOL TVisualFramework::OnCmdMsg(UINT nID, int nCode, void* pExtra, 
                             AFX_CMDHANDLERINFO* pHandlerInfo) 
{
	// TODO: Add your specialized code here and/or call the base class
	
	return CCmdTarget::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
}

//=============================================================================
// class TVisualFormView
//
// This class implements the code to set the font for all child controls.
// If it belongs to the visual framework (as a pane) then setting the font
// for the framework's panes will automatically set the font for all child
// controls in the form view.
//=============================================================================

static BOOL __stdcall setChildFont(HWND hwnd, LPARAM lparam);
static BOOL __stdcall setChildEnabled(HWND hwnd, LPARAM lparam);

IMPLEMENT_DYNAMIC(TVisualFormView, CFormView)

BEGIN_MESSAGE_MAP(TVisualFormView, CFormView)
	//{{AFX_MSG_MAP(TVisualFormView)
	ON_WM_ENABLE()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

TVisualFormView::TVisualFormView(LPCTSTR lpszTemplateName)
	: CFormView(lpszTemplateName)
{
}

TVisualFormView::TVisualFormView(UINT nIDTemplate)
	: CFormView(nIDTemplate)
{
}

void TVisualFormView::SetFont(CFont *pFont)
{
  ASSERT(pFont);
  ::EnumChildWindows(m_hWnd, ::setChildFont, (LPARAM)pFont);
}

void TVisualFormView::OnEnable(BOOL bEnable) 
{
	CFormView::OnEnable(bEnable);
  ::EnumChildWindows(m_hWnd, ::setChildEnabled, (LPARAM)bEnable);
}

// lParam is a pointer to CFont object
BOOL __stdcall s