resizectrl.cpp

界面编程的一些实现方法打包,VC中实现,比较新颖,大家

// ResizeCtrl.cpp: implementation of the CResizeCtrl class.
//
//
// Written by Herbert Menke ([e-mail])
// Copyright (c) 2000.
//
// This code may be used in compiled form in any way you desire. This
// file may be redistributed unmodified by any means PROVIDING it is 
// not sold for profit without the authors written consent, and 
// providing that this notice and the authors name is included. If 
// the source code in  this file is used in any commercial application 
// then acknowledgement must be made to the author of this file 
// (in whatever form you wish).
//
// This file is provided "as is" with no expressed or implied warranty.
//
// Expect bugs.
// 
// Please use and enjoy. Please let me know of any bugs/mods/improvements 
// that you have found/implemented and I will fix/incorporate them into this
// file. 
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "ResizeCtrl.h"
#ifndef __AFXTEMPL_H__
 #include <afxtempl.H>
#endif


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

// Specification struct
struct RSRect
{
  int left;   // Specifies the percentage change in the position of the left edge 
              // of the object relative to the total change in the parent form抯 width. 
  int top;    // Specifies the percentage change in the position of the top 
              // of the object relative to the total change in the parent form抯 height.
  int width;  // Specifies the percentage change in the width of the object 
              // relative to the total change in the parent form抯 width.
  int height; // Specifies the percentage change in the height of the object 
              // relative to the total change in the parent form抯 height.
};


struct CRPItemState
{
  HWND   handle;    // Handle of Control
  RSRect pending;   // pending Resize pixels
  RSRect part;      // resize specifications
};

class CResizeArray : public CArray<CRPItemState,CRPItemState> { };

static const char m_szResizeProperty[] = "___CResizeCtrl___Class___";

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

CResizeCtrl::CResizeCtrl( )
: m_array       ( NULL  )
, m_hWndParent  ( NULL  )
, m_maxPart     ( 100   )
, m_inResize    ( FALSE )
, m_prevWndProc ( NULL  )
, m_enabled     ( FALSE )
, m_minTracking ( CSize( -1, -1 ) )
, m_maxTracking ( CSize( -1, -1 ) )
, m_hitCode     ( 0 )
, m_inMouseMove ( FALSE )
, m_delta       ( CSize( 0, 0 ) )
, m_windowRect  ( CRect( 0, 0, 0, 0 ) )
, m_gripEnabled ( FALSE )
{
}

CResizeCtrl::CResizeCtrl( HWND hWndParent, BOOL enable, int maxPart )
: m_array( NULL )
, m_hWndParent  ( NULL  )
, m_maxPart     ( 100   )
, m_inResize    ( FALSE )
, m_prevWndProc ( NULL  )
, m_enabled     ( FALSE )
, m_minTracking ( CSize( -1, -1 ) )
, m_maxTracking ( CSize( -1, -1 ) )
, m_hitCode     ( 0 )
, m_inMouseMove ( FALSE )
, m_delta       ( CSize( 0, 0 ) )
, m_gripEnabled ( FALSE )
{
  Create( hWndParent, enable, maxPart );

}

CResizeCtrl::CResizeCtrl( CWnd * wndParent, BOOL enable, int maxPart )
: m_array       ( NULL  )
, m_hWndParent  ( NULL  )
, m_maxPart     ( 100   )
, m_inResize    ( FALSE )
, m_prevWndProc ( NULL  )
, m_enabled     ( FALSE )
, m_minTracking ( CSize( -1, -1 ) )
, m_maxTracking ( CSize( -1, -1 ) )
, m_hitCode     ( 0 )
, m_inMouseMove ( FALSE )
, m_delta       ( CSize( 0, 0 ) )
, m_gripEnabled ( FALSE )
{
  Create( wndParent, enable, maxPart );
}

CResizeCtrl::~CResizeCtrl()
{
  SetEnabled( FALSE );
  m_array->RemoveAll();
  delete m_array;
}

BOOL CResizeCtrl::Create( CWnd * wndParent, BOOL enable, int maxPart )
{
  ASSERT( wndParent );
  if( wndParent )
    return Create( wndParent->GetSafeHwnd(), enable, maxPart );
  return FALSE;
}

BOOL CResizeCtrl::Create( HWND hWndParent, BOOL enable, int maxPart )
{
  ASSERT( !m_array );
  if( m_array )
    return FALSE;

  m_array = new CResizeArray;
  ASSERT( m_array );
  ASSERT( hWndParent );
  ASSERT( maxPart > 0 );
  m_hWndParent  = hWndParent;
  m_maxPart     = maxPart;
  m_inResize    = FALSE;
  m_prevWndProc = NULL;
  m_enabled     = FALSE;
  m_minTracking.cx  =
  m_minTracking.cy  =
  m_maxTracking.cx  =
  m_maxTracking.cy  = -1;
  m_hasResizingBorder = (::GetWindowLong( hWndParent, GWL_STYLE ) & WS_THICKFRAME ) == WS_THICKFRAME;
  if( enable )
    SetEnabled( TRUE );
  else
    ::GetWindowRect( hWndParent , &m_windowRect );
  return TRUE;
}



//
// Enabled Property
//

BOOL CResizeCtrl::SetEnabled( BOOL enable )
{
  ASSERT ( m_array );

  if( m_enabled != enable )
  {
    ASSERT( m_hWndParent  );
    ::GetWindowRect( m_hWndParent, &m_windowRect );
    // remove subclassing
    if( FALSE == enable )
    {
      ASSERT( m_prevWndProc );
      ::SetWindowLong( m_hWndParent, GWL_WNDPROC, reinterpret_cast<LONG>( m_prevWndProc ) );
      m_prevWndProc = NULL;
      ::RemoveProp( m_hWndParent, m_szResizeProperty );
      if( m_hasResizingBorder == FALSE )
        ChangeStyle( enable );  
    }
    else
    {
      m_hitCode       = 0;
      m_delta.cx      =
      m_delta.cy      = 0;
      m_inResize      = 
      m_inMouseMove   = FALSE;
      //m_hWndFocus     = NULL;

      WNDPROC wndProc = CResizeCtrl::WndProc;
      if( m_hasResizingBorder == FALSE )
      {
        ChangeStyle( enable );  
      }
      CRect   rect;
      ::GetClientRect( m_hWndParent, &rect );
      m_size.cx = rect.Width();
      m_size.cy = rect.Height();

      ::SetProp( m_hWndParent, m_szResizeProperty, reinterpret_cast<HANDLE>(this) );
      m_prevWndProc = reinterpret_cast<WNDPROC>( ::GetWindowLong( m_hWndParent, GWL_WNDPROC ) );
      ::SetWindowLong( m_hWndParent, GWL_WNDPROC, reinterpret_cast<LONG>( wndProc ) );
    }
    m_enabled = enable;
    if( m_gripEnabled )
    {
      GetGripRect( m_gripRect, TRUE );
    }
    return TRUE;
  }
  return FALSE;
}
BOOL CResizeCtrl::GetEnabled() const
{
  return m_enabled;
}

//
// GripEnabled Property
//

BOOL CResizeCtrl::SetGripEnabled( BOOL showGrip )
{
  if( m_gripEnabled != showGrip )
  {
    m_gripEnabled = showGrip;
    if( m_enabled )
      GetGripRect( m_gripRect, TRUE );
  }
  return FALSE;
}
BOOL CResizeCtrl::GetGripEnabled() const
{
  return m_gripEnabled;
}

// resizeInfo is a null terminated array of CResizeInfo

BOOL CResizeCtrl::Add( const CResizeInfo * resizeInfo )
{
  ASSERT ( m_array );

  BOOL result = TRUE;
  while( result == TRUE && resizeInfo->ctlID > 0 )
  {
    result &= Add( resizeInfo->ctlID,
                   resizeInfo->left,
                   resizeInfo->top,
                   resizeInfo->width,
                   resizeInfo->height );
    resizeInfo++;               
  }
  return result;
}

BOOL CResizeCtrl::Add( int ctlID,  int left, int top, int width, int height )
{
  ASSERT ( m_array );

  return Add( ::GetDlgItem( m_hWndParent, ctlID), left, top, width, height );
}

BOOL CResizeCtrl::Add( CWnd * wndCtl, int left, int top, int width, int height )
{
  ASSERT ( m_array );

  if( wndCtl )
    return Add( wndCtl->GetSafeHwnd(), left, top, width, height );
  return FALSE;

}

BOOL CResizeCtrl::Add(HWND hWndCtl, int left, int top, int width, int height)
{
  ASSERT ( m_array );

  if( left < 0 || left > m_maxPart )
  {
    return FALSE;
  }
  if( top < 0 || top > m_maxPart )
  {
    return FALSE;
  }
  if( width < 0 || width > m_maxPart )
  {
    return FALSE;
  }
  if( height < 0 || height > m_maxPart )
  {
    return FALSE;
  }

  if( ( left + width ) > m_maxPart )
  {
    return FALSE;
  }
  if( ( top + height) > m_maxPart )
  {
    return FALSE;
  }

  if( !::IsWindow( hWndCtl))
    return FALSE;

  CRPItemState item;

  item.part.left   = left;
  item.part.top    = top;
  item.part.width  = width;
  item.part.height = height;
  item.pending.left   =
  item.pending.top    =
  item.pending.width  =
  item.pending.height = 0;
  item.handle         = hWndCtl;

  return m_array->Add( item ) >= 0 ;
}

BOOL CResizeCtrl::Remove( int ctlID )
{
  ASSERT ( m_array );

  return Remove( ::GetDlgItem( m_hWndParent, ctlID ) );
}

BOOL CResizeCtrl::Remove( CWnd * wndCtl )
{
  ASSERT ( m_array );

  if( wndCtl )
    return Remove( wndCtl->GetSafeHwnd () );
  return FALSE;  
}

BOOL CResizeCtrl::Remove(HWND hWndCtl)
{
  ASSERT ( m_array );

  if( !::IsWindow( hWndCtl))
    return FALSE;

  int upperBound = m_array->GetUpperBound ();
  for( int current = 0; current <= upperBound; current++ )
  {