treepropsheetresizablelibhook.cpp

人事管理系统

	m_bSavePage = FALSE;
	m_dwGripTempState = 1;
}

void CResizableSheetHook::SavePage()
{
	if (!m_bSavePage)
		return;

	// saves active page index, zero (the first) if problems
	// cannot use GetActivePage, because it always fails

	CTabCtrl *pTab = m_pSheet->GetTabControl();
	int page = 0;

	if (pTab != NULL) 
		page = pTab->GetCurSel();
	if (page < 0)
		page = 0;

	AfxGetApp()->WriteProfileInt(m_sSection, ACTIVEPAGE, page);
}

void CResizableSheetHook::LoadPage()
{
	// restore active page, zero (the first) if not found
	int page = AfxGetApp()->GetProfileInt(m_sSection, ACTIVEPAGE, 0);
	
	if (m_bSavePage)
	{
		m_pSheet->SetActivePage(page);
		ArrangeLayout();	// needs refresh
	}
}

BOOL CResizableSheetHook::IsWizard()
{
  return (m_pSheet->m_psh.dwFlags & PSH_WIZARD); 
}

void CResizableSheetHook::EnableSaveRestore(LPCTSTR pszSection,BOOL bRectOnly /*=FALSE*/,BOOL bWithPage /*=FALSE*/)
{
	m_sSection = pszSection;
	m_bSavePage = bWithPage;

	m_bEnableSaveRestore = TRUE;
	m_bRectOnly = bRectOnly;

	// restore immediately
	LoadWindowRect(pszSection, bRectOnly);
	LoadPage();
}

int CResizableSheetHook::GetMinWidth()
{
	CWnd* pWnd = NULL;
	CRect rectWnd, rectSheet;
	GetTotalClientRect(&rectSheet);

	int max = 0, min = rectSheet.Width();
	// search for leftmost and rightmost button margins
	for (int i = 0; i < 7; i++)
	{
		pWnd = m_pSheet->GetDlgItem(_propButtons[i]);
		// exclude not present or hidden buttons
		if (pWnd == NULL || !(pWnd->GetStyle() & WS_VISIBLE))
			continue;

		// left position is relative to the right border
		// of the parent window (negative value)
		pWnd->GetWindowRect(&rectWnd);
		::MapWindowPoints(NULL, m_pSheet->GetSafeHwnd(), (LPPOINT)&rectWnd, 2);
		int left = rectSheet.right - rectWnd.left;
		int right = rectSheet.right - rectWnd.right;

		if (left > max)
			max = left;
		if (right < min)
			min = right;
	}

	// sizing border width
	int border = GetSystemMetrics(SM_CXSIZEFRAME);
	
	// compute total width
	return max + min + 2*border;
}

//********************************************************************
// CTreePropSheetResizableLibHook
//********************************************************************

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CTreePropSheetResizableLibHook::CTreePropSheetResizableLibHook(TreePropSheet::CTreePropSheetEx* pTreePropSheet)
 : CResizableSheetHook(pTreePropSheet),
   m_pTreePropSheet(pTreePropSheet)
{
}

CTreePropSheetResizableLibHook::~CTreePropSheetResizableLibHook()
{
}

//////////////////////////////////////////////////////////////////////
// Overridable
//////////////////////////////////////////////////////////////////////

void CTreePropSheetResizableLibHook::PresetLayout()
{
	/* If in tree mode, register the tree and the frame with the layout manager. */
  if( m_pTreePropSheet->IsTreeViewMode() )      // Tree mode
  {
  	m_pTreePropSheet->GetPageTreeControl()->ModifyStyle(0, WS_CLIPSIBLINGS);
	  m_pTreePropSheet->GetFrameControl()->GetWnd()->ModifyStyle(0, WS_CLIPSIBLINGS);
    AddAnchor( m_pTreePropSheet->GetSplitterWnd()->GetSafeHwnd(), TOP_LEFT, BOTTOM_RIGHT );
    // Save the margin between the frame and the current page. This rect should NOT be normalized.
    CRect rectFrame, rectPage;
    ::GetWindowRect( m_pTreePropSheet->GetFrameControl()->GetWnd()->GetSafeHwnd(), &rectFrame );
    ::GetWindowRect( m_pTreePropSheet->GetActivePage()->GetSafeHwnd(), &rectPage );
    m_rectFramePageMargins.SetRect( rectPage.left - rectFrame.left,
                                    rectPage.top - rectFrame.top,
                                    rectFrame.right - rectPage.right,
                                    rectFrame.bottom - rectPage.bottom );
  	AddAnchorCallback(1);   // Callback for frame
	  AddAnchorCallback(2);   // Callback for page
  }
  else
  {
    if (IsWizard())	                        // wizard mode
	  {
		  // hide tab control
		  m_pSheet->GetTabControl()->ShowWindow(SW_HIDE);

		  AddAnchor(ID_WIZLINE, BOTTOM_LEFT, BOTTOM_RIGHT);
	  }
	  else	                                        // tab mode
	  {
		  AddAnchor(AFX_IDC_TAB_CONTROL, TOP_LEFT, BOTTOM_RIGHT);
	  }

	  // add a callback for active page (which can change at run-time)
	  AddAnchorCallback(1);
  }

	// use *total* parent size to have correct margins
	CRect rectPage, rectSheet;
	GetTotalClientRect(&rectSheet);

	m_pSheet->GetActivePage()->GetWindowRect(&rectPage);
	::MapWindowPoints(NULL, m_pSheet->GetSafeHwnd(), (LPPOINT)&rectPage, 2);

	// pre-calculate margins
	m_sizePageTL = rectPage.TopLeft() - rectSheet.TopLeft();
	m_sizePageBR = rectPage.BottomRight() - rectSheet.BottomRight();

	// add all possible buttons, if they exist
  for (int i = 0; i < _propButtonsCount; i++)
	{
    if (NULL != m_pSheet->GetDlgItem(_propButtons[i]))
      AddAnchor(_propButtons[i], BOTTOM_RIGHT);
	}
}

//////////////////////////////////////////////////////////////////////
//
BOOL CTreePropSheetResizableLibHook::ArrangeLayoutCallback(LayoutInfo &layout)
{
	// Handle the tree callbacks in another methods.
  if( m_pTreePropSheet->IsTreeViewMode() )    // Tree mode
  {
    return TreeModeCallbacks( layout );
  }

	if (layout.nCallbackID != 1)	// we only added 1 callback
		return CResizableSheetHook::ArrangeLayoutCallback(layout);

	// set layout info for active page
	layout.hWnd = (HWND)::SendMessage( m_pSheet->GetSafeHwnd(), PSM_GETCURRENTPAGEHWND, 0, 0);
	if (!::IsWindow(layout.hWnd))
		return FALSE;

	if( m_pTreePropSheet->IsWizard() )	   // wizard mode
	{
		// use pre-calculated margins
		layout.sizeMarginTL = m_sizePageTL;
		layout.sizeMarginBR = m_sizePageBR;
	}
	else	                                 // tab mode
	{
		CTabCtrl* pTab = m_pSheet->GetTabControl();
		ASSERT(pTab != NULL);

		// get tab position after resizing and calc page rect
		CRect rectPage, rectSheet;
		GetTotalClientRect(&rectSheet);

		VERIFY(GetAnchorPosition(pTab->m_hWnd, rectSheet, rectPage));
		pTab->AdjustRect(FALSE, &rectPage);

		// set margins
		layout.sizeMarginTL = rectPage.TopLeft() - rectSheet.TopLeft();
		layout.sizeMarginBR = rectPage.BottomRight() - rectSheet.BottomRight();
	}

	// set anchor types
	layout.sizeTypeTL = TOP_LEFT;
	layout.sizeTypeBR = BOTTOM_RIGHT;

	// use this layout info
	return TRUE;
}

BOOL CTreePropSheetResizableLibHook::TreeModeCallbacks(LayoutInfo &layout)
{
	ASSERT( m_pTreePropSheet->IsTreeViewMode() );

  if (layout.nCallbackID != 1 && layout.nCallbackID != 2)	// we only added 1 callback
		return CResizableSheetHook::ArrangeLayoutCallback(layout);

  /* Callbacks:
      1: Tab
      2: Page */

  CWnd* pFrame = m_pTreePropSheet->GetFrameControl()->GetWnd();
  ASSERT( pFrame );
  CRect rectSheet, rectFrame;
  m_pTreePropSheet->GetClientRect( &rectSheet );
	pFrame->GetWindowRect(&rectFrame);
  m_pTreePropSheet->ScreenToClient(&rectFrame);

  if( layout.nCallbackID == 1 )
  { // Tab control
    // Need to set the tab and page according to the frame. Since this 
    // is resized by 'anchors', it is guaranteed to be already resized 
    // properly.
    layout.hWnd = m_pTreePropSheet->GetTabControl()->GetSafeHwnd();
    
	  layout.sizeTypeTL = TOP_LEFT;
	  layout.sizeTypeBR = BOTTOM_RIGHT;

		// set margins
		layout.sizeMarginTL = rectFrame.TopLeft() - rectSheet.TopLeft();
		layout.sizeMarginBR = rectFrame.BottomRight() - rectSheet.BottomRight();

    ::MoveWindow( layout.hWnd, rectFrame.left, rectFrame.top, rectFrame.Width(), rectFrame.Height(), FALSE );
  }
  else
  { // Page
	  // set layout info for active page
	  layout.hWnd = (HWND)::SendMessage( m_pSheet->GetSafeHwnd(), PSM_GETCURRENTPAGEHWND, 0, 0);
	  if (!::IsWindow(layout.hWnd))
		  return FALSE;

	  layout.sizeTypeTL = TOP_LEFT;
	  layout.sizeTypeBR = BOTTOM_RIGHT;
    rectFrame.DeflateRect( m_rectFramePageMargins );

		// set margins
		layout.sizeMarginTL = rectFrame.TopLeft() - rectSheet.TopLeft();
		layout.sizeMarginBR = rectFrame.BottomRight() - rectSheet.BottomRight();

    ::MoveWindow( layout.hWnd, rectFrame.left, rectFrame.top, rectFrame.Width(), rectFrame.Height(), FALSE );
  }
  return TRUE;
}

};