ngresizectrl.cpp

ResOrg 图形化管理Vc项目的资源ID的工具的源代码。 ResOrg - Manage and Renumber Resource Symbol IDs Introduction The

					changed |= CalcValue( deltaY, items->part.top,    items->pending.top,    rcItem.top,    FALSE );
					changed |= CalcValue( deltaY, items->part.height, items->pending.height, rcItem.bottom, TRUE );
					
					if( changed )
					{
						hdwp = ::DeferWindowPos( hdwp, items->handle, NULL,
							rcItem.left, rcItem.top,
							rcItem.right, rcItem.bottom, flags	);
					}
					
				}
				//      TRACE( "%08d End   Resize hwnd: 0x%8.8x Flags: 0x%8.8x\n", count, m_hWndParent, flags );
				::EndDeferWindowPos( hdwp );
				m_size.cx = cx;
				m_size.cy = cy;
			}
		}
		m_inResize = FALSE;
	}
}


LRESULT CALLBACK CNGResizeCtrl::WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	LRESULT result = 0;
	CNGResizeCtrl * This = reinterpret_cast<CNGResizeCtrl *>(::GetProp( hWnd, m_szResizeProperty ));
	if( This )
	{
		WNDPROC prevWndProc = This->m_prevWndProc;
		if( FALSE == This->ProcessMessage( msg, wParam, lParam, result ) )
			result =  ::CallWindowProc( prevWndProc, hWnd, msg, wParam, lParam );
	}
	return result;
}



void CNGResizeCtrl::ChangeStyle(BOOL enable)
{
	ASSERT( m_hWndParent );
	ASSERT( m_hasResizingBorder == FALSE );
	CRect rect;
	
	BOOL hasMenu = ::GetMenu( m_hWndParent ) != NULL;
	long style   = ::GetWindowLong( m_hWndParent, GWL_STYLE );
	::GetWindowRect( m_hWndParent, &rect );
	
	// retrieve client Rectangle
	RECT oldClientRect;
	::GetClientRect( m_hWndParent, &oldClientRect );
	RECT newClientRect = oldClientRect;
	
	// adjust rect with current style
	::AdjustWindowRect( &oldClientRect, style, hasMenu );
	
	if( enable )
	{
		style |= WS_THICKFRAME;
	}
	else
	{
		style &= ~WS_THICKFRAME;
	}
	
	// adjust rect with new style
	::AdjustWindowRect( &newClientRect, style, hasMenu );
	
	// and adjust the windowrect, so that the clientrect remains equal
	rect.left   += ( newClientRect.left   - oldClientRect.left );
	rect.right  += ( newClientRect.right  - oldClientRect.right );
	rect.top    += ( newClientRect.top    - oldClientRect.top   );
	rect.bottom += ( newClientRect.bottom - oldClientRect.bottom );
	
	::SetWindowLong( m_hWndParent, GWL_STYLE, style );
	::SetWindowPos ( m_hWndParent, HWND_DESKTOP, rect.left, rect.top, rect.Width(), rect.Height(),
		SWP_NOZORDER | SWP_NOACTIVATE  );
	
}

BOOL CNGResizeCtrl::ProcessMessage(UINT message, WPARAM wParam, LPARAM lParam, LRESULT & result)
{
	BOOL handled = FALSE;
	if( message == m_idGetResizeCtrl )
	{
		result  = reinterpret_cast<LRESULT>( this);
		handled = TRUE;
	}
	else if( m_gripEnabled && WM_NCHITTEST == message )
	{
		POINT pt = { (int)LOWORD(lParam), (int)HIWORD(lParam) };
		::ScreenToClient( m_hWndParent, &pt);
		if( ::PtInRect ( m_gripRect, pt ) )
		{
			result  = HTBOTTOMRIGHT;
			handled = TRUE;
		}
	}
	else if( m_gripEnabled && WM_PAINT == message )
	{
		// First let the previous windowproc handle the WM_SIZE message
		result = ::CallWindowProc( m_prevWndProc, m_hWndParent, message, wParam, lParam );
		HDC hDC = ::GetDC( m_hWndParent );
		DrawFrameControl(hDC, &m_gripRect, DFC_SCROLL, DFCS_SCROLLSIZEGRIP);
		::ReleaseDC( m_hWndParent, hDC ); 
		// flag message handled
		handled = TRUE;
	}
	else if( WM_DESTROY == message )
	{
		// Remove subclassing
		SetEnabled( FALSE );
	}
	else if( WM_SIZE == message )
	{
		// First let the previous windowproc handle the WM_SIZE message
		result = ::CallWindowProc( m_prevWndProc, m_hWndParent, message, wParam, lParam );
		// resize all registered controls
		Resize( (int)LOWORD(lParam) , (int)HIWORD(lParam) );
		if( m_gripEnabled )
		{
			::InvalidateRect( m_hWndParent, m_gripRect, TRUE );
			GetGripRect( m_gripRect, TRUE );
		}
		// flag message handled
		handled = TRUE;
	}
	else if( WM_GETMINMAXINFO == message )
	{
		// First let the previous windowproc handle the WM_GETMINMAXINFO message
		result = ::CallWindowProc( m_prevWndProc, m_hWndParent, message, wParam, lParam );
		MINMAXINFO * lpMMI = (MINMAXINFO * )lParam;
		if( m_minTracking.cx == -1 )
			m_minTracking.cx = lpMMI->ptMinTrackSize.x;
		
		if( m_minTracking.cy == -1 )
			m_minTracking.cy = lpMMI->ptMinTrackSize.y;
		
		if( m_maxTracking.cx == -1 )
			m_maxTracking.cx = lpMMI->ptMaxTrackSize.x;
		
		if( m_maxTracking.cy == -1 )
			m_maxTracking.cy = lpMMI->ptMaxTrackSize.y;
		
		lpMMI->ptMinTrackSize.x = m_minTracking.cx;
		lpMMI->ptMinTrackSize.y = m_minTracking.cy;
		lpMMI->ptMaxTrackSize.x = m_maxTracking.cx;
		lpMMI->ptMaxTrackSize.y = m_maxTracking.cy;
		// flag message handled
		handled = TRUE;
	}
	else
	{
		// if the original window had no resizing border
		// we must serve WM_MOUSE, WM_NCLBUTTONDOWN and
		// WM_LBUTTONUP to enable resizing
		if( !m_hasResizingBorder )
		{
			POINT mousePostion;
			RECT  currentRect;
			
			if( WM_MOUSEMOVE == message )
			{
				if (m_hitCode && !m_inMouseMove )
				{
					m_inMouseMove = TRUE;
					
					::GetCursorPos( &mousePostion );
					mousePostion.x += m_delta.cx;
					mousePostion.y += m_delta.cy;
					
					RECT  m_previsionRect;
					
					::GetWindowRect( m_hWndParent, &currentRect );
					m_previsionRect = currentRect;
					
					switch( m_hitCode )
					{
					case HTTOPLEFT     : currentRect.left   = mousePostion.x; // fall through
					case HTTOP         : currentRect.top    = mousePostion.y;	break;
						
					case HTBOTTOMRIGHT : currentRect.right  = mousePostion.x; // fall through
					case HTBOTTOM      : currentRect.bottom = mousePostion.y; break;
						
					case HTBOTTOMLEFT  : currentRect.bottom = mousePostion.y; // fall through
					case HTLEFT        : currentRect.left   = mousePostion.x;	break;
						
					case HTTOPRIGHT    : currentRect.top    = mousePostion.y; // fall through
					case HTRIGHT       : currentRect.right  = mousePostion.x;	break;
					}
					if (!::EqualRect( &currentRect, &m_previsionRect ))
					{
						int width  = currentRect.right - currentRect.left;
						int height = currentRect.bottom - currentRect.top;
						
						::SetWindowPos( m_hWndParent, HWND_DESKTOP, currentRect.left, currentRect.top,	
                            width, height, SWP_NOZORDER | SWP_NOACTIVATE );
					}
					m_inMouseMove = FALSE;
				}
			}
			else if( WM_NCLBUTTONDOWN == message )
			{
				::GetCursorPos( &mousePostion );
				::GetWindowRect( m_hWndParent, &currentRect );
				
				m_hitCode  = wParam;
				m_delta.cx = 
					m_delta.cy = 0;
				
				switch( m_hitCode )
				{
				case HTTOPLEFT     : m_delta.cx = currentRect.left   - mousePostion.x; // fall through
				case HTTOP         : m_delta.cy = currentRect.top    - mousePostion.y; break;
					
				case HTBOTTOMRIGHT : m_delta.cx = currentRect.right  - mousePostion.x; // fall through
				case HTBOTTOM      : m_delta.cy = currentRect.bottom - mousePostion.y; break;
					
				case HTBOTTOMLEFT  : m_delta.cy = currentRect.bottom - mousePostion.y; // fall through
				case HTLEFT        : m_delta.cx = currentRect.left   - mousePostion.x; break;
					
				case HTTOPRIGHT    : m_delta.cy = currentRect.top    - mousePostion.y; // fall through
				case HTRIGHT       : m_delta.cx = currentRect.right  - mousePostion.x; break;
					
				default            : m_hitCode = 0; break;
				}
				
				if (m_hitCode)
				{
					::SetCapture( m_hWndParent );
				}
				
			}
			else if( WM_LBUTTONUP == message )
			{
				if (m_hitCode != 0)
				{
					::ReleaseCapture();
					m_hitCode   = 0;
				}
			}
		}
	}
	return handled;
}
///////////////////////////////////////////////////////////////////////
// MinMaxInfo Support

BOOL  CNGResizeCtrl::SetMinimumTrackingSize( const CSize & size )
{
	m_minTracking = size;
	return TRUE;
}
BOOL  CNGResizeCtrl::SetMinimumTrackingSize()
{
	RECT  rect;
	::GetWindowRect( m_hWndParent, &rect );
	return SetMinimumTrackingSize( CSize( rect.right - rect.left, rect.bottom - rect.top ) );
}
CSize CNGResizeCtrl::GetMinimumTrackingSize( )
{
	return m_minTracking;
}

BOOL  CNGResizeCtrl::SetMaximumTrackingSize( const CSize & size )
{
	m_maxTracking = size;
	return TRUE;
}
CSize CNGResizeCtrl::GetMaximumTrackingSize( )
{
	return m_maxTracking;
}


void CNGResizeCtrl::GetGripRect(RECT & rect, BOOL redraw)
{
	GetClientRect( m_hWndParent, &rect );
	rect.left = rect.right  - ::GetSystemMetrics(SM_CXVSCROLL) ;
	rect.top  = rect.bottom - ::GetSystemMetrics(SM_CYHSCROLL) ;
	if( redraw )
		::InvalidateRect( m_hWndParent, &rect, TRUE );
}

//
// Support for CPropertyPage
//

CNGResizeCtrl * CNGResizeCtrl::GetResizeCtrl( CWnd * wnd )
{
	if( wnd )
		return GetResizeCtrl( wnd->GetSafeHwnd() );
	else
		return NULL;
}
CNGResizeCtrl * CNGResizeCtrl::GetResizeCtrl( HWND hWnd )
{
	if( ::IsWindow( hWnd ) )
	{
		return reinterpret_cast<CNGResizeCtrl*>( ::SendMessage( hWnd, m_idGetResizeCtrl, 0, 0 ) );
	}
	else
		return NULL;
}

//
// Support for CPropertySheet and Wizard
//

// Prepares the propertysheet to ensure that
// all pages are created , should be called
// before the control is enabled 
BOOL CNGResizeCtrl::PropertySheetPrepare( CPropertySheet * sheet )
{
	if( GetEnabled() == FALSE && sheet )
	{
		int count        = sheet->GetPageCount();
		int selectedPage = sheet->GetActiveIndex();

		// Activated all pages except the current active page
		// this ensures, that all pages are created
		for( int currentPage = 0; currentPage < count; currentPage++ )
		{
			if( currentPage != selectedPage )
			{
				sheet->SetActivePage(currentPage );
			}
		}
		// reselect the active page
		if (sheet->GetPageIndex( sheet->GetActivePage() ) != selectedPage)
		{
			sheet->SetActivePage(selectedPage);
		}
		return count > 0 ;
	}
	return FALSE;
}

// Adds the buttons of PropertySheet or Wizard
BOOL CNGResizeCtrl::PropertySheetAddButtons( CPropertySheet * sheet, int left, int top, int width, int height )
{
	if( sheet )
	{
		HWND hWnd = sheet->GetSafeHwnd();
		BOOL ok = TRUE;
		if( sheet->IsWizard() )
		{
			// Add Next/Prev...
			ok &= Add( ::GetDlgItem( hWnd , 0x3023 )    ,left, top, width, height );
			ok &= Add( ::GetDlgItem( hWnd , 0x3024 )    ,left, top, width, height );
			ok &= Add( ::GetDlgItem( hWnd , 0x3025 )    ,left, top, width, height );
		}
		else
		{
			ok &= Add( ::GetDlgItem( hWnd , ID_APPLY_NOW  )    ,left, top, width, height );
		}
		ok &= Add( ::GetDlgItem( hWnd , IDOK )      ,left, top, width, height );
		ok &= Add( ::GetDlgItem( hWnd , IDCANCEL )  ,left, top, width, height );
		ok &= Add( ::GetDlgItem( hWnd , IDHELP   )  ,left, top, width, height );
		return ok;
	}
	return FALSE;
}
// Adds the pages of PropertySheet or Wizard
BOOL CNGResizeCtrl::PropertySheetAddPages( CPropertySheet * sheet, int left, int top, int width, int height )
{
	if( sheet )
	{
		BOOL ok    = Add( sheet->GetTabControl(), left, top, width, height );;
		int  count = sheet->GetPageCount();
		for( int currentPage = 0; currentPage < count; currentPage++ )
		{
			ok &= Add( sheet->GetPage( currentPage), left, top, width, height );
		}
		return ok;
	}
	return FALSE;
}
// Adds the etched bar beneath the pages
BOOL CNGResizeCtrl::WizardAddEtchedBar( CPropertySheet * sheet, int left, int top, int width, int height )
{
	if( sheet && sheet->IsWizard() )
	{
		return Add( ::GetDlgItem( sheet->GetSafeHwnd() , 0x3026 ), left, top, width, height );
	}
	return FALSE;
}

// saves the the delta-size between the wizard-size and a page-size
// because WizBack and WizNext resizes a page to the initial Size
BOOL CNGResizeCtrl::WizardSaveMargins( CPropertySheet * sheet )
{
	if( sheet )
	{
		if( NULL == m_margins )
			m_margins = new CRect;
		ASSERT( m_margins );
		
		sheet->GetWindowRect( m_margins );
		CRect rect;
		CPropertyPage *  page = sheet->GetActivePage( );
		page->GetWindowRect( &rect );
		m_margins->left    = rect.left - m_margins->left;
		m_margins->top     = rect.top  - m_margins->top;
		m_margins->right  -= rect.right;
		m_margins->bottom -= rect.bottom;
		return TRUE;
	}
	return FALSE;
}


// restores propertypage size after WizBack or WizNext
BOOL CNGResizeCtrl::WizardAdjustPage( CPropertySheet * sheet )
{
	if (sheet && m_margins)
	{
		if (sheet->GetActivePage() == NULL)
		{
			return FALSE;
		}
		// because WizBack and WizNext resizes
		// a page to the initial Size
		// we need to change the size
		CRect rect;
		sheet->GetWindowRect( &rect );

		BOOL bHasWizard97Header = FALSE;

		// The following is needed to handle pages with WIZARD97 header bitmaps
		if (sheet->IsKindOf(RUNTIME_CLASS(CPropertySheetEx) ) )
		{
			BOOL bIsWizard97 = ( ( ((CPropertySheetEx*)sheet)->m_psh.dwFlags & PSH_WIZARD97) != 0);
			if (bIsWizard97)
			{
				CPropertyPageEx* pPage = (CPropertyPageEx*)sheet->GetActivePage();
				if (pPage != NULL)
				{
					bHasWizard97Header = ( (pPage->m_psp.dwFlags & PSP_HIDEHEADER) == 0);
				}
			}
		}
		if (bHasWizard97Header)
		{
			// If the page has a header, we need to move it below the border.
			// By inspection (Spy++), the border is a static control with ID 0x3027
			CWnd* pTopBorder = sheet->GetDlgItem(0x3027);
			ASSERT(pTopBorder != NULL);
			if (pTopBorder != NULL)
			{
				CRect rectTopBorder;
				pTopBorder->GetWindowRect(rectTopBorder);

				// With the exception of the bottom, the margins are already
				// accounted for by the position of the top border...
				rect.left	= rectTopBorder.left;
				rect.top	= rectTopBorder.top;
				rect.right	-= m_margins->right;
				rect.bottom	-= m_margins->bottom;
			}
		}
		else
		{
			rect.left   += m_margins->left;
			rect.top    += m_margins->top;
			rect.right  -= m_margins->right;
			rect.bottom -= m_margins->bottom;
		}
		sheet->ScreenToClient( &rect );
		CPropertyPage *  page = sheet->GetActivePage( );
		page->MoveWindow( &rect );
		return TRUE;
	}
	return FALSE;
}