#include "StdAfx.h"
#include "UIContainer.h"


/////////////////////////////////////////////////////////////////////////////////////
//
//

CContainerUI::CContainerUI() : 
   m_hwndScroll(NULL), 
   m_iPadding(0),
   m_iScrollPos(0),
   m_bAutoDestroy(true),
   m_bAllowScrollbars(false)
{
   m_cxyFixed.cx = m_cxyFixed.cy = 0;
   ::ZeroMemory(&m_rcInset, sizeof(m_rcInset));
}

CContainerUI::~CContainerUI()
{
   RemoveAll();
}

LPCTSTR CContainerUI::GetClass() const
{
   return _T("ContainerUI");
}

LPVOID CContainerUI::GetInterface(LPCTSTR pstrName)
{
   if( _tcscmp(pstrName, _T("Container")) == 0 ) return static_cast<IContainerUI*>(this);
   return CControlUI::GetInterface(pstrName);
}

CControlUI* CContainerUI::GetItem(int iIndex) const
{
   if( iIndex < 0 || iIndex >= m_items.GetSize() ) return NULL;
   return static_cast<CControlUI*>(m_items[iIndex]);
}

int CContainerUI::GetCount() const
{
   return m_items.GetSize();
}

bool CContainerUI::Add(CControlUI* pControl)
{
   if( m_pManager != NULL ) m_pManager->InitControls(pControl, this);
   if( m_pManager != NULL ) m_pManager->UpdateLayout();
   return m_items.Add(pControl);
}

bool CContainerUI::Remove(CControlUI* pControl)
{
   for( int it = 0; m_bAutoDestroy && it < m_items.GetSize(); it++ ) {
      if( static_cast<CControlUI*>(m_items[it]) == pControl ) {
         if( m_pManager != NULL ) m_pManager->UpdateLayout();
         delete pControl;
         return m_items.Remove(it);
      }
   }
   return false;
}

void CContainerUI::RemoveAll()
{
   for( int it = 0; m_bAutoDestroy && it < m_items.GetSize(); it++ ) delete static_cast<CControlUI*>(m_items[it]);
   m_items.Empty();
   m_iScrollPos = 0;
   if( m_pManager != NULL ) m_pManager->UpdateLayout();
}

void CContainerUI::SetAutoDestroy(bool bAuto)
{
   m_bAutoDestroy = bAuto;
}

void CContainerUI::SetInset(SIZE szInset)
{
   m_rcInset.left = m_rcInset.right = szInset.cx;
   m_rcInset.top = m_rcInset.bottom = szInset.cy;
}

void CContainerUI::SetInset(RECT rcInset)
{
   m_rcInset = rcInset;
}

void CContainerUI::SetPadding(int iPadding)
{
   m_iPadding = iPadding;
}

void CContainerUI::SetWidth(int cx)
{
   m_cxyFixed.cx = cx;
}

void CContainerUI::SetHeight(int cy)
{
   m_cxyFixed.cy = cy;
}

void CContainerUI::SetVisible(bool bVisible)
{
   // Hide possible scrollbar control
   if( m_hwndScroll != NULL ) ::ShowScrollBar(m_hwndScroll, SB_CTL, bVisible);
   // Hide children as well
   for( int it = 0; it < m_items.GetSize(); it++ ) {
      static_cast<CControlUI*>(m_items[it])->SetVisible(bVisible);
   }
   CControlUI::SetVisible(bVisible);
}

void CContainerUI::Event(TEventUI& event)
{
   if( m_hwndScroll != NULL ) 
   {
      if( event.Type == UIEVENT_VSCROLL ) 
      {
         switch( LOWORD(event.wParam) ) {
         case SB_THUMBPOSITION:
         case SB_THUMBTRACK:
            {
               SCROLLINFO si = { 0 };
               si.cbSize = sizeof(SCROLLINFO);
               si.fMask = SIF_TRACKPOS;
               ::GetScrollInfo(m_hwndScroll, SB_CTL, &si);
               SetScrollPos(si.nTrackPos);
            }
            break;
         case SB_LINEUP:
            SetScrollPos(GetScrollPos() - 5);
            break;
         case SB_LINEDOWN:
            SetScrollPos(GetScrollPos() + 5);
            break;
         case SB_PAGEUP:
            SetScrollPos(GetScrollPos() - GetScrollPage());
            break;
         case SB_PAGEDOWN:
            SetScrollPos(GetScrollPos() + GetScrollPage());
            break;
         }
      }
      if( event.Type == UIEVENT_KEYDOWN ) 
      {
         switch( event.chKey ) {
         case VK_DOWN:
            SetScrollPos(GetScrollPos() + 5);
            return;
         case VK_UP:
            SetScrollPos(GetScrollPos() - 5);
            return;
         case VK_NEXT:
            SetScrollPos(GetScrollPos() + GetScrollPage());
            return;
         case VK_PRIOR:
            SetScrollPos(GetScrollPos() - GetScrollPage());
            return;
         case VK_HOME:
            SetScrollPos(0);
            return;
         case VK_END:
            SetScrollPos(9999);
            return;
         }
      }
   }
   CControlUI::Event(event);
}

int CContainerUI::GetScrollPos() const
{
   return m_iScrollPos;
}

int CContainerUI::GetScrollPage() const
{
   // TODO: Determine this dynamically
   return 40;
}

SIZE CContainerUI::GetScrollRange() const
{
   if( m_hwndScroll == NULL ) return CSize();
   int cx = 0, cy = 0;
   ::GetScrollRange(m_hwndScroll, SB_CTL, &cx, &cy);
   return CSize(cx, cy);
}

void CContainerUI::SetScrollPos(int iScrollPos)
{
   if( m_hwndScroll == NULL ) return;
   int iRange1 = 0, iRange2 = 0;
   ::GetScrollRange(m_hwndScroll, SB_CTL, &iRange1, &iRange2);
   iScrollPos = CLAMP(iScrollPos, iRange1, iRange2);
   ::SetScrollPos(m_hwndScroll, SB_CTL, iScrollPos, TRUE);
   m_iScrollPos = ::GetScrollPos(m_hwndScroll, SB_CTL);
   // Reposition children to the new viewport.
   SetPos(m_rcItem);
   Invalidate();
}

void CContainerUI::EnableScrollBar(bool bEnable)
{
   if( m_bAllowScrollbars == bEnable ) return;
   m_iScrollPos = 0;
   m_bAllowScrollbars = bEnable;
}

int CContainerUI::FindSelectable(int iIndex, bool bForward /*= true*/) const
{
   // NOTE: This is actually a helper-function for the list/combo/ect controls
   //       that allow them to find the next enabled/available selectable item
   if( GetCount() == 0 ) return -1;
   iIndex = CLAMP(iIndex, 0, GetCount() - 1);
   if( bForward ) {
      for( int i = iIndex; i < GetCount(); i++ ) {
         if( GetItem(i)->GetInterface(_T("ListItem")) != NULL 
             && GetItem(i)->IsVisible()
             && GetItem(i)->IsEnabled() ) return i;
      }
      return -1;
   }
   else {
      for( int i = iIndex; i >= 0; --i ) {
         if( GetItem(i)->GetInterface(_T("ListItem")) != NULL 
             && GetItem(i)->IsVisible()
             && GetItem(i)->IsEnabled() ) return i;
      }
      return FindSelectable(0, true);
   }
}

void CContainerUI::SetPos(RECT rc)
{
   CControlUI::SetPos(rc);
   if( m_items.IsEmpty() ) return;
   rc.left += m_rcInset.left;
   rc.top += m_rcInset.top;
   rc.right -= m_rcInset.right;
   rc.bottom -= m_rcInset.bottom;
   // We'll position the first child in the entire client area.
   // Do not leave a container empty.
   ASSERT(m_items.GetSize()==1);
   static_cast<CControlUI*>(m_items[0])->SetPos(rc);
}

SIZE CContainerUI::EstimateSize(SIZE /*szAvailable*/)
{
   return m_cxyFixed;
}

void CContainerUI::SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue)
{
   if( _tcscmp(pstrName, _T("inset")) == 0 ) SetInset(CSize(_ttoi(pstrValue), _ttoi(pstrValue)));
   else if( _tcscmp(pstrName, _T("padding")) == 0 ) SetPadding(_ttoi(pstrValue));
   else if( _tcscmp(pstrName, _T("width")) == 0 ) SetWidth(_ttoi(pstrValue));
   else if( _tcscmp(pstrName, _T("height")) == 0 ) SetHeight(_ttoi(pstrValue));
   else if( _tcscmp(pstrName, _T("scrollbar")) == 0 ) EnableScrollBar(_tcscmp(pstrValue, _T("true")) == 0);
   else CControlUI::SetAttribute(pstrName, pstrValue);
}

void CContainerUI::SetManager(CPaintManagerUI* pManager, CControlUI* pParent)
{
   for( int it = 0; it < m_items.GetSize(); it++ ) {
      static_cast<CControlUI*>(m_items[it])->SetManager(pManager, this);
   }
   CControlUI::SetManager(pManager, pParent);
}

CControlUI* CContainerUI::FindControl(FINDCONTROLPROC Proc, LPVOID pData, UINT uFlags)
{
   // Check if this guy is valid
   if( (uFlags & UIFIND_VISIBLE) != 0 && !IsVisible() ) return NULL;
   if( (uFlags & UIFIND_ENABLED) != 0 && !IsEnabled() ) return NULL;
   if( (uFlags & UIFIND_HITTEST) != 0 && !::PtInRect(&m_rcItem, *(static_cast<LPPOINT>(pData))) ) return NULL;
   if( (uFlags & UIFIND_ME_FIRST) != 0 ) {
      CControlUI* pControl = CControlUI::FindControl(Proc, pData, uFlags);
      if( pControl != NULL ) return pControl;
   }
   for( int it = 0; it != m_items.GetSize(); it++ ) {
      CControlUI* pControl = static_cast<CControlUI*>(m_items[it])->FindControl(Proc, pData, uFlags);
      if( pControl != NULL ) return pControl;
   }
   return CControlUI::FindControl(Proc, pData, uFlags);
}

void CContainerUI::DoPaint(HDC hDC, const RECT& rcPaint)
{
   RECT rcTemp = { 0 };
   if( !::IntersectRect(&rcTemp, &rcPaint, &m_rcItem) ) return;

   CRenderClip clip;
   CBlueRenderEngineUI::GenerateClip(hDC, m_rcItem, clip);

   for( int it = 0; it < m_items.GetSize(); it++ ) {
      CControlUI* pControl = static_cast<CControlUI*>(m_items[it]);
      if( !pControl->IsVisible() ) continue;
      if( !::IntersectRect(&rcTemp, &rcPaint, &pControl->GetPos()) ) continue;
      if( !::IntersectRect(&rcTemp, &m_rcItem, &pControl->GetPos()) ) continue;
      pControl->DoPaint(hDC, rcPaint);
   }
}

void CContainerUI::ProcessScrollbar(RECT rc, int cyRequired)
{
   // Need the scrollbar control, but it's been created already?
   if( cyRequired > rc.bottom - rc.top && m_hwndScroll == NULL && m_bAllowScrollbars ) {
      m_hwndScroll = ::CreateWindowEx(0, WC_SCROLLBAR, NULL, WS_CHILD | SBS_VERT, 0, 0, 0, 0, m_pManager->GetPaintWindow(), NULL, m_pManager->GetResourceInstance(), NULL);
      ASSERT(::IsWindow(m_hwndScroll));
      ::SetProp(m_hwndScroll, "WndX", static_cast<HANDLE>(this));
      ::SetScrollPos(m_hwndScroll, SB_CTL, 0, TRUE);
      ::ShowWindow(m_hwndScroll, SW_SHOWNOACTIVATE);
      SetPos(m_rcItem);
      return;
   }
   // No scrollbar required
   if( m_hwndScroll == NULL ) return;
   // Move it into place
   int cxScroll = m_pManager->GetSystemMetrics().cxvscroll;
   ::MoveWindow(m_hwndScroll, rc.right, rc.top, cxScroll, rc.bottom - rc.top, TRUE);
   // Scroll not needed anymore?
   int cyScroll = cyRequired - (rc.bottom - rc.top);
   if( cyScroll < 0 ) {
      if( m_iScrollPos != 0 ) SetScrollPos(0);
      cyScroll = 0;
   }
   // Scroll range changed?
   int cyOld1, cyOld2;
   ::GetScrollRange(m_hwndScroll, SB_CTL, &cyOld1, &cyOld2);
   if( cyOld2 != cyScroll ) {
      ::SetScrollRange(m_hwndScroll, SB_CTL, 0, cyScroll, FALSE);
      ::EnableScrollBar(m_hwndScroll, SB_CTL, cyScroll == 0 ? ESB_DISABLE_BOTH : ESB_ENABLE_BOTH);
   }
}


/////////////////////////////////////////////////////////////////////////////////////
//
//

CCanvasUI::CCanvasUI() : m_hBitmap(NULL), m_iOrientation(HTBOTTOMRIGHT)
{
}

CCanvasUI::~CCanvasUI()
{
   if( m_hBitmap != NULL ) ::DeleteObject(m_hBitmap);
}

LPCTSTR CCanvasUI::GetClass() const
{
   return _T("CanvasUI");
}

bool CCanvasUI::SetWatermark(UINT iBitmapRes, int iOrientation)
{
   return SetWatermark(MAKEINTRESOURCE(iBitmapRes), iOrientation);
}

bool CCanvasUI::SetWatermark(LPCTSTR pstrBitmap, int iOrientation)
{
   if( m_hBitmap != NULL ) ::DeleteObject(m_hBitmap);
   m_hBitmap = (HBITMAP) ::LoadImage(m_pManager->GetResourceInstance(), pstrBitmap, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION);
   ASSERT(m_hBitmap!=NULL);
   if( m_hBitmap == NULL ) return false;
   ::GetObject(m_hBitmap, sizeof(BITMAP), &m_BitmapInfo);
   m_iOrientation = iOrientation;
   Invalidate();
   return true;
}

void CCanvasUI::DoPaint(HDC hDC, const RECT& rcPaint)
{
   // Fill background
   RECT rcFill = { 0 };
   if( ::IntersectRect(&rcFill, &rcPaint, &m_rcItem) ) {
      CBlueRenderEngineUI::DoFillRect(hDC, m_pManager, rcFill, m_clrBack);
   }
   // Paint watermark bitmap
   if( m_hBitmap != NULL ) {
      RECT rcBitmap = { 0 };
      switch( m_iOrientation ) {
      case HTTOPRIGHT:
         ::SetRect(&rcBitmap, m_rcItem.right - m_BitmapInfo.bmWidth, m_rcItem.top, m_rcItem.right, m_rcItem.top + m_BitmapInfo.bmHeight);
         break;
      case HTBOTTOMRIGHT:
         ::SetRect(&rcBitmap, m_rcItem.right - m_BitmapInfo.bmWidth, m_rcItem.bottom - m_BitmapInfo.bmHeight, m_rcItem.right, m_rcItem.bottom);
         break;
      default:
         ::SetRect(&rcBitmap, m_rcItem.right - m_BitmapInfo.bmWidth, m_rcItem.bottom - m_BitmapInfo.bmHeight, m_rcItem.right, m_rcItem.bottom);
         break;
      }
      RECT rcTemp = { 0 };
      if( ::IntersectRect(&rcTemp, &rcPaint, &rcBitmap) ) {
         CRenderClip clip;
         CBlueRenderEngineUI::GenerateClip(hDC, m_rcItem, clip);
         CBlueRenderEngineUI::DoPaintBitmap(hDC, m_pManager, m_hBitmap, rcBitmap);
      }
   }
   CContainerUI::DoPaint(hDC, rcPaint);
}

void CCanvasUI::SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue)
{
   if( _tcscmp(pstrName, _T("watermark")) == 0 ) SetWatermark(pstrValue);
   else CContainerUI::SetAttribute(pstrName, pstrValue);
}


/////////////////////////////////////////////////////////////////////////////////////
//
//

CWindowCanvasUI::CWindowCanvasUI()
{
   SetInset(CSize(10, 10));
   m_clrBack = m_pManager->GetThemeColor(UICOLOR_WINDOW_BACKGROUND);
}

LPCTSTR CWindowCanvasUI::GetClass() const
{
   return _T("WindowCanvasUI");
}


/////////////////////////////////////////////////////////////////////////////////////
//
//

CControlCanvasUI::CControlCanvasUI()
{
   SetInset(CSize(0, 0));
   m_clrBack = m_pManager->GetThemeColor(UICOLOR_CONTROL_BACKGROUND_NORMAL);
}

LPCTSTR CControlCanvasUI::GetClass() const
{
   return _T("ControlCanvasUI");
}


/////////////////////////////////////////////////////////////////////////////////////
//
//

CWhiteCanvasUI::CWhiteCanvasUI()
{
   SetInset(CSize(0, 0));
   m_clrBack = m_pManager->GetThemeColor(UICOLOR_STANDARD_WHITE);
}

LPCTSTR CWhiteCanvasUI::GetClass() const
{
   return _T("WhiteCanvasUI");
}


/////////////////////////////////////////////////////////////////////////////////////
//
//

CDialogCanvasUI::CDialogCanvasUI()
{
   SetInset(CSize(10, 10));
   m_clrBack = m_pManager->GetThemeColor(UICOLOR_DIALOG_BACKGROUND);
}

LPCTSTR CDialogCanvasUI::GetClass() const
{
   return _T("DialogCanvasUI");
}


/////////////////////////////////////////////////////////////////////////////////////
//
//

CTabFolderCanvasUI::CTabFolderCanvasUI()
{
   SetInset(CSize(0, 0));
   COLORREF clrColor1;
   m_pManager->GetThemeColorPair(UICOLOR_TAB_FOLDER_NORMAL, clrColor1, m_clrBack);
}

LPCTSTR CTabFolderCanvasUI::GetClass() const
{
   return _T("TabFolderCanvasUI");
}


/////////////////////////////////////////////////////////////////////////////////////
//
//

CVerticalLayoutUI::CVerticalLayoutUI() : m_cyNeeded(0)
{
}

LPCTSTR CVerticalLayoutUI::GetClass() const
{
   return _T("VertialLayoutUI");
}

void CVerticalLayoutUI::SetPos(RECT rc)
{
   m_rcItem = rc;
   // Adjust for inset
   rc.left += m_rcInset.left;
   rc.top += m_rcInset.top;
   rc.right -= m_rcInset.right;
   rc.bottom -= m_rcInset.bottom;
   if( m_hwndScroll != NULL ) rc.right -= m_pManager->GetSystemMetrics().cxvscroll;
   // Determine the minimum size
   SIZE szAvailable = { rc.right - rc.left, rc.bottom - rc.top };
   int nAdjustables = 0;
   int cyFixed = 0;
   for( int it1 = 0; it1 < m_items.GetSize(); it1++ ) {
      CControlUI* pControl = static_cast<CControlUI*>(m_items[it1]);
      if( !pControl->IsVisible() ) continue;
      SIZE sz = pControl->EstimateSize(szAvailable);
      if( sz.cy == 0 ) nAdjustables++;
      cyFixed += sz.cy + m_iPadding;
   }
   // Place elements
   int cyNeeded = 0;
   int cyExpand = 0;
   if( nAdjustables > 0 ) cyExpand = MAX(0, (szAvailable.cy - cyFixed) / nAdjustables);
   // Position the elements
   SIZE szRemaining = szAvailable;
   int iPosY = rc.top - m_iScrollPos;
   int iAdjustable = 0;
   for( int it2 = 0; it2 < m_items.GetSize(); it2++ ) {
      CControlUI* pControl = static_cast<CControlUI*>(m_items[it2]);
      if( !pControl->IsVisible() ) continue;
      SIZE sz = pControl->EstimateSize(szRemaining);
      if( sz.cy == 0 ) {
         iAdjustable++;
         sz.cy = cyExpand;
         // Distribute remaining to last element (usually round-off left-overs)
         if( iAdjustable == nAdjustables ) sz.cy += MAX(0, szAvailable.cy - (cyExpand * nAdjustables) - cyFixed);
      }
      RECT rcCtrl = { rc.left, iPosY, rc.right, iPosY + sz.cy };
      pControl->SetPos(rcCtrl);
      iPosY += sz.cy + m_iPadding;
      cyNeeded += sz.cy + m_iPadding;
      szRemaining.cy -= sz.cy + m_iPadding;
   }
   // Handle overflow with scrollbars
   ProcessScrollbar(rc, cyNeeded);
}


/////////////////////////////////////////////////////////////////////////////////////
//
//

CHorizontalLayoutUI::CHorizontalLayoutUI()
{
}

LPCTSTR CHorizontalLayoutUI::GetClass() const
{
   return _T("HorizontalLayoutUI");
}

void CHorizontalLayoutUI::SetPos(RECT rc)
{
   m_rcItem = rc;
   // Adjust for inset
   rc.left += m_rcInset.left;
   rc.top += m_rcInset.top;
   rc.right -= m_rcInset.right;
   rc.bottom -= m_rcInset.bottom;
   // Determine the width of elements that are sizeable
   SIZE szAvailable = { rc.right - rc.left, rc.bottom - rc.top };
   int nAdjustables = 0;
   int cxFixed = 0;
   for( int it1 = 0; it1 < m_items.GetSize(); it1++ ) {
      CControlUI* pControl = static_cast<CControlUI*>(m_items[it1]);
      if( !pControl->IsVisible() ) continue;
      SIZE sz = pControl->EstimateSize(szAvailable);
      if( sz.cx == 0 ) nAdjustables++;
      cxFixed += sz.cx + m_iPadding;
   }
   int cxExpand = 0;
   if( nAdjustables > 0 ) cxExpand = MAX(0, (szAvailable.cx - cxFixed) / nAdjustables);
   // Position the elements
   SIZE szRemaining = szAvailable;
   int iPosX = rc.left;
   int iAdjustable = 0;
   for( int it2 = 0; it2 < m_items.GetSize(); it2++ ) {
      CControlUI* pControl = static_cast<CControlUI*>(m_items[it2]);
      if( !pControl->IsVisible() ) continue;
      SIZE sz = pControl->EstimateSize(szRemaining);
      if( sz.cx == 0 ) {
         iAdjustable++;
         sz.cx = cxExpand;
         if( iAdjustable == nAdjustables ) sz.cx += MAX(0, szAvailable.cx - (cxExpand * nAdjustables) - cxFixed);
      }
      RECT rcCtrl = { iPosX, rc.top, iPosX + sz.cx, rc.bottom };
      pControl->SetPos(rcCtrl);
      iPosX += sz.cx + m_iPadding;
      szRemaining.cx -= sz.cx + m_iPadding;
   }
}


/////////////////////////////////////////////////////////////////////////////////////
//
//

CTileLayoutUI::CTileLayoutUI() : m_nColumns(2), m_cyNeeded(0)
{
   SetPadding(10);
   SetInset(CSize(10, 10));
}

LPCTSTR CTileLayoutUI::GetClass() const
{
   return _T("TileLayoutUI");
}

void CTileLayoutUI::SetColumns(int nCols)
{
   if( nCols <= 0 ) return;
   m_nColumns = nCols;
   UpdateLayout();
}

void CTileLayoutUI::SetPos(RECT rc)
{
   m_rcItem = rc;
   // Adjust for inset
   rc.left += m_rcInset.left;
   rc.top += m_rcInset.top;
   rc.right -= m_rcInset.right;
   rc.bottom -= m_rcInset.bottom;
   if( m_hwndScroll != NULL ) rc.right -= m_pManager->GetSystemMetrics().cxvscroll;
   // Position the elements
   int cxWidth = (rc.right - rc.left) / m_nColumns;
   int cyHeight = 0;
   int iCount = 0;
   POINT ptTile = { rc.left, rc.top - m_iScrollPos };
   for( int it1 = 0; it1 < m_items.GetSize(); it1++ ) {
      CControlUI* pControl = static_cast<CControlUI*>(m_items[it1]);
      if( !pControl->IsVisible() ) continue;
      // Determine size
      RECT rcTile = { ptTile.x, ptTile.y, ptTile.x + cxWidth, ptTile.y };
      // Adjust with element padding
      if( (iCount % m_nColumns) == 0 ) rcTile.right -= m_iPadding / 2;
      else if( (iCount % m_nColumns) == m_nColumns - 1 ) rcTile.left += m_iPadding / 2;
      else ::InflateRect(&rcTile, -(m_iPadding / 2), 0);
      // If this panel expands vertically
      if( m_cxyFixed.cy == 0) {
         SIZE szAvailable = { rcTile.right - rcTile.left, 9999 };
         int iIndex = iCount;
         for( int it2 = it1; it2 < m_items.GetSize(); it2++ ) {
            SIZE szTile = static_cast<CControlUI*>(m_items[it2])->EstimateSize(szAvailable);
            cyHeight = MAX(cyHeight, szTile.cy);
            if( (++iIndex % m_nColumns) == 0) break;
         }
      }
      // Set position
      rcTile.bottom = rcTile.top + cyHeight;
      pControl->SetPos(rcTile);
      // Move along...
      if( (++iCount % m_nColumns) == 0 ) {
         ptTile.x = rc.left;
         ptTile.y += cyHeight + m_iPadding;
         cyHeight = 0;
      }
      else {
         ptTile.x += cxWidth;
      }
      m_cyNeeded = rcTile.bottom - (rc.top - m_iScrollPos);
   }
   // Process the scrollbar
   ProcessScrollbar(rc, m_cyNeeded);
}


/////////////////////////////////////////////////////////////////////////////////////
//
//

CDialogLayoutUI::CDialogLayoutUI() : m_bFirstResize(true), m_aModes(sizeof(STRETCHMODE))
{
   ::ZeroMemory(&m_rcDialog, sizeof(m_rcDialog));
}

LPCTSTR CDialogLayoutUI::GetClass() const
{
   return _T("DialogLayoutUI");
}

LPVOID CDialogLayoutUI::GetInterface(LPCTSTR pstrName)
{
   if( _tcscmp(pstrName, _T("DialogLayout")) == 0 ) return this;
   return CContainerUI::GetInterface(pstrName);
}

void CDialogLayoutUI::SetStretchMode(CControlUI* pControl, UINT uMode)
{
   STRETCHMODE mode;
   mode.pControl = pControl;
   mode.uMode = uMode;
   mode.rcItem = pControl->GetPos();
   m_aModes.Add(&mode);
}

SIZE CDialogLayoutUI::EstimateSize(SIZE szAvailable)
{
   RecalcArea();
   return CSize(m_rcDialog.right - m_rcDialog.left, m_rcDialog.bottom - m_rcDialog.top);
}

void CDialogLayoutUI::SetPos(RECT rc)
{
   m_rcItem = rc;
   RecalcArea();
   // Do Scrollbar
   ProcessScrollbar(rc, m_rcDialog.bottom - m_rcDialog.top);
   if( m_hwndScroll != NULL ) rc.right -= m_pManager->GetSystemMetrics().cxvscroll;
   // Determine how "scaled" the dialog is compared to the original size
   int cxDiff = (rc.right - rc.left) - (m_rcDialog.right - m_rcDialog.left);
   int cyDiff = (rc.bottom - rc.top) - (m_rcDialog.bottom - m_rcDialog.top);
   if( cxDiff < 0 ) cxDiff = 0;
   if( cyDiff < 0 ) cyDiff = 0;
   // Stretch each control
   // Controls are coupled in "groups", which determine a scaling factor.
   // A "line" indicator is used to apply the same scaling to a new group of controls.
   int nCount, cxStretch, cyStretch, cxMove, cyMove;
   for( int i = 0; i < m_aModes.GetSize(); i++ ) {
      STRETCHMODE* pItem = static_cast<STRETCHMODE*>(m_aModes[i]);
      if( i == 0 || (pItem->uMode & UISTRETCH_NEWGROUP) != 0 ) {
         nCount = 0;
         for( int j = i + 1; j < m_aModes.GetSize(); j++ ) {
            STRETCHMODE* pNext = static_cast<STRETCHMODE*>(m_aModes[j]);
            if( (pNext->uMode & (UISTRETCH_NEWGROUP | UISTRETCH_NEWLINE)) != 0 ) break;
            if( (pNext->uMode & (UISTRETCH_SIZE_X | UISTRETCH_SIZE_Y)) != 0 ) nCount++;
         }
         if( nCount == 0 ) nCount = 1;
         cxStretch = cxDiff / nCount;
         cyStretch = cyDiff / nCount;
         cxMove = 0;
         cyMove = 0;
      }
      if( (pItem->uMode & UISTRETCH_NEWLINE) != 0 ) {
         cxMove = 0;
         cyMove = 0;
      }
      RECT rcPos = pItem->rcItem;
      ::OffsetRect(&rcPos, rc.left, rc.top - m_iScrollPos);
      if( (pItem->uMode & UISTRETCH_MOVE_X) != 0 ) ::OffsetRect(&rcPos, cxMove, 0);
      if( (pItem->uMode & UISTRETCH_MOVE_Y) != 0 ) ::OffsetRect(&rcPos, 0, cyMove);
      if( (pItem->uMode & UISTRETCH_SIZE_X) != 0 ) rcPos.right += cxStretch;
      if( (pItem->uMode & UISTRETCH_SIZE_Y) != 0 ) rcPos.bottom += cyStretch;
      if( (pItem->uMode & (UISTRETCH_SIZE_X | UISTRETCH_SIZE_Y)) != 0 ) {
         cxMove += cxStretch;
         cyMove += cyStretch;
      }      
      pItem->pControl->SetPos(rcPos);
   }
}

void CDialogLayoutUI::RecalcArea()
{
   if( !m_bFirstResize ) return;
   // Add the remaining control to the list
   // Controls that have specific stretching needs will define them in the XML resource
   // and by calling SetStretchMode(). Other controls needs to be added as well now...
   for( int it = 0; it < m_items.GetSize(); it++ ) {         
      CControlUI* pControl = static_cast<CControlUI*>(m_items[it]);
      bool bFound = false;
      for( int i = 0; !bFound && i < m_aModes.GetSize(); i++ ) {
         if( static_cast<STRETCHMODE*>(m_aModes[i])->pControl == pControl ) bFound = true;
      }
      if( !bFound ) {
         STRETCHMODE mode;
         mode.pControl = pControl;
         mode.uMode = UISTRETCH_NEWGROUP;
         mode.rcItem = pControl->GetPos();
         m_aModes.Add(&mode);
      }
   }
   // Figure out the actual size of the dialog so we can add proper scrollbars later
   CRect rcDialog(9999, 9999, 0,0);
   for( int i = 0; i < m_items.GetSize(); i++ ) {
      const RECT& rcPos = static_cast<CControlUI*>(m_items[i])->GetPos();
      rcDialog.Join(rcPos);
   }
   for( int j = 0; j < m_aModes.GetSize(); j++ ) {
      RECT& rcPos = static_cast<STRETCHMODE*>(m_aModes[j])->rcItem;
      ::OffsetRect(&rcPos, -rcDialog.left, -rcDialog.top);
   }
   m_rcDialog = rcDialog;
   // We're done with initialization
   m_bFirstResize = false;
}