ext/ResizableLib/ResizableMinMax.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 //
   3 // This file is part of ResizableLib
   4 // http://sourceforge.net/projects/resizablelib
   5 //
   6 // Copyright (C) 2000-2004 by Paolo Messina
   7 // http://www.geocities.com/ppescher - mailto:ppescher@hotmail.com
   8 //
   9 // The contents of this file are subject to the Artistic License (the "License").
  10 // You may not use this file except in compliance with the License.
  11 // You may obtain a copy of the License at:
  12 // http://www.opensource.org/licenses/artistic-license.html
  13 //
  14 // If you find this code useful, credits would be nice!
  15 //
  16 /////////////////////////////////////////////////////////////////////////////
  17
  18 /*!
  19  *  @file
  20  *  @brief Implementation of the CResizableMinMax class.
  21  */
  22
  23 #include "stdafx.h"
  24 #include "ResizableMinMax.h"
  25
  26 #ifdef _DEBUG
  27 #undef THIS_FILE
  28 static char THIS_FILE[]=__FILE__;
  29 #define new DEBUG_NEW
  30 #endif
  31
  32 //////////////////////////////////////////////////////////////////////
  33 // Construction/Destruction
  34 //////////////////////////////////////////////////////////////////////
  35
  36 CResizableMinMax::CResizableMinMax()
  37 {
  38         m_bUseMinTrack = FALSE;
  39         m_bUseMaxTrack = FALSE;
  40         m_bUseMaxRect = FALSE;
  41 }
  42
  43 CResizableMinMax::~CResizableMinMax()
  44 {
  45
  46 }
  47
  48 void CResizableMinMax::MinMaxInfo(LPMINMAXINFO lpMMI)
  49 {
  50         if (m_bUseMinTrack)
  51                 lpMMI->ptMinTrackSize = m_ptMinTrackSize;
  52
  53         if (m_bUseMaxTrack)
  54                 lpMMI->ptMaxTrackSize = m_ptMaxTrackSize;
  55
  56         if (m_bUseMaxRect)
  57         {
  58                 lpMMI->ptMaxPosition = m_ptMaxPos;
  59                 lpMMI->ptMaxSize = m_ptMaxSize;
  60         }
  61 }
  62
  63 void CResizableMinMax::ChainMinMaxInfo(LPMINMAXINFO lpMMI, CWnd* pParentFrame, CWnd* pWnd)
  64 {
  65         // get the extra size from child to parent
  66         CRect rectClient, rectWnd;
  67         if ((pParentFrame->GetStyle() & WS_CHILD) && pParentFrame->IsZoomed())
  68                 pParentFrame->GetClientRect(rectWnd);
  69         else
  70                 pParentFrame->GetWindowRect(rectWnd);
  71         pParentFrame->RepositionBars(0, 0xFFFF,
  72                 AFX_IDW_PANE_FIRST, CWnd::reposQuery, rectClient);
  73         CSize sizeExtra = rectWnd.Size() - rectClient.Size();
  74
  75         ChainMinMaxInfo(lpMMI, pWnd->GetSafeHwnd(), sizeExtra);
  76 }
  77
  78 void CResizableMinMax::ChainMinMaxInfo(LPMINMAXINFO lpMMI, HWND hWndChild, CSize sizeExtra)
  79 {
  80         // ask the child window for track size
  81         MINMAXINFO mmiChild = *lpMMI;
  82         ::SendMessage(hWndChild, WM_GETMINMAXINFO, 0, (LPARAM)&mmiChild);
  83         BOOL bRetMax = (lpMMI->ptMaxTrackSize.x != mmiChild.ptMaxTrackSize.x
  84                 || lpMMI->ptMaxTrackSize.y != mmiChild.ptMaxTrackSize.y);
  85         BOOL bRetMin = (lpMMI->ptMinTrackSize.x != mmiChild.ptMinTrackSize.x
  86                 || lpMMI->ptMinTrackSize.y != mmiChild.ptMinTrackSize.y);
  87
  88         // add static extra size
  89         mmiChild.ptMaxTrackSize = sizeExtra + mmiChild.ptMaxTrackSize;
  90         mmiChild.ptMinTrackSize = sizeExtra + mmiChild.ptMinTrackSize;
  91
  92         // min size is the largest
  93         if (bRetMin)
  94         {
  95                 lpMMI->ptMinTrackSize.x = __max(lpMMI->ptMinTrackSize.x,
  96                         mmiChild.ptMinTrackSize.x);
  97                 lpMMI->ptMinTrackSize.y = __max(lpMMI->ptMinTrackSize.y,
  98                         mmiChild.ptMinTrackSize.y);
  99         }
 100         // max size is the shortest
 101         if (bRetMax)
 102         {
 103                 lpMMI->ptMaxTrackSize.x = __min(lpMMI->ptMaxTrackSize.x,
 104                         mmiChild.ptMaxTrackSize.x);
 105                 lpMMI->ptMaxTrackSize.y = __min(lpMMI->ptMaxTrackSize.y,
 106                         mmiChild.ptMaxTrackSize.y);
 107         }
 108 }
 109
 110 BOOL CResizableMinMax::CalcSizeExtra(HWND /*hWndChild*/, CSize /*sizeChild*/, CSize& /*sizeExtra*/)
 111 {
 112         // should be overridden if you use ChainMinMaxInfoCB
 113         ASSERT(FALSE);
 114         return FALSE;
 115 }
 116
 117 void CResizableMinMax::ChainMinMaxInfoCB(LPMINMAXINFO lpMMI, HWND hWndChild)
 118 {
 119         // ask the child window for track size
 120         MINMAXINFO mmiChild = *lpMMI;
 121         ::SendMessage(hWndChild, WM_GETMINMAXINFO, 0, (LPARAM)&mmiChild);
 122         BOOL bRetMax = (lpMMI->ptMaxTrackSize.x != mmiChild.ptMaxTrackSize.x
 123                 || lpMMI->ptMaxTrackSize.y != mmiChild.ptMaxTrackSize.y);
 124         BOOL bRetMin = (lpMMI->ptMinTrackSize.x != mmiChild.ptMinTrackSize.x
 125                 || lpMMI->ptMinTrackSize.y != mmiChild.ptMinTrackSize.y);
 126
 127         // use a callback to determine extra size
 128         CSize sizeExtra(0, 0);
 129         bRetMax = bRetMax && CalcSizeExtra(hWndChild, mmiChild.ptMaxTrackSize, sizeExtra);
 130         mmiChild.ptMaxTrackSize = sizeExtra + mmiChild.ptMaxTrackSize;
 131         bRetMin = bRetMin && CalcSizeExtra(hWndChild, mmiChild.ptMinTrackSize, sizeExtra);
 132         mmiChild.ptMinTrackSize = sizeExtra + mmiChild.ptMinTrackSize;
 133
 134         // min size is the largest
 135         if (bRetMin)
 136         {
 137                 lpMMI->ptMinTrackSize.x = __max(lpMMI->ptMinTrackSize.x,
 138                         mmiChild.ptMinTrackSize.x);
 139                 lpMMI->ptMinTrackSize.y = __max(lpMMI->ptMinTrackSize.y,
 140                         mmiChild.ptMinTrackSize.y);
 141         }
 142         // max size is the shortest
 143         if (bRetMax)
 144         {
 145                 lpMMI->ptMaxTrackSize.x = __min(lpMMI->ptMaxTrackSize.x,
 146                         mmiChild.ptMaxTrackSize.x);
 147                 lpMMI->ptMaxTrackSize.y = __min(lpMMI->ptMaxTrackSize.y,
 148                         mmiChild.ptMaxTrackSize.y);
 149         }
 150 }
 151
 152 void CResizableMinMax::SetMaximizedRect(const CRect& rc)
 153 {
 154         m_bUseMaxRect = TRUE;
 155
 156         m_ptMaxPos = rc.TopLeft();
 157         m_ptMaxSize.x = rc.Width();
 158         m_ptMaxSize.y = rc.Height();
 159 }
 160
 161 void CResizableMinMax::ResetMaximizedRect()
 162 {
 163         m_bUseMaxRect = FALSE;
 164 }
 165
 166 void CResizableMinMax::SetMinTrackSize(const CSize& size)
 167 {
 168         m_bUseMinTrack = TRUE;
 169
 170         m_ptMinTrackSize.x = size.cx;
 171         m_ptMinTrackSize.y = size.cy;
 172 }
 173
 174 void CResizableMinMax::ResetMinTrackSize()
 175 {
 176         m_bUseMinTrack = FALSE;
 177 }
 178
 179 void CResizableMinMax::SetMaxTrackSize(const CSize& size)
 180 {
 181         m_bUseMaxTrack = TRUE;
 182
 183         m_ptMaxTrackSize.x = size.cx;
 184         m_ptMaxTrackSize.y = size.cy;
 185 }
 186
 187 void CResizableMinMax::ResetMaxTrackSize()
 188 {
 189         m_bUseMaxTrack = FALSE;
 190 }