treepropsheetex.cpp

人事管理系统

// TreePropSheetEx.cpp
//
/////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2004 by Yves Tkaczyk
// (http://www.tkaczyk.net - [e-mail])
//
// The contents of this file are subject to the Artistic License (the "License").
// You may not use this file except in compliance with the License. 
// You may obtain a copy of the License at:
// http://www.opensource.org/licenses/artistic-license.html
//
// Documentation: http://www.codeproject.com/property/treepropsheetex.asp
// CVS tree:      http://sourceforge.net/projects/treepropsheetex
//
/////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "TreePropSheetEx.h"
#include "TreePropSheetSplitter.h"
#include "MemDC.h"
#include <stdlib.h>

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

namespace
{
  /*! Initialized size. */
  const CSize kInitializeSize( -1, -1 );
};
namespace TreePropSheet
{

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

IMPLEMENT_DYNCREATE(CTreePropSheetEx, CTreePropSheetBase )

#pragma warning(push)
#pragma warning(4: 4355)

CTreePropSheetEx::CTreePropSheetEx()
 : CTreePropSheetBase()
{
  Init();
}

CTreePropSheetEx::CTreePropSheetEx(UINT nIDCaption,CWnd* pParentWnd /*=NULL*/,UINT iSelectPage /*=0*/)
 : CTreePropSheetBase( nIDCaption, pParentWnd, iSelectPage )
{
  Init();
}

CTreePropSheetEx::CTreePropSheetEx(LPCTSTR pszCaption,CWnd* pParentWnd /*=NULL*/,UINT iSelectPage /*=0*/)
 : CTreePropSheetBase( pszCaption, pParentWnd, iSelectPage )
{
  Init();
}

#pragma warning(pop)

CTreePropSheetEx::~CTreePropSheetEx()
{
}

//////////////////////////////////////////////////////////////////////
// Properties
//////////////////////////////////////////////////////////////////////

bool CTreePropSheetEx::SetIsResizable(const bool bIsResizable)
{
  if( ::IsWindow( m_hWnd ) )
    return false;

	m_bIsResizable = bIsResizable;
  return true;
}

//////////////////////////////////////////////////////////////////////
//
bool CTreePropSheetEx::IsResizable() const
{
	return m_bIsResizable;
}

//////////////////////////////////////////////////////////////////////
//
void CTreePropSheetEx::SetMinSize(const CSize& sizeMin)
{
  ASSERT( m_bIsResizable );
	m_sizeSheetMinimumSize = sizeMin;

  // If the window exists, update it.
  UpdateSheetMinimumSize();
}

//////////////////////////////////////////////////////////////////////
//
CSize CTreePropSheetEx::GetMinSize() const
{
	return m_sizeSheetMinimumSize;
}

//////////////////////////////////////////////////////////////////////
//
void CTreePropSheetEx::SetMaxSize(const CSize& sizeMax)
{
  ASSERT( m_bIsResizable );
	m_sizeSheetMaximumSize = sizeMax;

  // If the window exists, update it.
  UpdateSheetMaximumSize();
}

//////////////////////////////////////////////////////////////////////
//
CSize CTreePropSheetEx::GetMaxSize() const
{
	return m_sizeSheetMaximumSize;
}

//////////////////////////////////////////////////////////////////////
//
bool CTreePropSheetEx::SetPaneMinimumSize(const int nPaneMinimumSize)
{
  ASSERT( nPaneMinimumSize >= 0 );

  if( ::IsWindow( m_hWnd ) )
    return false;

  m_nTreeMinimumSize = nPaneMinimumSize;
  m_nFrameMinimumSize = nPaneMinimumSize;

  return true;
}

//////////////////////////////////////////////////////////////////////
//
int CTreePropSheetEx::GetPaneMinimumSize() const
{
  if( m_nTreeMinimumSize != m_nFrameMinimumSize )
    return -1;

	return m_nFrameMinimumSize;
}

//////////////////////////////////////////////////////////////////////
//
bool CTreePropSheetEx::SetPaneMinimumSizes(const int nTreeMinimumSize,const int nFrameMinimumSize)
{
  ASSERT( nTreeMinimumSize >= 0 );
  ASSERT( nFrameMinimumSize >= 0 );

  if( ::IsWindow( m_hWnd ) )
    return false;

  m_nTreeMinimumSize = nTreeMinimumSize;
  m_nFrameMinimumSize = nFrameMinimumSize;
  return true;
}

//////////////////////////////////////////////////////////////////////
//
void CTreePropSheetEx::GetPaneMinimumSizes(int& nTreeMinimumSize,int& nFrameMinimumSize) const
{
  nTreeMinimumSize = m_nTreeMinimumSize;
  nFrameMinimumSize = m_nFrameMinimumSize;
}

//////////////////////////////////////////////////////////////////////
//
void CTreePropSheetEx::SetTreeIsResizable(const bool bIsTreeResizable)
{
	m_bIsTreeResizable = bIsTreeResizable;

  // If the splitter exists, update it.
  if( ::IsWindow( m_hWnd ) && NULL != m_pSplitter.get() )
  {
    m_pSplitter->SetAllowUserResizing( m_bIsTreeResizable );
  }
}

//////////////////////////////////////////////////////////////////////
//
bool CTreePropSheetEx::IsTreeResizable() const
{
	return m_bIsTreeResizable;
}

//////////////////////////////////////////////////////////////////////
//
bool CTreePropSheetEx::SetSplitterWidth(const int nSplitterWidth)
{
  ASSERT( m_nSplitterWidth >= 1 );
	if( ::IsWindow( m_hWnd ) ) 
    return false;

  m_nSplitterWidth = nSplitterWidth;
  return true;
}

//////////////////////////////////////////////////////////////////////
//
int CTreePropSheetEx::GetSplitterWidth() const
{
	return m_nSplitterWidth;
}

//////////////////////////////////////////////////////////////////////
//
void CTreePropSheetEx::SetTreeResizingMode(const enTreeSizingMode eSizingMode)
{
  ASSERT( eSizingMode == TSM_Fixed || eSizingMode == TSM_Proportional );

	// Store the tree sizing mode.
  m_eSizingMode = eSizingMode;
  
  // Update the splitter if it exists.
  if( m_pSplitter.get() )
  {
    const bool vert_splitter_frozen[2] = { m_eSizingMode==TSM_Fixed?true:false, false };
    m_pSplitter->SetFrozenPanes( vert_splitter_frozen );
  }
}

//////////////////////////////////////////////////////////////////////
//
enTreeSizingMode CTreePropSheetEx::GetTreeResizingMode() const
{
	return m_eSizingMode;
}

//////////////////////////////////////////////////////////////////////
//
CTreePropSheetEx::tSplitter* CTreePropSheetEx::GetSplitterObject() const
{
	return m_pSplitter.get();
}

//////////////////////////////////////////////////////////////////////
//
CWnd* CTreePropSheetEx::GetSplitterWnd() const
{
	return static_cast<CWnd*>( m_pSplitter.get() );
}

//////////////////////////////////////////////////////////////////////
//
void CTreePropSheetEx::SetContextMenuMode(const TreePropSheet::enContextMenuMode eContextMenuMode)
{
  m_eContextMenuMode = eContextMenuMode;
}

//////////////////////////////////////////////////////////////////////
//
TreePropSheet::enContextMenuMode CTreePropSheetEx::GetContextMenuMode() const
{
	return m_eContextMenuMode; 
}

//////////////////////////////////////////////////////////////////////
//
void CTreePropSheetEx::SetRealTimeSplitter(const bool bRealtime)
{
	m_bIsRealtimeSplitterMode = bRealtime;

  // Update the splitter if it exists.
  if( m_pSplitter.get() )