Windows/UltimateToolbox
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
UltimateToolbox/UltimateToolbox93_src/Ultimate Toolbox/source/OXScrollWnd.cpp
Raten fb064541d6 new
2025-11-27 16:46:48 +09:00

2345 lines
56 KiB
C++
Raw Blame History

// ==========================================================================
// Class Implementation : COXScrollWnd
// ==========================================================================
// Version: 9.3
// This software along with its related components, documentation and files ("The Libraries")
// is © 1994-2007 The Code Project (1612916 Ontario Limited) and use of The Libraries is
// governed by a software license agreement ("Agreement"). Copies of the Agreement are
// available at The Code Project (www.codeproject.com), as part of the package you downloaded
// to obtain this file, or directly from our office. For a copy of the license governing
// this software, you may contact us at legalaffairs@codeproject.com, or by calling 416-849-8900.
// //////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "OXScrollWnd.h"
#include <afxpriv.h>
#include "UTB64Bit.h"
#ifndef __OXMFCIMPL_H__
#if _MFC_VER >= 0x0700
#if _MFC_VER >= 1400
#include <afxtempl.h>
#endif
#include <..\src\mfc\afximpl.h>
#else
#include <..\src\afximpl.h>
#endif
#define __OXMFCIMPL_H__
#endif
#ifndef SPI_GETWHEELSCROLLLINES
#define SPI_GETWHEELSCROLLLINES 104
#endif
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
// Special mapping modes just for COXScrollWnd implementation
#ifndef MM_NONE
#define MM_NONE 0
#endif
/////////////////////////////////////////////////////////////////////////////
// COXScrollWnd
IMPLEMENT_DYNCREATE(COXScrollWnd, CWnd)
COXScrollWnd::COXScrollWnd() :
m_nMapMode(MM_NONE),
m_nZoomLevel(100), // 100%
m_align(ZA_TOPLEFT),
m_alignContents(CA_TOPLEFT),
m_bIsInSmoothScrolling(FALSE),
m_bAlwaysFitWindow(FALSE),
m_bDisplayContextMenu(TRUE),
m_bUseTrackZoom(FALSE),
m_totalLog(0,0),
m_rectLog(0,0,0,0),
m_totalDev(0,0),
m_pageDev(0,0),
m_lineDev(0,0),
m_sizeDev(0,0),
m_nPagePercent(0),
m_nLinePercent(0),
m_bUseRelativeScrollSizes(FALSE),
m_bInsideUpdate(FALSE)
{
SetSmoothScrolling(FALSE);
SetSmoothEnvironment();
}
COXScrollWnd::~COXScrollWnd()
{
}
BOOL COXScrollWnd::Initialize()
{
BOOL bResult=FALSE;
#ifdef OXSCRLWND_USE_RULER
bResult=AttachRuler();
#else
bResult=TRUE;
#endif // OXSCRLWND_USE_RULER
return bResult;
}
BEGIN_MESSAGE_MAP(COXScrollWnd, CWnd)
//{{AFX_MSG_MAP(COXScrollWnd)
ON_WM_HSCROLL()
ON_WM_WINDOWPOSCHANGED()
ON_WM_VSCROLL()
ON_WM_CONTEXTMENU()
ON_WM_LBUTTONDOWN()
ON_WM_MOUSEWHEEL()
ON_WM_MOUSEACTIVATE()
ON_WM_CREATE()
ON_WM_KEYDOWN()
//}}AFX_MSG_MAP
ON_COMMAND_RANGE(IDM_OX_SETZOOM10,IDM_OX_SIZETOCONTENT,OnChangeZoom)
ON_COMMAND(IDM_OX_ALWAYSFITWINDOW,OnAlwaysFitWindow)
ON_COMMAND(IDM_OX_USETRACKZOOM,OnUseTrackZoom)
ON_COMMAND(IDM_OX_SMOOTHSCROLLING,OnSmoothScrolling)
#ifdef OXSCRLWND_USE_RULER
ON_COMMAND(IDM_OX_SHOWHORZRULERBAR,OnShowHorzRulerBar)
ON_COMMAND(IDM_OX_SHOWVERTRULERBAR,OnShowVertRulerBar)
ON_COMMAND(IDM_OX_RULERBAR_INCHES,OnRulerBarUseInches)
ON_COMMAND(IDM_OX_RULERBAR_CENTIMETERS,OnRulerBarUseCentimeters)
#endif // OXSCRLWND_USE_RULER
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// COXScrollWnd message handlers
void COXScrollWnd::PreSubclassWindow()
{
_AFX_THREAD_STATE* pThreadState=AfxGetThreadState();
// hook not already in progress
if(pThreadState->m_pWndInit==NULL)
{
if(!Initialize())
{
TRACE(_T("COXScrollWnd::PreSubclassWindow: failed to initialize the object!\n"));
}
}
CWnd::PreSubclassWindow();
}
BOOL COXScrollWnd::PreTranslateMessage(MSG* pMsg)
{
BOOL bProcessed=FALSE;
if(pMsg->message==WM_KEYDOWN)
{
bProcessed=
HandleKeyInput(PtrToUint(pMsg->wParam),LOWORD(pMsg->lParam),HIWORD(pMsg->lParam));
}
if(bProcessed)
{
return TRUE;
}
else
{
return CWnd::PreTranslateMessage(pMsg);
}
}
BOOL COXScrollWnd::HandleKeyInput(UINT nChar, UINT nRepCnt, UINT nFlags)
{
UNREFERENCED_PARAMETER(nRepCnt);
UNREFERENCED_PARAMETER(nFlags);
BOOL bHandled=TRUE;
switch(nChar)
{
case VK_UP:
{
SendMessage(WM_VSCROLL,MAKEWPARAM(SB_LINEUP,0),NULL);
break;
}
case VK_DOWN:
{
SendMessage(WM_VSCROLL,MAKEWPARAM(SB_LINEDOWN,0),NULL);
break;
}
case VK_PRIOR:
{
SendMessage(WM_VSCROLL,MAKEWPARAM(SB_PAGEUP,0),NULL);
break;
}
case VK_NEXT:
{
SendMessage(WM_VSCROLL,MAKEWPARAM(SB_PAGEDOWN,0),NULL);
break;
}
case VK_LEFT:
{
SendMessage(WM_HSCROLL,MAKEWPARAM(SB_LINELEFT,0),NULL);
break;
}
case VK_RIGHT:
{
SendMessage(WM_HSCROLL,MAKEWPARAM(SB_LINERIGHT,0),NULL);
break;
}
case VK_HOME:
{
if(::GetKeyState(VK_CONTROL)<0)
{
SendMessage(WM_VSCROLL,MAKEWPARAM(SB_TOP,0),NULL);
}
else
{
SendMessage(WM_HSCROLL,MAKEWPARAM(SB_LEFT,0),NULL);
}
break;
}
case VK_END:
{
if(::GetKeyState(VK_CONTROL)<0)
{
SendMessage(WM_VSCROLL,MAKEWPARAM(SB_BOTTOM,0),NULL);
}
else
{
SendMessage(WM_HSCROLL,MAKEWPARAM(SB_RIGHT,0),NULL);
}
break;
}
case VK_TAB:
{
if(::GetKeyState(VK_SHIFT)<0)
{
SendMessage(WM_HSCROLL,MAKEWPARAM(SB_PAGELEFT,0),NULL);
}
else
{
SendMessage(WM_HSCROLL,MAKEWPARAM(SB_PAGERIGHT,0),NULL);
}
break;
}
default:
{
bHandled=FALSE;
break;
}
}
return bHandled;
}
int COXScrollWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if(CWnd::OnCreate(lpCreateStruct)==-1)
return -1;
if(!Initialize())
{
TRACE(_T("COXScrollWnd::OnCreate: failed to initialize the object!\n"));
return -1;
}
return 0;
}
void COXScrollWnd::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
// TODO: Add your message handler code here and/or call default
// ASSERT(pScrollBar == GetScrollBarCtrl(SB_HORZ)); // may be null
// UNUSED(pScrollBar);
UNREFERENCED_PARAMETER(pScrollBar);
OnScroll(MAKEWORD(nSBCode, -1), nPos);
}
void COXScrollWnd::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
// TODO: Add your message handler code here and/or call default
// ASSERT(pScrollBar == GetScrollBarCtrl(SB_VERT)); // may be null
// UNUSED(pScrollBar);
UNREFERENCED_PARAMETER(pScrollBar);
OnScroll(MAKEWORD(-1, nSBCode), nPos);
}
void COXScrollWnd::OnWindowPosChanged(WINDOWPOS* lpwndpos)
{
CWnd::OnWindowPosChanged(lpwndpos);
// TODO: Add your message handler code here
if((lpwndpos->flags & SWP_NOSIZE)==0)
{
if(IsAlwaysFitWindow())
{
ZoomToWindow();
}
else if(m_nMapMode!=MM_NONE)
{
UpdateBars(FALSE);
}
}
}
void COXScrollWnd::OnContextMenu(CWnd* pWnd, CPoint point)
{
// TODO: Add your message handler code here
if(!GetDisplayContextMenu())
{
CWnd::OnContextMenu(pWnd,point);
return;
}
if(pWnd==this)
{
// create popup menu
//
CMenu menu;
CMenu menuZoom;
#ifdef OXSCRLWND_USE_RULER
CMenu menuRulerBars;
#endif // OXSCRLWND_USE_RULER
if(menu.CreatePopupMenu())
{
int nZoomLevel=GetZoomLevel();
CString sItem;
if(menuZoom.CreatePopupMenu())
{
VERIFY(sItem.LoadString(IDS_OX_SETZOOM10));
menuZoom.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_SETZOOM10,
sItem);
VERIFY(sItem.LoadString(IDS_OX_SETZOOM25));
menuZoom.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_SETZOOM25,
sItem);
VERIFY(sItem.LoadString(IDS_OX_SETZOOM50));
menuZoom.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_SETZOOM50,
sItem);
VERIFY(sItem.LoadString(IDS_OX_SETZOOM100));
menuZoom.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_SETZOOM100,
sItem);
VERIFY(sItem.LoadString(IDS_OX_SETZOOM200));
menuZoom.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_SETZOOM200,
sItem);
VERIFY(sItem.LoadString(IDS_OX_SETZOOM300));
menuZoom.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_SETZOOM300,
sItem);
VERIFY(sItem.LoadString(IDS_OX_SETZOOM400));
menuZoom.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_SETZOOM400,
sItem);
VERIFY(sItem.LoadString(IDS_OX_SETZOOM500));
menuZoom.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_SETZOOM500,
sItem);
VERIFY(sItem.LoadString(IDS_OX_SETZOOM600));
menuZoom.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_SETZOOM600,
sItem);
VERIFY(sItem.LoadString(IDS_OX_SETZOOM700));
menuZoom.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_SETZOOM700,
sItem);
VERIFY(sItem.LoadString(IDS_OX_SETZOOM800));
menuZoom.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_SETZOOM800,
sItem);
VERIFY(sItem.LoadString(IDS_OX_SETZOOM900));
menuZoom.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_SETZOOM900,
sItem);
VERIFY(sItem.LoadString(IDS_OX_SETZOOM1000));
menuZoom.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_SETZOOM1000,
sItem);
VERIFY(sItem.LoadString(IDS_OX_ZOOMPOPUPMENU));
menu.AppendMenu(MF_STRING|MF_POPUP,
(UINT_PTR)(HMENU)menuZoom,sItem);
menuZoom.CheckMenuItem(IDM_OX_SETZOOM10,MF_BYCOMMAND|
((nZoomLevel==10) ? MF_CHECKED : MF_UNCHECKED));
menuZoom.CheckMenuItem(IDM_OX_SETZOOM25,MF_BYCOMMAND|
((nZoomLevel==25) ? MF_CHECKED : MF_UNCHECKED));
menuZoom.CheckMenuItem(IDM_OX_SETZOOM50,MF_BYCOMMAND|
((nZoomLevel==50) ? MF_CHECKED : MF_UNCHECKED));
menuZoom.CheckMenuItem(IDM_OX_SETZOOM100,MF_BYCOMMAND|
((nZoomLevel==100) ? MF_CHECKED : MF_UNCHECKED));
menuZoom.CheckMenuItem(IDM_OX_SETZOOM200,MF_BYCOMMAND|
((nZoomLevel==200) ? MF_CHECKED : MF_UNCHECKED));
menuZoom.CheckMenuItem(IDM_OX_SETZOOM300,MF_BYCOMMAND|
((nZoomLevel==300) ? MF_CHECKED : MF_UNCHECKED));
menuZoom.CheckMenuItem(IDM_OX_SETZOOM400,MF_BYCOMMAND|
((nZoomLevel==400) ? MF_CHECKED : MF_UNCHECKED));
menuZoom.CheckMenuItem(IDM_OX_SETZOOM500,MF_BYCOMMAND|
((nZoomLevel==500) ? MF_CHECKED : MF_UNCHECKED));
menuZoom.CheckMenuItem(IDM_OX_SETZOOM600,MF_BYCOMMAND|
((nZoomLevel==600) ? MF_CHECKED : MF_UNCHECKED));
menuZoom.CheckMenuItem(IDM_OX_SETZOOM700,MF_BYCOMMAND|
((nZoomLevel==700) ? MF_CHECKED : MF_UNCHECKED));
menuZoom.CheckMenuItem(IDM_OX_SETZOOM800,MF_BYCOMMAND|
((nZoomLevel==800) ? MF_CHECKED : MF_UNCHECKED));
menuZoom.CheckMenuItem(IDM_OX_SETZOOM900,MF_BYCOMMAND|
((nZoomLevel==900) ? MF_CHECKED : MF_UNCHECKED));
menuZoom.CheckMenuItem(IDM_OX_SETZOOM1000,MF_BYCOMMAND|
((nZoomLevel==1000) ? MF_CHECKED : MF_UNCHECKED));
}
VERIFY(sItem.LoadString(IDS_OX_SIZETOCONTENT));
menu.AppendMenu(MF_STRING,IDM_OX_SIZETOCONTENT,sItem);
if(nZoomLevel!=100 && !IsAlwaysFitWindow())
{
VERIFY(sItem.LoadString(IDS_OX_SETZOOM100));
menu.AppendMenu(MF_STRING,IDM_OX_SETZOOM100,sItem);
}
menu.AppendMenu(MF_SEPARATOR);
VERIFY(sItem.LoadString(IDS_OX_ALWAYSFITWINDOW));
menu.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_ALWAYSFITWINDOW,
sItem);
menu.CheckMenuItem(IDM_OX_ALWAYSFITWINDOW,MF_BYCOMMAND|
(IsAlwaysFitWindow() ? MF_CHECKED : MF_UNCHECKED));
VERIFY(sItem.LoadString(IDS_OX_USETRACKZOOM));
menu.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_USETRACKZOOM,
sItem);
menu.CheckMenuItem(IDM_OX_USETRACKZOOM,MF_BYCOMMAND|
(GetUseTrackZoom() ? MF_CHECKED : MF_UNCHECKED));
VERIFY(sItem.LoadString(IDS_OX_SMOOTHSCROLLING));
menu.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_SMOOTHSCROLLING,
sItem);
menu.CheckMenuItem(IDM_OX_SMOOTHSCROLLING,MF_BYCOMMAND|
(IsSmoothScrolling() ? MF_CHECKED : MF_UNCHECKED));
if(IsAlwaysFitWindow())
{
menu.EnableMenuItem(0,MF_BYPOSITION|MF_GRAYED);
menu.EnableMenuItem(IDM_OX_SIZETOCONTENT,MF_BYCOMMAND|MF_GRAYED);
}
#ifdef OXSCRLWND_USE_RULER
if(m_ruler.IsAttached() && menuRulerBars.CreatePopupMenu())
{
menu.AppendMenu(MF_SEPARATOR);
VERIFY(sItem.LoadString(IDS_OX_SHOWHORZRULERBAR));
menuRulerBars.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_SHOWHORZRULERBAR,
sItem);
VERIFY(sItem.LoadString(IDS_OX_SHOWVERTRULERBAR));
menuRulerBars.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_SHOWVERTRULERBAR,
sItem);
menuRulerBars.AppendMenu(MF_SEPARATOR);
VERIFY(sItem.LoadString(IDS_OX_RULERBAR_INCHES));
menuRulerBars.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_RULERBAR_INCHES,
sItem);
VERIFY(sItem.LoadString(IDS_OX_RULERBAR_CENTIMETERS));
menuRulerBars.AppendMenu(MF_STRING|MF_CHECKED,IDM_OX_RULERBAR_CENTIMETERS,
sItem);
VERIFY(sItem.LoadString(IDS_OX_RULERBARPOPUPMENU));
menu.AppendMenu(MF_STRING|MF_POPUP,
(UINT_PTR)(HMENU)menuRulerBars,sItem);
menuRulerBars.CheckMenuItem(IDM_OX_SHOWHORZRULERBAR,MF_BYCOMMAND|
(m_ruler.GetShowHorzRulerBar() ? MF_CHECKED : MF_UNCHECKED));
menuRulerBars.CheckMenuItem(IDM_OX_SHOWVERTRULERBAR,MF_BYCOMMAND|
(m_ruler.GetShowVertRulerBar() ? MF_CHECKED : MF_UNCHECKED));
menuRulerBars.CheckMenuItem(IDM_OX_RULERBAR_INCHES,MF_BYCOMMAND|
((m_ruler.GetHorzRulerBar()->GetCalibrate()==100 &&
m_ruler.GetVertRulerBar()->GetCalibrate()==100) ?
MF_CHECKED : MF_UNCHECKED));
menuRulerBars.CheckMenuItem(IDM_OX_RULERBAR_CENTIMETERS,MF_BYCOMMAND|
((m_ruler.GetHorzRulerBar()->GetCalibrate()==254 &&
m_ruler.GetVertRulerBar()->GetCalibrate()==254) ?
MF_CHECKED : MF_UNCHECKED));
}
#endif // OXSCRLWND_USE_RULER
}
if(OnPopulateContextMenu(&menu,point))
{
menu.TrackPopupMenu(TPM_LEFTALIGN|TPM_LEFTBUTTON,
point.x,point.y,this);
}
}
}
void COXScrollWnd::OnChangeZoom(UINT nID)
{
int nNewZoomLevel=0;
switch(nID)
{
case IDM_OX_SETZOOM10:
nNewZoomLevel=10;
break;
case IDM_OX_SETZOOM25:
nNewZoomLevel=25;
break;
case IDM_OX_SETZOOM50:
nNewZoomLevel=50;
break;
case IDM_OX_SETZOOM100:
nNewZoomLevel=100;
break;
case IDM_OX_SETZOOM200:
nNewZoomLevel=200;
break;
case IDM_OX_SETZOOM300:
nNewZoomLevel=300;
break;
case IDM_OX_SETZOOM400:
nNewZoomLevel=400;
break;
case IDM_OX_SETZOOM500:
nNewZoomLevel=500;
break;
case IDM_OX_SETZOOM600:
nNewZoomLevel=600;
break;
case IDM_OX_SETZOOM700:
nNewZoomLevel=700;
break;
case IDM_OX_SETZOOM800:
nNewZoomLevel=800;
break;
case IDM_OX_SETZOOM900:
nNewZoomLevel=900;
break;
case IDM_OX_SETZOOM1000:
nNewZoomLevel=1000;
break;
case IDM_OX_SIZETOCONTENT:
nNewZoomLevel=0;
break;
default:
ASSERT(FALSE);
}
if(nNewZoomLevel==0)
{
ZoomToWindow();
}
else
{
ASSERT(nNewZoomLevel>=MINZOOM && nNewZoomLevel<=MAXZOOM);
SetZoomLevel(nNewZoomLevel);
}
}
void COXScrollWnd::OnAlwaysFitWindow()
{
SetAlwaysFitWindow(!IsAlwaysFitWindow());
}
void COXScrollWnd::OnUseTrackZoom()
{
SetUseTrackZoom(!GetUseTrackZoom());
}
void COXScrollWnd::OnSmoothScrolling()
{
SetSmoothScrolling(!IsSmoothScrolling());
}
#ifdef OXSCRLWND_USE_RULER
void COXScrollWnd::OnShowHorzRulerBar()
{
m_ruler.SetShowHorzRulerBar(!GetShowHorzRulerBar());
}
void COXScrollWnd::OnShowVertRulerBar()
{
m_ruler.SetShowVertRulerBar(!GetShowVertRulerBar());
}
void COXScrollWnd::OnRulerBarUseInches()
{
m_ruler.GetHorzRulerBar()->SetCalibrate(100,FALSE);
m_ruler.GetVertRulerBar()->SetCalibrate(100,FALSE);
m_ruler.RedrawAttached();
}
void COXScrollWnd::OnRulerBarUseCentimeters()
{
m_ruler.GetHorzRulerBar()->SetCalibrate(254,FALSE);
m_ruler.GetVertRulerBar()->SetCalibrate(254,FALSE);
m_ruler.RedrawAttached();
}
#endif // OXSCRLWND_USE_RULER
void COXScrollWnd::OnLButtonDown(UINT nFlags, CPoint point)
{
UNREFERENCED_PARAMETER(nFlags);
if(GetUseTrackZoom() && !IsAlwaysFitWindow())
{
CRectTracker track;
track.m_sizeMin=CSize(5,5);
if(track.TrackRubberBand(this,point,TRUE))
{
CRect rectTrack=track.m_rect;
rectTrack.NormalizeRect();
CRect rectClient;
GetClientRect(rectClient);
CRect rectDisplayed=rectClient;
if(rectDisplayed.Width()>m_totalDev.cx)
rectDisplayed.right=rectDisplayed.left+m_totalDev.cx;
if(rectDisplayed.Height()>m_totalDev.cy)
rectDisplayed.bottom=rectDisplayed.top+m_totalDev.cy;
rectTrack.IntersectRect(rectTrack,rectDisplayed);
if(!rectTrack.IsRectEmpty() && rectTrack.Width()>=8 && rectTrack.Height()>=8)
{
CPoint ptScrollPos=GetScrollPosition(ZA_TOPLEFT);
int nOldZoomLevel=GetZoomLevel();
int nNewZoomLevel=
__min((nOldZoomLevel*rectClient.Width())/rectTrack.Width(),
(nOldZoomLevel*rectClient.Height())/rectTrack.Height());
SetZoomLevel(nNewZoomLevel,ZA_TOPLEFT);
ptScrollPos.x+=((rectTrack.left-rectClient.left)*100)/nOldZoomLevel;
ptScrollPos.y+=((rectTrack.top-rectClient.top)*100)/nOldZoomLevel;
ScrollToPosition(ptScrollPos,ZA_TOPLEFT);
}
}
}
}
int COXScrollWnd::OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message)
{
UNREFERENCED_PARAMETER(pDesktopWnd);
UNREFERENCED_PARAMETER(nHitTest);
UNREFERENCED_PARAMETER(message);
SetFocus();
return MA_NOACTIVATE;
}
///////////////////////////////////////////////////////////////////////////
void COXScrollWnd::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo)
{
UNREFERENCED_PARAMETER(pInfo);
ASSERT_VALID(pDC);
ASSERT(m_totalDev.cx>=0 && m_totalDev.cx>=0);
SetMapMode(pDC);
CPoint ptVpOrg(0, 0); // assume no shift for printing
if (!pDC->IsPrinting())
{
ptVpOrg=GetOrigin(pDC);
// Set the logical origin, do it yourself when printing !!!
pDC->SetWindowOrg(m_rectLog.TopLeft());
}
pDC->SetViewportOrg(ptVpOrg);
}
CPoint COXScrollWnd::GetOrigin(CDC* pDC/*=NULL*/) const
{
BOOL bDeleteDC=FALSE;
if(pDC==NULL)
{
CWnd* pWnd=(CWnd*)this;
pDC=new CClientDC(pWnd);
bDeleteDC=TRUE;
}
ScaleViewport(pDC);
CRect rect;
GetClientRect(&rect);
CPoint ptOrigin(0,0);
// by default shift viewport origin in negative direction of scroll
ptOrigin=-GetDeviceScrollPosition();
switch(m_alignContents)
{
case CA_TOPLEFT:
break;
case CA_TOPCENTER:
if(m_totalDev.cx<rect.Width())
{
ptOrigin.x=(rect.Width()-m_totalDev.cx)/2;
}
break;
case CA_TOPRIGHT:
if(m_totalDev.cx<rect.Width())
{
ptOrigin.x=rect.Width()-m_totalDev.cx;
}
break;
case CA_CENTERLEFT:
if(m_totalDev.cy<rect.Height())
{
ptOrigin.y=(rect.Height()-m_totalDev.cy)/2;
}
break;
case CA_CENTER:
if(m_totalDev.cx<rect.Width())
{
ptOrigin.x=(rect.Width()-m_totalDev.cx)/2;
}
if(m_totalDev.cy<rect.Height())
{
ptOrigin.y=(rect.Height()-m_totalDev.cy)/2;
}
break;
case CA_CENTERRIGHT:
if(m_totalDev.cy<rect.Height())
{
ptOrigin.y=(rect.Height()-m_totalDev.cy)/2;
}
if(m_totalDev.cx<rect.Width())
{
ptOrigin.x=rect.Width()-m_totalDev.cx;
}
break;
case CA_BOTTOMLEFT:
if(m_totalDev.cy<rect.Height())
{
ptOrigin.y=rect.Height()-m_totalDev.cy;
}
break;
case CA_BOTTOMCENTER:
if(m_totalDev.cx<rect.Width())
{
ptOrigin.x=(rect.Width()-m_totalDev.cx)/2;
}
if(m_totalDev.cy<rect.Height())
{
ptOrigin.y=rect.Height()-m_totalDev.cy;
}
break;
case CA_BOTTOMRIGHT:
if(m_totalDev.cy<rect.Height())
{
ptOrigin.y=rect.Height()-m_totalDev.cy;
}
if(m_totalDev.cx<rect.Width())
{
ptOrigin.x=rect.Width()-m_totalDev.cx;
}
break;
default:
ASSERT(FALSE);
}
if(bDeleteDC)
{
delete pDC;
}
return ptOrigin;
}
/////////////////////////////////////////////////////////////////////////////
// Set mode and scaling/scrolling sizes
void COXScrollWnd::SetDeviceScrollSizesRelative(int nMapMode,
SIZE sizeTotal,
int nPagePercent,
int nLinePercent)
{
// synthesize a rectangle from the size
CRect rectLog( CPoint(0,0), sizeTotal );
if( nMapMode != MM_TEXT )
rectLog.bottom = -rectLog.bottom;
// call overloaded function for real work
SetDeviceScrollSizesRelative( nMapMode, rectLog, nPagePercent,
nLinePercent );
}
void COXScrollWnd::SetDeviceScrollSizesRelative(SIZE sizeDevice,
const CRect& rectContents,
int nPagePercent,
int nLinePercent)
{
ASSERT( sizeDevice.cy > 0 );
if( rectContents.Height() < 0 )
sizeDevice.cy = -sizeDevice.cy;
m_sizeDev = sizeDevice;
SetDeviceScrollSizesRelative(MM_ANISOTROPIC,rectContents,
nPagePercent,nLinePercent);
}
void COXScrollWnd::SetDeviceScrollSizesRelative(int nMapMode,
const CRect& rectContents,
int nPagePercent,
int nLinePercent)
{
ASSERT( nLinePercent > 0 );
ASSERT( nPagePercent >= nLinePercent );
ASSERT( nLinePercent <= 100 );
ASSERT( nPagePercent <= 100 );
m_bUseRelativeScrollSizes = TRUE;
m_nPagePercent = nPagePercent;
m_nLinePercent = nLinePercent;
m_rectLog = rectContents;
m_totalLog.cx = m_rectLog.Width();
m_totalLog.cy = m_rectLog.Height();
if( m_totalLog.cy < 0 )
m_totalLog.cy = -m_totalLog.cy;
ASSERT(nMapMode > 0);
ASSERT(nMapMode != MM_ISOTROPIC);
int nOldMapMode = m_nMapMode;
m_nMapMode = nMapMode;
//BLOCK: convert logical coordinate space to device coordinates
{
CWindowDC dc(NULL);
SetMapMode( &dc );
ScaleViewport( &dc );
m_totalDev = m_totalLog;
dc.LPtoDP((LPPOINT)&m_totalDev);
if (m_totalDev.cy < 0)
m_totalDev.cy = -m_totalDev.cy;
} // release DC here
// now adjust device specific sizes
ASSERT(m_totalDev.cx >= 0 && m_totalDev.cy >= 0);
if (m_hWnd != NULL)
{
// window has been created, invalidate now
UpdateBars();
if (nOldMapMode != m_nMapMode)
Invalidate(TRUE);
}
}
// maintained for backward compatibility
void COXScrollWnd::SetScrollSizes(int nMapMode, SIZE sizeTotal,
const SIZE& sizePage, const SIZE& sizeLine)
{
m_bUseRelativeScrollSizes = FALSE;
ASSERT(sizeTotal.cx >= 0 && sizeTotal.cy >= 0);
ASSERT(nMapMode > 0);
ASSERT(nMapMode != MM_ISOTROPIC && nMapMode != MM_ANISOTROPIC);
int nOldMapMode = m_nMapMode;
m_nMapMode = nMapMode;
m_totalLog = sizeTotal;
// synthesize a rectangle from the size
m_rectLog = CRect( CPoint(0,0), sizeTotal );
if( m_nMapMode != MM_TEXT )
m_rectLog.bottom = -m_rectLog.bottom;
//BLOCK: convert logical coordinate space to device coordinates
{
CWindowDC dc(NULL);
ASSERT(m_nMapMode > 0);
SetMapMode( &dc );
// leave page and line sizes unaffected from zooming
m_pageDev = sizePage;
dc.LPtoDP((LPPOINT)&m_pageDev);
m_lineDev = sizeLine;
dc.LPtoDP((LPPOINT)&m_lineDev);
// total size
ScaleViewport( &dc );
m_totalDev = m_totalLog;
dc.LPtoDP((LPPOINT)&m_totalDev);
if (m_totalDev.cy < 0)
m_totalDev.cy = -m_totalDev.cy;
if (m_pageDev.cy < 0)
m_pageDev.cy = -m_pageDev.cy;
if (m_lineDev.cy < 0)
m_lineDev.cy = -m_lineDev.cy;
} // release DC here
// now adjust device specific sizes
ASSERT(m_totalDev.cx >= 0 && m_totalDev.cy >= 0);
if (m_pageDev.cx == 0)
m_pageDev.cx = m_totalDev.cx / 10;
if (m_pageDev.cy == 0)
m_pageDev.cy = m_totalDev.cy / 10;
if (m_lineDev.cx == 0)
m_lineDev.cx = m_pageDev.cx / 10;
if (m_lineDev.cy == 0)
m_lineDev.cy = m_pageDev.cy / 10;
if (m_hWnd != NULL)
{
// window has been created, invalidate now
UpdateBars();
if (nOldMapMode != m_nMapMode)
Invalidate(TRUE);
}
}
// Zoom Ops
void COXScrollWnd::ZoomToWindow()
{
int nZoomLevel=GetZoomLevel();
{
CClientDC dc(this);
ASSERT(m_nMapMode > 0);
SetMapMode( &dc );
CSize sizeSb, sizeZoom, sizeClient;
long temp;
GetTrueClientSize(sizeClient,sizeSb);
CRect rectClient;
GetClientRect(rectClient);
rectClient.right=rectClient.left+sizeClient.cx;
rectClient.bottom=rectClient.top+sizeClient.cy;
dc.DPtoLP( rectClient );
sizeClient=rectClient.Size();
if( sizeClient.cy < 0 )
sizeClient.cy = -sizeClient.cy;
temp = (long)((float)100 * (float)sizeClient.cx /
(float)m_totalLog.cx);
if( temp > (long)MAXZOOM )
sizeZoom.cx = MAXZOOM;
else
sizeZoom.cx = (int)temp;
temp = (long)((float)100 * (float)sizeClient.cy /
(float)m_totalLog.cy);
if( temp > (long)MAXZOOM )
sizeZoom.cy = MAXZOOM;
else
sizeZoom.cy = (int)temp;
// use the lower value
if( sizeZoom.cy < sizeZoom.cx )
nZoomLevel = sizeZoom.cy;
else
nZoomLevel = sizeZoom.cx;
if ( nZoomLevel < MINZOOM )
nZoomLevel = MINZOOM;
}
SetZoomLevel(nZoomLevel);
}
void COXScrollWnd::ZoomToRectangle( CRect rectZoom, ZoomAlignment Align )
{
int nZoomLevel=GetZoomLevel();
{
CClientDC dc(this);
OnPrepareDC( &dc );
// clip zoom rectangle to document size
CRect rectDevDoc = m_rectLog;
dc.LPtoDP( rectDevDoc );
if( !rectZoom.IntersectRect( rectZoom, rectDevDoc ) )
return; // competely outside of the document, ignore
dc.DPtoLP( rectZoom );
// check again in logical coords
if( 0 == rectZoom.Width() )
return;
if( 0 == rectZoom.Height() )
return;
CSize sizeZoom=rectZoom.Size();
if( sizeZoom.cy < 0 )
sizeZoom.cy = -sizeZoom.cy;
CSize sizeSb, sizeClient;
GetTrueClientSize(sizeClient,sizeSb);
CRect rectClient;
GetClientRect(rectClient);
rectClient.right=rectClient.left+sizeClient.cx;
rectClient.bottom=rectClient.top+sizeClient.cy;
SetMapMode( &dc ); // assume 100%
dc.DPtoLP( rectClient );
sizeClient=rectClient.Size();
if( sizeClient.cy < 0 )
sizeClient.cy = -sizeClient.cy;
long temp = (long)((float)100 * (float)sizeClient.cx /
(float)sizeZoom.cx);
if( temp > (long)MAXZOOM )
sizeZoom.cx = MAXZOOM;
else
sizeZoom.cx = (int)temp;
temp = (long)((float)100 * (float)sizeClient.cy /
(float)sizeZoom.cy);
if( temp > (long)MAXZOOM )
sizeZoom.cy = MAXZOOM;
else
sizeZoom.cy = (int)temp;
// use the lower value
if( sizeZoom.cy < sizeZoom.cx )
nZoomLevel = sizeZoom.cy;
else
nZoomLevel = sizeZoom.cx;
if ( nZoomLevel < MINZOOM )
nZoomLevel = MINZOOM;
}
SetZoomLevel(nZoomLevel);
CPoint ptAlign;
if (m_hWnd != NULL)
{
if( Align == ZA_DEFAULT )
Align = m_align;
switch( Align )
{
case ZA_TOPLEFT:
ptAlign.x = rectZoom.left;
ptAlign.y = rectZoom.top;
break;
case ZA_BOTTOMLEFT:
ptAlign.x = rectZoom.left;
ptAlign.y = rectZoom.bottom;
break;
case ZA_CENTER:
ptAlign.x = (rectZoom.left + rectZoom.right)/2;
ptAlign.y = (rectZoom.top + rectZoom.bottom)/2;
break;
}
ScrollToPosition( ptAlign, Align );
UpdateBars();
Invalidate(TRUE);
}
}
int COXScrollWnd::SetZoomLevel( int nNewLevel, ZoomAlignment Align )
{
int nOldLevel=m_nZoomLevel;
if(Align==ZA_DEFAULT)
Align=m_align;
CPoint ptCurrent=GetScrollPosition( Align );
if( nNewLevel < MINZOOM )
nNewLevel = MINZOOM;
if( nNewLevel > MAXZOOM )
nNewLevel = MAXZOOM;
m_nZoomLevel = nNewLevel;
if( nOldLevel != nNewLevel )
{
//BLOCK: convert logical coordinate space to device coordinates
{
CWindowDC dc(NULL);
ASSERT(m_nMapMode > 0);
SetMapMode( &dc );
// total size
ScaleViewport( &dc );
m_totalDev = m_totalLog;
dc.LPtoDP((LPPOINT)&m_totalDev);
if (m_totalDev.cy < 0)
m_totalDev.cy = -m_totalDev.cy;
} // release DC here
ASSERT(m_totalDev.cx >= 0 && m_totalDev.cy >= 0);
if (m_hWnd != NULL)
{
// window exists, invalidate now
ScrollToPosition( ptCurrent, Align );
UpdateBars(FALSE);
Invalidate(TRUE);
}
}
#ifdef OXSCRLWND_USE_RULER
m_ruler.ZoomRuler(m_nZoomLevel,TRUE);
m_ruler.ZoomRuler(m_nZoomLevel,FALSE);
#endif // OXSCRLWND_USE_RULER
return nOldLevel;
}
// zoom helper functions
void COXScrollWnd::SetMapMode( CDC* pDC ) const
{
ASSERT(m_nMapMode > 0);
pDC->SetMapMode(m_nMapMode);
if( m_nMapMode == MM_ANISOTROPIC )
{
ASSERT( m_sizeDev.cx >= 10 );
ASSERT( m_sizeDev.cy >= 10 || m_sizeDev.cy <= -10 );
ASSERT( m_sizeDev.cx < 3200 );
ASSERT( m_sizeDev.cy < 3200 || m_sizeDev.cy >= -3200 );
pDC->SetWindowExt( m_totalLog );
pDC->SetViewportExt( m_sizeDev );
}
else
{
// unlock mapping mode for zooming, extents of previous map mode are inherited
pDC->SetMapMode( MM_ANISOTROPIC );
if( m_nMapMode == MM_TEXT )
{
// current extents are 1,1 which are too small to zoom down
pDC->ScaleWindowExt( 1000, 1, 1000, 1 );
pDC->ScaleViewportExt( 1000, 1, 1000, 1 );
}
}
}
void COXScrollWnd::SetZoomAlign( ZoomAlignment align )
{
#ifdef _DEBUG
if( align == ZA_DEFAULT )
TRACE(_T("You cannot set the ZoomAlignment to ZA_DEFAULT"));
#endif
if( align != ZA_DEFAULT )
m_align = align;
}
/////////////////////////////////////////////////////////////////////////////
// Getting information
CPoint COXScrollWnd::GetScrollPosition( ZoomAlignment Align ) const // logical coordinates
{
CPoint pt = GetDeviceScrollPosition();
// pt may be negative if m_bCenter is set
CRect rectClient;
GetClientRect( rectClient );
DWORD dwStyle = GetStyle();
BOOL bHasV, bHasH;
bHasV = (dwStyle & WS_VSCROLL) != 0 || GetScrollBarCtrl(SB_VERT) != NULL;
bHasH = (dwStyle & WS_HSCROLL) != 0 || GetScrollBarCtrl(SB_HORZ) != NULL;
if( Align == ZA_DEFAULT )
Align = m_align;
switch ( Align )
{
case ZA_BOTTOMLEFT:
if( bHasV )
pt.y += rectClient.Height();
else
pt.y = m_totalDev.cy - 1;
break;
case ZA_CENTER:
if( bHasV )
pt.y += rectClient.Height()/2;
else
pt.y = m_totalDev.cy/2;
if( bHasH )
pt.x += rectClient.Width()/2;
else
pt.x = m_totalDev.cx/2;
break;
}
ASSERT(m_nMapMode > 0); // must be set
CWindowDC dc(NULL);
SetMapMode( &dc );
ScaleViewport( &dc );
// CRect::TopLeft() doesn't work with const CRects
dc.SetWindowOrg( m_rectLog.left, m_rectLog.top );
dc.DPtoLP((LPPOINT)&pt);
return pt;
}
void COXScrollWnd::ScrollToPosition(POINT pt, ZoomAlignment Align) // logical coordinates
{
ASSERT(m_nMapMode > 0); // not allowed
CWindowDC dc(NULL);
SetMapMode( &dc );
ScaleViewport( &dc );
dc.SetWindowOrg( m_rectLog.TopLeft() );
dc.LPtoDP((LPPOINT)&pt);
CRect rectClient;
GetClientRect( rectClient );
// now in device coordinates
if( Align == ZA_DEFAULT )
Align = m_align;
switch ( Align )
{
case ZA_BOTTOMLEFT:
pt.y -= rectClient.Height();
break;
case ZA_CENTER:
pt.y -= rectClient.Height()/2;
pt.x -= rectClient.Width()/2;
break;
}
//limit if out of range
CSize sizeClient=rectClient.Size();
CSize needSb;
CSize sizeRange;
CPoint ptMove;
GetScrollBarState(sizeClient,needSb,sizeRange,ptMove,FALSE);
if (pt.x > sizeRange.cx)
pt.x = sizeRange.cx;
if (pt.x < 0)
pt.x = 0;
if (pt.y > sizeRange.cy)
pt.y = sizeRange.cy;
if (pt.y < 0)
pt.y = 0;
ScrollToDevicePosition(pt);
}
CPoint COXScrollWnd::GetDeviceScrollPosition() const
{
CPoint pt(GetScrollPos(SB_HORZ), GetScrollPos(SB_VERT));
ASSERT(pt.x >= 0 && pt.y >= 0);
return pt;
}
void COXScrollWnd::GetDeviceScrollSizes(int& nMapMode, SIZE& sizeTotal,
SIZE& sizePage, SIZE& sizeLine) const
{
if (m_nMapMode <= 0)
TRACE(_T("Warning: COXScrollWnd::GetDeviceScrollSizes returning invalid mapping mode\n"));
nMapMode = m_nMapMode;
sizeTotal = m_totalDev;
sizePage = m_pageDev;
sizeLine = m_lineDev;
}
void COXScrollWnd::ScrollToDevicePosition(POINT ptDev)
{
ASSERT(ptDev.x >= 0);
ASSERT(ptDev.y >= 0);
int dx=0;
int dy=0;
// Note: ScrollToDevicePosition can and is used to scroll out-of-range
// areas as far as COXZoomView is concerned -- specifically in
// the print-preview code. Since OnScrollBy makes sure the range is
// valid, ScrollToDevicePosition does not vector through OnScrollBy.
CRect rect;
GetClientRect(rect);
CSize sizeClient=rect.Size();
CSize needSb;
CSize sizeRange;
CPoint ptMove;
GetScrollBarState(sizeClient,needSb,sizeRange,ptMove,FALSE);
int xOrig=GetScrollPos(SB_HORZ);
int yOrig=GetScrollPos(SB_VERT);
if(needSb.cx || xOrig!=0)
{
SetScrollPos(SB_HORZ,ptDev.x);
}
dx=xOrig-ptDev.x;
if(needSb.cy || yOrig!=0)
{
SetScrollPos(SB_VERT,ptDev.y);
}
dy=yOrig-ptDev.y;
ScrollWindow( dx, dy );
}
/////////////////////////////////////////////////////////////////////////////
// Other helpers
// retained for compatibility
void COXScrollWnd::FillOutsideRect(CDC* pDC, CBrush* pBrush) const
{
ASSERT_VALID(pDC);
ASSERT_VALID(pBrush);
// Fill Rect outside the contents
//
CPoint ptOrigin=GetOrigin(pDC);
CRect rectClient;
GetClientRect(rectClient);
CRect rect=rectClient;
rect.left=m_totalDev.cx+ptOrigin.x;
if(!rect.IsRectEmpty())
{
pDC->FillRect(rect, pBrush); // vertical strip along the side
}
rect.left=0;
rect.right=m_totalDev.cx+ptOrigin.x;
rect.top=m_totalDev.cy+ptOrigin.y;
if(!rect.IsRectEmpty())
{
pDC->FillRect(rect,pBrush); // horizontal strip along the bottom
}
if(ptOrigin.y>0)
{
rect.top=0;
rect.bottom=ptOrigin.y;
rect.right=rectClient.right-ptOrigin.x;
if(!rect.IsRectEmpty())
{
pDC->FillRect(rect, pBrush); // horizontal strip along the top
}
}
if(ptOrigin.x>0)
{
rect.left=0;
rect.right=ptOrigin.x;
rect.top=ptOrigin.y;
rect.bottom=rectClient.bottom-ptOrigin.y;
if(!rect.IsRectEmpty())
{
pDC->FillRect(rect, pBrush); // horizontal strip along the top
}
}
//
//////////////////////////
}
/////////////////////////////////////////////////////////////////////////////
// Tie to scrollbars and CWnd behaviour
void COXScrollWnd::GetScrollBarSizes(CSize& sizeSb)
{
sizeSb.cx=sizeSb.cy=0;
DWORD dwStyle=GetStyle();
if (GetScrollBarCtrl(SB_VERT) == NULL)
{
// vert scrollbars will impact client area of this window
sizeSb.cx=GetSystemMetrics(SM_CXVSCROLL);
if (dwStyle & WS_BORDER)
sizeSb.cx-=GetSystemMetrics(SM_CXBORDER);
}
if (GetScrollBarCtrl(SB_HORZ)==NULL)
{
// horz scrollbars will impact client area of this window
sizeSb.cy=GetSystemMetrics(SM_CYHSCROLL);
if(dwStyle & WS_BORDER)
sizeSb.cy-=GetSystemMetrics(SM_CYBORDER);
}
}
BOOL COXScrollWnd::GetTrueClientSize(CSize& size, CSize& sizeSb)
// return TRUE if enough room to add scrollbars if needed
{
CRect rect;
GetClientRect(&rect);
ASSERT(rect.top == 0 && rect.left == 0);
size.cx = rect.right;
size.cy = rect.bottom;
DWORD dwStyle = GetStyle();
// first get the size of the scrollbars for this window
GetScrollBarSizes(sizeSb);
// first calculate the size of a potential scrollbar
// (scroll bar controls do not get turned on/off)
if (sizeSb.cx != 0 && (dwStyle & WS_VSCROLL))
{
// vert scrollbars will impact client area of this window
size.cx += sizeSb.cx; // currently on - adjust now
}
if (sizeSb.cy != 0 && (dwStyle & WS_HSCROLL))
{
// horz scrollbars will impact client area of this window
size.cy += sizeSb.cy; // currently on - adjust now
}
// return TRUE if enough room
return (size.cx > sizeSb.cx && size.cy > sizeSb.cy);
}
// helper to return the state of the scrollbars without actually changing
// the state of the scrollbars
void COXScrollWnd::GetScrollBarState(CSize sizeClient, CSize& needSb,
CSize& sizeRange, CPoint& ptMove,
BOOL bInsideClient)
{
// get scroll bar sizes (the part that is in the client area)
CSize sizeSb;
GetScrollBarSizes(sizeSb);
// enough room to add scrollbars
sizeRange = m_totalDev - sizeClient;
// > 0 => need to scroll
ptMove = GetDeviceScrollPosition();
// point to move to (start at current scroll pos)
BOOL bNeedH = sizeRange.cx > 0;
if (!bNeedH)
ptMove.x = 0; // jump back to origin
else if (bInsideClient)
sizeRange.cy += sizeSb.cy; // need room for a scroll bar
BOOL bNeedV = sizeRange.cy > 0;
if (!bNeedV)
ptMove.y = 0; // jump back to origin
//ptMove.y = m_totalDev.cy - sizeClient.cy;
else if (bInsideClient)
sizeRange.cx += sizeSb.cx; // need room for a scroll bar
if (bNeedV && !bNeedH && sizeRange.cx > 0)
{
ASSERT(bInsideClient);
// need a horizontal scrollbar after all
bNeedH = TRUE;
sizeRange.cy += sizeSb.cy;
}
// if current scroll position will be past the limit, scroll to limit
if (sizeRange.cx > 0 && ptMove.x >= sizeRange.cx)
ptMove.x = sizeRange.cx;
if (sizeRange.cy > 0 && ptMove.y >= sizeRange.cy)
ptMove.y = sizeRange.cy;
// now update the bars as appropriate
needSb.cx = bNeedH;
needSb.cy = bNeedV;
// needSb, sizeRange, and ptMove area now all updated
}
void COXScrollWnd::UpdateBars(BOOL /*bSendRecalc*/)
{
// UpdateBars may cause window to be resized - ignore those resizings
if (m_bInsideUpdate)
return; // Do not allow recursive calls
// Lock out recursion
m_bInsideUpdate = TRUE;
// update the horizontal to reflect reality
// NOTE: turning on/off the scrollbars will cause 'OnSize' callbacks
ASSERT(m_totalDev.cx >= 0 && m_totalDev.cy >= 0);
CRect rectClient;
BOOL bCalcClient = TRUE;
// allow parent to do inside-out layout first
CWnd* pParentWnd = GetParent();
if (pParentWnd != NULL)
{
// if parent window responds to this message, use just
// client area for scroll bar calc -- not "true" client area
if ((BOOL)pParentWnd->SendMessage(WM_RECALCPARENT, 0,
(LPARAM)(LPCRECT)&rectClient) != 0)
{
// use rectClient instead of GetTrueClientSize for
// client size calculation.
bCalcClient = FALSE;
}
}
CSize sizeClient;
CSize sizeSb;
if (bCalcClient)
{
// get client rect
if (!GetTrueClientSize(sizeClient, sizeSb))
{
// no room for scroll bars (common for zero sized elements)
CRect rect;
GetClientRect(&rect);
if (rect.right > 0 && rect.bottom > 0)
{
// if entire client area is not invisible, assume we have
// control over our scrollbars
EnableScrollBarCtrl(SB_BOTH, FALSE);
}
m_bInsideUpdate = FALSE;
return;
}
}
else
{
// let parent window determine the "client" rect
sizeClient.cx = rectClient.right - rectClient.left;
sizeClient.cy = rectClient.bottom - rectClient.top;
}
// enough room to add scrollbars
CSize sizeRange;
CPoint ptMove;
CSize needSb;
// if scrolling-sizes are relative to client area update them NOW
if( m_bUseRelativeScrollSizes )
{
m_pageDev.cx = MulDiv( m_nPagePercent, sizeClient.cx, 100);
m_pageDev.cy = MulDiv( m_nPagePercent, sizeClient.cy, 100);
m_lineDev.cx = MulDiv( m_nLinePercent, sizeClient.cx, 100);
m_lineDev.cy = MulDiv( m_nLinePercent, sizeClient.cy, 100);
}
// get the current scroll bar state given the true client area
GetScrollBarState(sizeClient, needSb, sizeRange, ptMove, bCalcClient);
if (needSb.cx)
sizeClient.cy -= sizeSb.cy;
if (needSb.cy)
sizeClient.cx -= sizeSb.cx;
// first scroll the window as needed
ScrollToDevicePosition(ptMove); // will set the scroll bar positions too
// this structure needed to update the scrollbar page range
SCROLLINFO info;
info.fMask = SIF_PAGE|SIF_RANGE;
info.nMin = 0;
// now update the bars as appropriate
EnableScrollBarCtrl(SB_HORZ, needSb.cx);
if (needSb.cx)
{
info.nPage = sizeClient.cx;
info.nMax = m_totalDev.cx-1;
if(!SetScrollInfo(SB_HORZ, &info, TRUE))
SetScrollRange(SB_HORZ, 0, sizeRange.cx, TRUE);
}
EnableScrollBarCtrl(SB_VERT, needSb.cy);
if (needSb.cy)
{
info.nPage = sizeClient.cy;
info.nMax = m_totalDev.cy-1;
if(!SetScrollInfo(SB_VERT, &info, TRUE))
SetScrollRange(SB_VERT, 0, sizeRange.cy, TRUE);
}
// Remove recursion lockout
m_bInsideUpdate = FALSE;
}
void COXScrollWnd::CalcWindowRect(LPRECT lpClientRect, UINT nAdjustType)
{
if (nAdjustType == adjustOutside)
{
// if the control is being used in-place, add scrollbar sizes
// (scollbars should appear on the outside when in-place editing)
CSize sizeClient(
lpClientRect->right - lpClientRect->left,
lpClientRect->bottom - lpClientRect->top);
CSize sizeRange = m_totalDev - sizeClient;
// > 0 => need to scroll
// get scroll bar sizes (used to adjust the window)
CSize sizeSb;
GetScrollBarSizes(sizeSb);
// adjust the window size based on the state
if (sizeRange.cy > 0)
{ // vertical scroll bars take up horizontal space
lpClientRect->right += sizeSb.cx;
}
if (sizeRange.cx > 0)
{ // horizontal scroll bars take up vertical space
lpClientRect->bottom += sizeSb.cy;
}
}
else
{
// call default to handle other non-client areas
::AdjustWindowRect(lpClientRect, GetStyle(), FALSE);
}
}
/////////////////////////////////////////////////////////////////////////////
// COXScrollWnd scrolling
BOOL COXScrollWnd::OnScroll(UINT nScrollCode, UINT nPos, BOOL bDoScroll)
{
// if(LOBYTE(nScrollCode)!=SB_THUMBTRACK && HIBYTE(nScrollCode)!=SB_THUMBTRACK &&
// IsSmoothScrolling() && !m_bIsInSmoothScrolling)
if(IsSmoothScrolling() && !m_bIsInSmoothScrolling &&
(LOBYTE(nScrollCode)==SB_PAGEDOWN || LOBYTE(nScrollCode)==SB_PAGEUP ||
HIBYTE(nScrollCode)==SB_PAGEDOWN || HIBYTE(nScrollCode)==SB_PAGEUP))
{
return OnSmoothScroll(nScrollCode,nPos, bDoScroll);
}
// calc new x position
int x = GetScrollPos(SB_HORZ);
int xOrig = x;
switch (LOBYTE(nScrollCode))
{
case SB_TOP:
x = 0;
break;
case SB_BOTTOM:
x = INT_MAX;
break;
case SB_LINEUP:
x -= m_lineDev.cx;
break;
case SB_LINEDOWN:
x += m_lineDev.cx;
break;
case SB_PAGEUP:
x -= m_pageDev.cx;
break;
case SB_PAGEDOWN:
x += m_pageDev.cx;
break;
case SB_THUMBTRACK:
x = nPos;
break;
}
// calc new y position
int y = GetScrollPos(SB_VERT);
int yOrig = y;
switch (HIBYTE(nScrollCode))
{
case SB_TOP:
y = 0;
break;
case SB_BOTTOM:
y = INT_MAX;
break;
case SB_LINEUP:
y -= m_lineDev.cy;
break;
case SB_LINEDOWN:
y += m_lineDev.cy;
break;
case SB_PAGEUP:
y -= m_pageDev.cy;
break;
case SB_PAGEDOWN:
y += m_pageDev.cy;
break;
case SB_THUMBTRACK:
y = nPos;
break;
}
BOOL bResult = OnScrollBy(CSize(x - xOrig, y - yOrig), bDoScroll);
if (bResult && bDoScroll)
UpdateWindow();
return bResult;
}
BOOL COXScrollWnd::OnScrollBy(CSize sizeScroll, BOOL bDoScroll)
{
int xOrig, x;
int yOrig, y;
// don't scroll if there is no valid scroll range (ie. no scroll bar)
CScrollBar* pBar;
DWORD dwStyle = GetStyle();
pBar = GetScrollBarCtrl(SB_VERT);
if ((pBar != NULL && !pBar->IsWindowEnabled()) ||
(pBar == NULL && !(dwStyle & WS_VSCROLL)))
{
// vertical scroll bar not enabled
sizeScroll.cy = 0;
}
pBar = GetScrollBarCtrl(SB_HORZ);
if ((pBar != NULL && !pBar->IsWindowEnabled()) ||
(pBar == NULL && !(dwStyle & WS_HSCROLL)))
{
// horizontal scroll bar not enabled
sizeScroll.cx = 0;
}
// adjust current x position
xOrig = x = GetScrollPos(SB_HORZ);
int xMax = GetScrollLimit(SB_HORZ);
x += sizeScroll.cx;
if (x < 0)
x = 0;
else if (x > xMax)
x = xMax;
// adjust current y position
yOrig = y = GetScrollPos(SB_VERT);
int yMax = GetScrollLimit(SB_VERT);
y += sizeScroll.cy;
if (y < 0)
y = 0;
else if (y > yMax)
y = yMax;
// did anything change?
if (x == xOrig && y == yOrig)
return FALSE;
if (bDoScroll)
{
// do scroll and update scroll positions
ScrollWindow(-(x-xOrig), -(y-yOrig));
if (x != xOrig)
{
SetScrollPos(SB_HORZ, x);
}
if (y != yOrig)
{
SetScrollPos(SB_VERT, y);
}
}
return TRUE;
}
BOOL COXScrollWnd::OnSmoothScroll(UINT nScrollCode, UINT nPos, BOOL bDoScroll)
{
// TODO: Add your specialized code here and/or call the base class
ASSERT(IsSmoothScrolling());
if(m_bIsInSmoothScrolling)
return TRUE;
m_bIsInSmoothScrolling=TRUE;
//
// First handle left/right scroll messages. If scrolling by page,
// scroll m_nPageSlices times rather than 1. If scrolling by line,
// scroll m_nLineSlices times.
//
BYTE nCode=LOBYTE(nScrollCode);
if((nCode==SB_PAGELEFT) ||(nCode==SB_PAGERIGHT) ||
(nCode==SB_LINELEFT) ||(nCode==SB_LINERIGHT))
{
int nCount=0;
int nInc=0;
int nFinalInc=0;
int nLineCode=0;
switch(nCode)
{
case SB_PAGELEFT:
{
nLineCode=SB_LINELEFT;
nInc=m_pageDev.cx/m_nPageSlices;
nFinalInc=m_pageDev.cx%m_nPageSlices;
nCount=m_nPageSlices;
break;
}
case SB_PAGERIGHT:
{
nLineCode=SB_LINERIGHT;
nInc=m_pageDev.cx/m_nPageSlices;
nFinalInc=m_pageDev.cx%m_nPageSlices;
nCount=m_nPageSlices;
break;
}
case SB_LINELEFT:
{
nLineCode=SB_LINELEFT;
nInc=m_lineDev.cx/m_nLineSlices;
nFinalInc=m_lineDev.cx%m_nLineSlices;
nCount=m_nLineSlices;
break;
}
case SB_LINERIGHT:
{
nLineCode=SB_LINERIGHT;
nInc=m_lineDev.cx/m_nLineSlices;
nFinalInc=m_lineDev.cx%m_nLineSlices;
nCount=m_nLineSlices;
break;
}
}
int nOldLineSize=m_lineDev.cx;
BOOL bResult=FALSE;
DWORD dwTime=0;
while(nInc>0 && nCount--)
{
DWORD dwCurrentTime=::GetCurrentTime();
DWORD dwElapsedTime=dwCurrentTime-dwTime;
if(dwElapsedTime<m_dwWaitingTime)
{
::Sleep(m_dwWaitingTime-dwElapsedTime);
}
dwTime=dwCurrentTime;
m_lineDev.cx=nInc;
BOOL bScrolled=
COXScrollWnd::OnScroll(MAKEWORD(nLineCode,-1),nPos,bDoScroll);
m_lineDev.cx=nOldLineSize;
if(!bScrolled)
{
m_bIsInSmoothScrolling=FALSE;
return bResult;
}
bResult=TRUE;
}
if(nFinalInc)
{
m_lineDev.cx=nFinalInc;
if(!COXScrollWnd::OnScroll(MAKEWORD(nLineCode,-1),nPos))
bResult=TRUE;
}
m_lineDev.cx=nOldLineSize;
m_bIsInSmoothScrolling=FALSE;
return bResult;
}
//
// Next handle up/down scroll messages. If scrolling by page,
// scroll m_nPageSlices times rather than 1. If scrolling by line,
// scroll m_nLineSlices times.
//
nCode=HIBYTE(nScrollCode);
if((nCode==SB_PAGEUP) ||(nCode==SB_PAGEDOWN) ||
(nCode==SB_LINEUP) ||(nCode==SB_LINEDOWN))
{
int nCount=0;
int nInc=0;
int nFinalInc=0;
int nLineCode=0;
switch(nCode)
{
case SB_PAGEUP:
{
nLineCode=SB_LINEUP;
nInc=m_pageDev.cy/m_nPageSlices;
nFinalInc=m_pageDev.cy%m_nPageSlices;
nCount=m_nPageSlices;
break;
}
case SB_PAGEDOWN:
{
nLineCode=SB_LINEDOWN;
nInc=m_pageDev.cy/m_nPageSlices;
nFinalInc=m_pageDev.cy%m_nPageSlices;
nCount=m_nPageSlices;
break;
}
case SB_LINEUP:
{
nLineCode=SB_LINEUP;
nInc=m_lineDev.cy/m_nLineSlices;
nFinalInc=m_lineDev.cy%m_nLineSlices;
nCount=m_nLineSlices;
break;
}
case SB_LINEDOWN:
{
nLineCode=SB_LINEDOWN;
nInc=m_lineDev.cy/m_nLineSlices;
nFinalInc=m_lineDev.cy%m_nLineSlices;
nCount=m_nLineSlices;
break;
}
}
int nOldLineSize=m_lineDev.cy;
BOOL bResult=FALSE;
DWORD dwTime=0;
while(nInc>0 && nCount--)
{
DWORD dwCurrentTime=::GetCurrentTime();
DWORD dwElapsedTime=dwCurrentTime-dwTime;
if(dwElapsedTime<m_dwWaitingTime)
{
::Sleep(m_dwWaitingTime-dwElapsedTime);
}
dwTime=dwCurrentTime;
m_lineDev.cy=nInc;
BOOL bScrolled=COXScrollWnd::OnScroll(MAKEWORD(-1,nLineCode),nPos,bDoScroll);
m_lineDev.cy=nOldLineSize;
if(!bScrolled)
{
m_bIsInSmoothScrolling=FALSE;
return bResult;
}
bResult=TRUE;
}
if(nFinalInc)
{
m_lineDev.cy=nFinalInc;
if(!COXScrollWnd::OnScroll(MAKEWORD(-1,nLineCode),nPos,bDoScroll))
bResult=TRUE;
}
m_lineDev.cy=nOldLineSize;
m_bIsInSmoothScrolling=FALSE;
return bResult;
}
m_bIsInSmoothScrolling=FALSE;
return TRUE;
}
BOOL COXScrollWnd::OnMouseWheel(UINT fFlags, short zDelta, CPoint point)
{
// we don't handle anything but scrolling just now
if (fFlags & (MK_SHIFT | MK_CONTROL))
return FALSE;
// we can't get out of it--perform the scroll ourselves
return DoMouseWheel(fFlags, zDelta, point);
}
// This function isn't virtual. If you need to override it,
// you really need to override OnMouseWheel() here or in
// CSplitterWnd.
BOOL COXScrollWnd::DoMouseWheel(UINT fFlags, short zDelta, CPoint point)
{
UNUSED_ALWAYS(point);
UNUSED_ALWAYS(fFlags);
// if we have a vertical scroll bar, the wheel scrolls that
// if we have _only_ a horizontal scroll bar, the wheel scrolls that
// otherwise, don't do any work at all
DWORD dwStyle = GetStyle();
CScrollBar* pBar = GetScrollBarCtrl(SB_VERT);
BOOL bHasVertBar = ((pBar != NULL) && pBar->IsWindowEnabled()) ||
(dwStyle & WS_VSCROLL);
pBar = GetScrollBarCtrl(SB_HORZ);
BOOL bHasHorzBar = ((pBar != NULL) && pBar->IsWindowEnabled()) ||
(dwStyle & WS_HSCROLL);
if (!bHasVertBar && !bHasHorzBar)
return FALSE;
BOOL bResult = FALSE;
UINT uWheelScrollLines=GetMouseScrollLines();
int nToScroll;
int nDisplacement;
if (bHasVertBar)
{
nToScroll = ::MulDiv(-zDelta, uWheelScrollLines, WHEEL_DELTA);
if (nToScroll == -1 || uWheelScrollLines == WHEEL_PAGESCROLL)
{
nDisplacement = m_pageDev.cy;
if (zDelta > 0)
nDisplacement = -nDisplacement;
}
else
{
nDisplacement = nToScroll * m_lineDev.cy;
nDisplacement = min(nDisplacement, m_pageDev.cy);
}
bResult = OnScrollBy(CSize(0, nDisplacement), TRUE);
}
else if (bHasHorzBar)
{
nToScroll = ::MulDiv(-zDelta, uWheelScrollLines, WHEEL_DELTA);
if (nToScroll == -1 || uWheelScrollLines == WHEEL_PAGESCROLL)
{
nDisplacement = m_pageDev.cx;
if (zDelta > 0)
nDisplacement = -nDisplacement;
}
else
{
nDisplacement = nToScroll * m_lineDev.cx;
nDisplacement = min(nDisplacement, m_pageDev.cx);
}
bResult = OnScrollBy(CSize(nDisplacement, 0), TRUE);
}
if (bResult)
UpdateWindow();
return bResult;
}
static BOOL g_bGotScrollLines = FALSE;
UINT COXScrollWnd::GetMouseScrollLines()
{
static UINT uCachedScrollLines;
// if we've already got it and we're not refreshing,
// return what we've already got
if (g_bGotScrollLines)
return uCachedScrollLines;
// see if we can find the mouse window
g_bGotScrollLines = TRUE;
static UINT msgGetScrollLines;
static WORD nRegisteredMessage;
if (nRegisteredMessage == 0)
{
msgGetScrollLines = ::RegisterWindowMessage(MSH_SCROLL_LINES);
if (msgGetScrollLines == 0)
nRegisteredMessage = 1; // couldn't register! never try again
else
nRegisteredMessage = 2; // it worked: use it
}
if (nRegisteredMessage == 2)
{
HWND hwMouseWheel = NULL;
hwMouseWheel = ::FindWindow(MSH_WHEELMODULE_CLASS, MSH_WHEELMODULE_TITLE);
if (hwMouseWheel && msgGetScrollLines)
{
uCachedScrollLines = (UINT)
::SendMessage(hwMouseWheel, msgGetScrollLines, 0, 0);
return uCachedScrollLines;
}
}
// couldn't use the window -- try system settings
uCachedScrollLines = 3; // reasonable default
DWORD dwWinVersion = ::GetVersion();
if (dwWinVersion < 0x80000000) // Windows NT/2000/XP
{
HKEY hKey;
if (RegOpenKeyEx(HKEY_CURRENT_USER, _T("Control Panel\\Desktop"),
0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS)
{
TCHAR szData[128];
DWORD dwKeyDataType;
DWORD dwDataBufSize = _countof(szData);
if (RegQueryValueEx(hKey, _T("WheelScrollLines"), NULL, &dwKeyDataType,
(LPBYTE) &szData, &dwDataBufSize) == ERROR_SUCCESS)
{
uCachedScrollLines = _tcstoul(szData, NULL, 10);
}
RegCloseKey(hKey);
}
}
#if _MFC_VER>0x0421
else if (!afxData.bWin95)
#else
else if (!afxData.bWin32s)
#endif
{
::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &uCachedScrollLines, 0);
}
return uCachedScrollLines;
}
void COXScrollWnd::NormalToScaled(CRect* pRect)
{
int nZoomLevel=GetZoomLevel();
// scale coordinates from normal to scaled
// taking into account current zoom level
if(nZoomLevel!=100)
{
pRect->left=((long)((long)pRect->left*(long)nZoomLevel))/(100L);
pRect->top=((long)((long)pRect->top*(long)nZoomLevel))/(100L);
pRect->right=((long)((long)pRect->right*(long)nZoomLevel))/(100L);
pRect->bottom=((long)((long)pRect->bottom*(long)nZoomLevel))/(100L);
}
}
void COXScrollWnd::NormalToScaled(CPoint* pPoint)
{
int nZoomLevel=GetZoomLevel();
// scale coordinates from normal to scaled
// taking into account current zoom level
if(nZoomLevel!=100)
{
pPoint->x=((long)((long)pPoint->x*(long)nZoomLevel))/(100L);
pPoint->y=((long)((long)pPoint->y*(long)nZoomLevel))/(100L);
}
}
void COXScrollWnd::ScaledToNormal(CRect* pRect)
{
int nZoomLevel=GetZoomLevel();
// scale coordinates from scaled to normal
// taking into account current zoom level
if(nZoomLevel!=100)
{
pRect->left=((long)((long)pRect->left*100L))/((long)nZoomLevel);
pRect->top=((long)((long)pRect->top*100L))/((long)nZoomLevel);
pRect->right=((long)((long)pRect->right*100L))/((long)nZoomLevel);
pRect->bottom=((long)((long)pRect->bottom*100L))/((long)nZoomLevel);
}
}
void COXScrollWnd::ScaledToNormal(CPoint* pPoint)
{
int nZoomLevel=GetZoomLevel();
// scale coordinates from scaled to normal
// taking into account current zoom level
if(nZoomLevel!=100)
{
pPoint->x=((long)((long)pPoint->x*100L))/((long)nZoomLevel);
pPoint->y=((long)((long)pPoint->y*100L))/((long)nZoomLevel);
}
}
void COXScrollWnd::NormalToPrinted(CDC* pDC, CRect* pRect)
{
// scale coordinates from display to printer
// taking into account screen and current printer DPI
int xPrinterDPI=pDC->GetDeviceCaps(LOGPIXELSX);
int yPrinterDPI=pDC->GetDeviceCaps(LOGPIXELSY);
CClientDC dc(this);
int xScreenDPI=dc.GetDeviceCaps(LOGPIXELSX);
int yScreenDPI=dc.GetDeviceCaps(LOGPIXELSY);
if(xPrinterDPI!=xScreenDPI || yPrinterDPI!=yScreenDPI)
{
pRect->left=((long)((long)pRect->left*(long)xPrinterDPI))/((long)xScreenDPI);
pRect->top=((long)((long)pRect->top*(long)yPrinterDPI))/((long)yScreenDPI);
pRect->right=((long)((long)pRect->right*(long)xPrinterDPI))/((long)xScreenDPI);
pRect->bottom=((long)((long)pRect->bottom*(long)yPrinterDPI))/((long)yScreenDPI);
}
}
void COXScrollWnd::NormalToPrinted(CDC* pDC, CPoint* pPoint)
{
// scale coordinates from display to printer
// taking into account screen and current printer DPI
int xPrinterDPI=pDC->GetDeviceCaps(LOGPIXELSX);
int yPrinterDPI=pDC->GetDeviceCaps(LOGPIXELSY);
CClientDC dc(this);
int xScreenDPI=dc.GetDeviceCaps(LOGPIXELSX);
int yScreenDPI=dc.GetDeviceCaps(LOGPIXELSY);
if(xPrinterDPI!=xScreenDPI || yPrinterDPI!=yScreenDPI)
{
pPoint->x=((long)((long)pPoint->x*(long)xPrinterDPI))/
((long)xScreenDPI);
pPoint->y=((long)((long)pPoint->y*(long)yPrinterDPI))/
((long)yScreenDPI);
}
}
void COXScrollWnd::PrintedToNormal(CDC* pDC, CRect* pRect)
{
// scale coordinates from printer to display
// taking into account screen and current printer DPI
int xPrinterDPI=pDC->GetDeviceCaps(LOGPIXELSX);
int yPrinterDPI=pDC->GetDeviceCaps(LOGPIXELSY);
CClientDC dc(this);
int xScreenDPI=dc.GetDeviceCaps(LOGPIXELSX);
int yScreenDPI=dc.GetDeviceCaps(LOGPIXELSY);
if(xPrinterDPI!=xScreenDPI || yPrinterDPI!=yScreenDPI)
{
pRect->left=((long)((long)pRect->left*(long)xScreenDPI))/
((long)xPrinterDPI);
pRect->top=((long)((long)pRect->top*(long)yScreenDPI))/
((long)yPrinterDPI);
pRect->right=((long)((long)pRect->right*(long)xScreenDPI))/
((long)xPrinterDPI);
pRect->bottom=((long)((long)pRect->bottom*(long)yScreenDPI))/
((long)yPrinterDPI);
}
}
void COXScrollWnd::PrintedToNormal(CDC* pDC, CPoint* pPoint)
{
// scale coordinates from printer to display
// taking into account screen and current printer DPI
int xPrinterDPI=pDC->GetDeviceCaps(LOGPIXELSX);
int yPrinterDPI=pDC->GetDeviceCaps(LOGPIXELSY);
CClientDC dc(this);
int xScreenDPI=dc.GetDeviceCaps(LOGPIXELSX);
int yScreenDPI=dc.GetDeviceCaps(LOGPIXELSY);
if(xPrinterDPI!=xScreenDPI || yPrinterDPI!=yScreenDPI)
{
pPoint->x=((long)((long)pPoint->x*(long)xScreenDPI))/
((long)xPrinterDPI);
pPoint->y=((long)((long)pPoint->y*(long)yScreenDPI))/
((long)yPrinterDPI);
}
}
BOOL COXScrollWnd::SizeToContent()
{
CRect rectWindow;
GetWindowRect(rectWindow);
if(GetParent()!=NULL)
GetParent()->ScreenToClient(rectWindow);
CRect rectClient;
GetClientRect(rectClient);
CSize szTotal=GetTotalSize();
CRect rect(0,0,szTotal.cx,szTotal.cy);
NormalToScaled(&rect);
szTotal=rect.Size();
rectWindow.right=rectWindow.right+szTotal.cx-rectClient.Width();
rectWindow.bottom=rectWindow.bottom+szTotal.cy-rectClient.Height();
MoveWindow(rectWindow);
return TRUE;
}
void COXScrollWnd::SetContentsAlign(ContentsAlignment align)
{
m_alignContents=align;
RedrawWindow();
}
/////////////////////////////////////////////////////////////////////////////
// COXScrollWnd diagnostics
#ifdef _DEBUG
void COXScrollWnd::Dump(CDumpContext& dc) const
{
ASSERT_VALID(this);
CWnd::Dump(dc);
AFX_DUMP1(dc, "\nm_totalLog = ", m_totalLog);
AFX_DUMP1(dc, "\nm_totalDev = ", m_totalDev);
AFX_DUMP1(dc, "\nm_pageDev = ", m_pageDev);
AFX_DUMP1(dc, "\nm_lineDev = ", m_lineDev);
AFX_DUMP1(dc, "\nm_bInsideUpdate = ", m_bInsideUpdate);
AFX_DUMP0(dc, "\nm_nMapMode = ");
switch (m_nMapMode)
{
case MM_NONE:
AFX_DUMP0(dc, "MM_NONE");
break;
case MM_TEXT:
AFX_DUMP0(dc, "MM_TEXT");
break;
case MM_LOMETRIC:
AFX_DUMP0(dc, "MM_LOMETRIC");
break;
case MM_HIMETRIC:
AFX_DUMP0(dc, "MM_HIMETRIC");
break;
case MM_LOENGLISH:
AFX_DUMP0(dc, "MM_LOENGLISH");
break;
case MM_HIENGLISH:
AFX_DUMP0(dc, "MM_HIENGLISH");
break;
case MM_TWIPS:
AFX_DUMP0(dc, "MM_TWIPS");
break;
case MM_ANISOTROPIC:
AFX_DUMP0(dc, "MM_ANISOTROPIC");
AFX_DUMP1(dc, "\nm_sizeDev = ", m_sizeDev);
break;
default:
AFX_DUMP0(dc, "*unknown*");
break;
}
AFX_DUMP1(dc, "\nm_nZoomLevel = ", m_nZoomLevel);
AFX_DUMP1(dc, "\nm_bUseRelativeScrollSizes = ", m_bUseRelativeScrollSizes);
if( m_bUseRelativeScrollSizes )
{
AFX_DUMP1(dc, "\nm_nPagePercent = ", m_nPagePercent);
AFX_DUMP1(dc, "\nm_nLinePercent = ", m_nLinePercent);
}
AFX_DUMP0(dc, "\nm_align = ");
switch (m_align)
{
case ZA_TOPLEFT:
AFX_DUMP0(dc, "TOPLEFT");
break;
case ZA_BOTTOMLEFT:
AFX_DUMP0(dc, "BOTTOMLEFT");
break;
case ZA_CENTER:
AFX_DUMP0(dc, "CENTER");
break;
default:
AFX_DUMP0(dc, "*illegal*");
break;
}
}
void COXScrollWnd::AssertValid() const
{
CWnd::AssertValid();
switch (m_nMapMode)
{
case MM_NONE:
case MM_TEXT:
case MM_LOMETRIC:
case MM_HIMETRIC:
case MM_LOENGLISH:
case MM_HIENGLISH:
case MM_TWIPS:
case MM_ANISOTROPIC:
break;
case MM_ISOTROPIC:
ASSERT(FALSE); // illegal mapping mode
default:
ASSERT(FALSE); // unknown mapping mode
}
}
#endif //_DEBUG
Reference in New Issue View Git Blame Copy Permalink