resizedlg.cpp

Go to the documentation of this file.

// ResizeDlg.cpp: implementation of the CResizeDlg class.
//

#include "pch.h"
#include "ResizeDlg.h"
#include "debug.h"
#include "persctl.h"
// #include "w32err.h" // #include "E:\nt\private\NTOS\w32\w32inc\w32err.h"
// #include "usercli.h" // #include "e:\nt\private\ntos\w32\ntuser\client\usercli.h"
// #include "resource.h"
// #include "E:\nt\private\NTOS\w32\w32inc\w32err.h"


#define MIN_COL_SPACE 4
#define MIN_ROW_SPACE 4

void* __cdecl operator new(size_t n)
{
    // return malloc(n);
        return GlobalAlloc( GPTR, n);
}

void __cdecl operator delete(void* p)
{
    // free(p);
        GlobalFree(p);
}

extern "C" {

LPVOID __cdecl MakeAResizeDlg(int id,HANDLE h)
{
        return new CResizeDlg(id, NULL, (HINSTANCE)h);
}

LRESULT ResizeDlgMessage( LPVOID pObject, 
    HWND hwnd,
    UINT message,
    WPARAM wParam,
    LPARAM lParam )
{
        return ((CResizeDlg*)pObject)->DlgProc( hwnd, message, wParam, lParam );
}


};




// Construction/Destruction

CResizeDlg::CResizeDlg(int DlgID, HWND hWndParent, HINSTANCE hInst)
: BASECLASS(DlgID, hWndParent, hInst)
{
        SetAnnotate(FALSE);
        SetRowWeight(0);
        SetColWeight(0);
        m_hwndGripper=NULL;
}

CResizeDlg::~CResizeDlg()
{

}

//
//
//
BOOL CALLBACK CResizeDlg::DlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
        switch( uMessage )
        {
        case WM_NCHITTEST:
                {
                        // Because we always turn on the resize frame, we must always hit test.
                        // if( (GetRowWeight() !=0 ) || (GetColWeight() != 0 ) )
                        {
                                // call def window proc to see what he wants to do
                                LONG lRes= HitTest( DefWindowProc( hDlg, uMessage, wParam, lParam ) );
                                if( lRes != (HTERROR-1) )
                                {
                                        SetWindowLong( hDlg, DWL_MSGRESULT,  lRes );
                                        return TRUE;
                                }
                        }
                }
                break;

        case WM_WINDOWPOSCHANGING:
                if( (GetRowWeight() !=0 ) || (GetColWeight() != 0 ) )
                        DoChangePos( (WINDOWPOS*)lParam);
                break;

        case WM_ERASEBKGND:
                /*
                if( (GetRowWeight() !=0 ) || (GetColWeight() != 0 ) )
            {
                        HDC hdc=(HDC)wParam;
                        RECT rcWindow;
                        GetClientRect(hDlg, &rcWindow);
                        int g_cxGrip = GetSystemMetrics( SM_CXVSCROLL );
                        int g_cyGrip = GetSystemMetrics( SM_CYHSCROLL );
                        rcWindow.left = rcWindow.right - g_cxGrip; // pWState->x_VSBArrow;
                        rcWindow.top = rcWindow.bottom - g_cyGrip; // pWState->y_HSBArrow;
                        DrawFrameControl(hdc, &rcWindow, DFC_SCROLL, DFCS_SCROLLSIZEGRIP);
                }
                */
                break;

        case WM_INITDIALOG:
                        SetWindow(hDlg);
                        DoInitDialog();
                        // Re-adjusts the dialogs to what we think they should be
                        // breaks some apps who are completely owner draw.
                        if( (GetRowWeight() !=0 ) || (GetColWeight() != 0 ) )
                        {
                                AddGripper(); // need to sit on the size meesage too.
                                RECT r;
                                GetWindowRect( hDlg, &r);
                                SetWindowPos(
                                        NULL, NULL, 0,0, r.right - r.left, r.bottom - r.top, 
                                        SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_NOMOVE | SWP_NOOWNERZORDER |
                                        SWP_NOREDRAW | SWP_NOZORDER );
                        }
                return TRUE;
                break;

        case WM_SIZE:
                if( (GetRowWeight() !=0 ) || (GetColWeight() != 0 ) )
                {
                        // Don't try to re-adjust to the size when initially shown.
                        if( wParam == SIZE_RESTORED )
                        {
                                WINDOWPOS pos={NULL, NULL, 0,0, LOWORD(lParam), HIWORD(lParam), 
                                        SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_NOMOVE | SWP_NOOWNERZORDER |
                                        SWP_NOREDRAW | SWP_NOSENDCHANGING | SWP_NOZORDER };
                                DoChangePos( &pos );
                                ResizeControls(LOWORD( lParam ) , HIWORD (lParam) );
                        }
                }
                break;

        case WM_PAINT:
                Annotate();
                break;
        }
        return FALSE;
}

//
// Walks all the controls, finds their edges,
// attatches them to their edges/guides.
//
void CResizeDlg::WalkControls()
{
        m_ParentInfo.Init( GetWindow() );
        FindControls();
        m_ParentInfo.DeterminBorders( &m_ControlList );
        MakeAttatchments();
        FindCommonGuides();
        SpecialRowCol();
}

//
// Walk the dialog
// build structures of what we think the relationships of the controls is.
//
void CResizeDlg::FindControls()
{
        HWND hCurrent;
        HWND hFirst;
        hCurrent=hFirst=::GetWindow(GetWindow(),GW_CHILD);
        TRACE(L"FindControls on 0x%0x\n", GetWindow() );
        TRACE(L"Parent size is %d,%d by %d,%d\n",
                m_ParentInfo.GetLeft(),
                m_ParentInfo.GetTop(),
                m_ParentInfo.GetRight(),
                m_ParentInfo.GetBottom() );

        if( hFirst )
        {
                do {
                        CResizeControl * pC = new CResizeControl(hCurrent, m_ParentInfo);
                        if( pC->Valid() )
                        {
                                //
                                // Make sure the control is wihin the bounds of our parent.
                                //
                                RECT r=pC->GetLocation();
                                TRACE(L"Control size is %d,%d by %d,%d\n",
                                        r.left,
                                        r.top,
                                        r.right,
                                        r.bottom);
                                if( (r.right > m_ParentInfo.GetRight()) ||
                                        (r.bottom > m_ParentInfo.GetBottom()) ||
                                        (r.top < m_ParentInfo.GetTop()) ||
                                        (r.left < m_ParentInfo.GetLeft()) )
                                {
                                        TRACE(L"Punting this control %s\n", pC->GetClassName() );
                                        delete pC;              // we don't play with these.
                                }
                                else
                                        m_ControlList.Append(pC);
                        }
                        else
                                delete pC;
                } while (hCurrent=::GetWindow(hCurrent,GW_HWNDNEXT));
        }
}

//
// We have data backing each control now.
// walk it and have it initialize itself.
//
void CResizeDlg::FindBorders()
{
}
 
//
// Now we have determined the borders on the dialog, see
// if any controls can make assumptions about their individual
// attatchments.
//
void CResizeDlg::MakeAttatchments()
{
        CResizeControl * pC;
        int i=0;
        while( pC=m_ControlList.GetControl(i++) )
                pC->DeterminLeftAttatchments();

        i=0;
        while( pC=m_ControlList.GetControl(i++) )
                pC->DeterminTopAttatchments();

        i=0;
        while( pC=m_ControlList.GetControl(i++) )
                pC->DeterminRightAttatchments();

        i=0;
        while( pC=m_ControlList.GetControl(i++) )
                pC->DeterminBottomAttatchments();

        i=0;
        while( pC=m_ControlList.GetControl(i++) )
                pC->SetControlAssociations();
}

//
//
//
void CResizeDlg::ResizeControls(WORD width, WORD height)
{
        int iSpecialRow = GetNumRows()-1;
        int iSpecialCol = GetNumCols()-1;

        //
        // Add free space
        //
        if( GetColWeight()>0 )
        {
                int FreeW = width - m_Cols[ GetNumCols() ].Pos - m_ParentInfo.GetRightBorder();
                if( FreeW != 0 )
                {
                        int iPadding=0;
                        int iPad=FreeW/GetColWeight();
                        for( int fi=0;fi<= GetNumCols(); fi++)
                        {
                                m_Cols[ fi ].Pos += iPadding;
                                if( m_Cols[fi].iFixed>=0)
                                        iPadding+=iPad * m_Cols[fi].iWeight;
                        }
                }
        }

        //
        // Add free row.
        //
        if( GetRowWeight()>0 )
        {
                int Free = height - m_Rows[ GetNumRows() ].Pos - m_ParentInfo.GetBottomBorder();
                if( Free != 0 )
                {
                        int iPadding=0;
                        int iPad=Free/GetRowWeight();
                        for( int fi=0;fi<= GetNumRows(); fi++)
                        {
                                m_Rows[ fi ].Pos += iPadding;
                                if( m_Rows[fi].iFixed>=0)
                                        iPadding+=iPad * m_Rows[fi].iWeight;
                        }
                }
        }

        //
        // Now setup the information for all of the controls, as to which cell they are in.
        //
        HDWP hdwp = BeginDeferWindowPos( m_ControlList.GetControlCount() );
        int i=0;
        CResizeControl * pC;
        CConstraint     * pCons;
        while( pC=(CResizeControl *) m_ControlList.GetPointer(i++) )
        {
                pCons=&(pC->m_Cons);
                int x=m_Cols[pCons->GetCol()].Pos + pCons->GetPadLeft();
                int y=m_Rows[pCons->GetRow()].Pos + pCons->GetPadTop();
                int w,h;

                BOOL bMove=true; BOOL bSize=false;
                if( pC->IsGrowsWide() )
                {
                        w=m_Cols[pCons->GetCol()+pCons->GetColW()].Pos + pCons->GetPadRight() -x;
                        bSize=true;
                }
                else
                        w=pC->GetWidth();

                if( pC->IsGrowsHigh() )
                {
                        h=m_Rows[pCons->GetRow()+pCons->GetRowH()].Pos + pCons->GetPadBottom() -y;
                        bSize=true;
                }
                else
                        h=pC->GetHeight();

                //
                // Here we special case the ComboBox - yuck.
                //
                if( lstrcmp( pC->GetClassName(), L"Button") ==0)
                {
                        //
                        // Check box button is OK though.
                        //
                        int ibs=GetWindowStyle( pC->GetControl() );
                        if( (ibs & 0xf) == BS_GROUPBOX )
                        {
                                //
                                // Force the width / height.
                                //
                                w=m_Cols[pCons->GetCol()+pCons->GetColW()].Pos + pCons->GetPadRight() -x;
                                h=m_Rows[pCons->GetRow()+pCons->GetRowH()].Pos + pCons->GetPadBottom() -y;
                                bSize=true;
                        }
                }

                //
                // If they are in special row / columns we do something special to them.
                //
                if( m_SpecialCol.bSpecial && ( pCons->GetCol() == iSpecialCol ) )
                {
                        // alignment issues
                        if(m_SpecialCol.iAlignment == -1 )
                        {
                                y=pC->GetTopGap();
                        }
                        else
                        if(m_SpecialCol.iAlignment == 1 )
                        {
                                //
                                // Right aligned.
                                //
                                y=pC->GetTopGap() + height - m_SpecialCol.iMax - m_ParentInfo.GetTopBorder();
                        }
                        else
                        {
                                //
                                // Center aligned
                                //
                                y=pC->GetTopGap() + ((height - m_SpecialCol.iMax - m_ParentInfo.GetTopBorder())/2);
                        }
                }

                if( m_SpecialRow.bSpecial && ( pCons->GetRow() == iSpecialRow ) )
                {
                        // alignment issues
                        if(m_SpecialRow.iAlignment == -1 )
                        {
                                x=pC->GetLeftGap();
                        }
                        else
                        if(m_SpecialRow.iAlignment == 1 )       // right aligned.
                        {
                                x=pC->GetLeftGap() + width - m_SpecialRow.iMax - m_ParentInfo.GetRightBorder();
                        }
                        else
                        {
                                x=pC->GetLeftGap() + ((width - m_SpecialRow.iMax - m_ParentInfo.GetRightBorder()) / 2);
                        }
                }

                hdwp = DeferWindowPos( hdwp, pC->GetControl(), NULL, 
                        x, y, w , h,
                        (bMove ? 0: SWP_NOMOVE) |       (bSize ? 0: SWP_NOSIZE) | SWP_NOZORDER );

        }

        //
        // Move the gripper
        //
        SetGripperPos(hdwp);

        EndDeferWindowPos( hdwp );
}

//
// Tries to combine guides to be offsets from other guides.
//
void CResizeDlg::FindCommonGuides()
{
        CEdge ** ppVert = m_ParentInfo.GetVerticalEdges();
        CEdge ** ppHoriz = m_ParentInfo.GetHorizontalEdges();

        //
        // Work out which guides are used in columns.
        //
        int iCount,i;
        iCount=m_ParentInfo.GetNumVert();
        Sort(ppVert, iCount );
#ifdef _DEBUG
        TRACE(L"Vertical edge information %d edges\n", iCount );
        for(i=0;i<iCount;i++)
        {
                CEdge * pEdge=ppVert[i];
                TRACE(L"Edge %02d: Edge@%02d times as 0x%02x, position %08d, Guide@%03d\n",
                        i, pEdge->GetControlCount(), 
                        pEdge->GetGuide()->Attatchment(),
                        pEdge->GetPosition(),
                        pEdge->GetGuide()->NumAttatchments()
                        );
        }
#endif

        iCount=m_ParentInfo.GetNumHoriz();
        Sort(ppHoriz, iCount );
#ifdef _DEBUG
        TRACE(L"Horiz edge information %d edges\n", iCount );
        for(i=0;i<iCount;i++)
        {
                CEdge * pEdge=ppHoriz[i];
                CGuide * pGuide=pEdge->GetGuide();
                TRACE(L"Edge %02d: Edge@%02d times as 0x%02x, position %08d, Guide@%03d\n",i,
                        pEdge->GetControlCount(), 
                        pEdge->Attatchment(),
                        pGuide->GetPosition(),
                        pEdge->GetGuide()->NumAttatchments()
                        );
        }
#endif

        //
        // Determin rows and columns
        //
        DeterminCols( ppVert, m_ParentInfo.GetNumVert() );
        DeterminRows( ppHoriz, m_ParentInfo.GetNumHoriz() );
        PlaceControls();

        delete [] ppVert;
        delete [] ppHoriz;

        DeterminWeights();
}

//
// Sorts an array of edges.
//
void CResizeDlg::Sort(CEdge * *ppEdges, int iCount)
{
        //
        // Lame sort BB fix later.
        //
        int iInsert=0;
        while ( iInsert < iCount )
        {
                int iSmallest=iInsert;
                for(int iMatch=iInsert; iMatch<iCount; iMatch++)
                {
                        if( ppEdges[iMatch]->GetPosition() < ppEdges[iSmallest]->GetPosition() )
                                iSmallest=iMatch;
                }
                if( iSmallest > iInsert )
                {
                        CEdge * pTemp=ppEdges[iInsert];
                        ppEdges[iInsert]=ppEdges[iSmallest];
                        ppEdges[iSmallest]=pTemp;
                }
                // TRACE(L"%02d is %08d\n", iInsert, ppEdges[iInsert]->GetPosition() );
                iInsert++;
        }
}


//
// State table kinda used to determin when a new col. is needed
// Prev This    New Col?
// L    L               Yes, on this edge
// L    R               Yes, on this edge
// R    L               Yes, between these two edges
// R    R               Yes if last (no if on same guide)?
//
void CResizeDlg::DeterminCols(CEdge * * ppEdges, int iCount)
{
        //
        // First pass is just to work out positions of edges,
        // and if those edges constitute Columns.
        //
        int i;
        int iCols=0;
        int iLastGuide;
        int iThisGuide;
        int * iPos = new int[iCount];                   // where the edges are
        iPos[0]=ppEdges[0]->GetPosition();              // we always use the first edge.
        int iLastPos=0;
        for(i=1; i<iCount;i++)
        {
                iThisGuide=ppEdges[i]->Attatchment() ;
                iLastGuide=ppEdges[i-1]->Attatchment();
                TRACE(L"Edge:%02d - Attatched as %02d\n", i, iThisGuide);

                //
                // Column between these two controls 
                //
                if( (iLastGuide & RIGHT_AT ) && ( iThisGuide & LEFT_AT ) )
                {
                        iCols++;
                        iPos[iCols] = ppEdges[i-1]->GetPosition() + ((ppEdges[i]->GetPosition() - ppEdges[i-1]->GetPosition())/2);
                        continue;
                }

                //
                // If we're starting another left edge of a control, needs a new guide
                //
                if( (iThisGuide & LEFT_AT ) )
                {
                        iCols++;
                        iPos[iCols]= ppEdges[i]->GetPosition();
                        continue;
                }

                //
                // If this is the last right edge
                //
                if( (iThisGuide & RIGHT_AT ) && ((i+1)==iCount) )
                {
                        iCols++;
                        iPos[iCols] = ppEdges[i]->GetPosition() ;
                        continue;       // just incase you add anytyhing below
                }
        }


        //
        // Second pass is to make up the column information
        // we don't allow narrow colums, that is columns who are <2 appart.
        //
        TRACE(L"Column Widths are ...\n");
        SetNumCols( iCols );                    // 0 through n are USED. Not n-1
        m_Cols = new CHANNEL[iCols+1];
        m_Cols[0].Pos=iPos[0];
        iLastPos=0;
        int iThisCol=1;
        for(int iThisPos=1;iThisPos<=iCols;iThisPos++)
        {
                int iWidth=iPos[iThisPos]-iPos[iLastPos];
                if( iWidth >= MIN_COL_SPACE )
                {
                        m_Cols[iThisCol].Pos = iPos[iThisPos];
                        m_Cols[iThisCol-1].Size = iWidth;
                        m_Cols[iThisCol-1].iWeight=0;
                        m_Cols[iThisCol-1].iFixed=FALSE;
                        /*
                        TRACE(L"Col:%02d Width:%03d Pos:%03d\n",        
                                iThisCol-1, 
                                m_Cols[iThisCol-1].Size, 
                                m_Cols[iThisCol-1].Pos);
                        */
                        iLastPos=iThisPos;
                        iThisCol++;
                }
                else
                {
                        // TRACE(L"Skipping col #%d as it's only %d wide\n",iThisPos,iWidth);
                }
        }
#ifdef _DEBUG
        if( (iThisCol-1) != iCols )
                TRACE(L"Skipped %d rows\n",iThisCol-1-iCols);
#endif
        SetNumCols( iThisCol-1 );

        delete [] iPos;
}

//
// State table kinda used to determin when a new col. is needed
// Prev This    New Col?
// L    L               Yes, on this edge
// L    R               Yes, on this edge
// R    L               Yes, between these two edges
// R    R               Yes if last (no if on same guide)?
//
void CResizeDlg::DeterminRows(CEdge * * ppEdges, int iCount)
{
        int i;
        int iRows=0;
        int iLastGuide;
        int iThisGuide;
        int * iPos = new int[iCount];

        //
        // brute force, each edge is a row.
        //
        iRows=0;
        iPos[0]=ppEdges[0]->GetPosition();
        int iLastPos=0;
        for(i=1; i<iCount;i++)
        {
                iThisGuide=ppEdges[i]->Attatchment() ;
                iLastGuide=ppEdges[i-1]->Attatchment();
                TRACE(L"Edge:%02d - Attatched as %02d pos:%03d\n", i, iThisGuide, ppEdges[i]->GetPosition() );

                //
                // row between these two controls 
                //
                if( (iLastGuide & BOTTOM_AT ) && ( iThisGuide & TOP_AT ) )
                {
                        iRows++;
                        iPos[iRows] = ppEdges[i-1]->GetPosition() + ((ppEdges[i]->GetPosition() - ppEdges[i-1]->GetPosition())/2);
                        continue;
                }

                //
                // If we're starting another left edge of a control, needs a new guide
                //
                if( (iThisGuide & TOP_AT ) )
                {
                        iRows++;
                        iPos[iRows]= ppEdges[i]->GetPosition();
                        continue;
                }

                //
                // If this is the last right edge
                //
                if( (iThisGuide & BOTTOM_AT ) && ((i+1)==iCount) )
                {
                        iRows++;
                        iPos[iRows] = ppEdges[i]->GetPosition() ;
                        continue;       // just incase you add anytyhing below
                }
        }

        //
        // Second pass is to make up the column information
        // we don't allow narrow colums, that is columns who are <2 appart.
        //
        TRACE(L"Rowumn Widths are ...\n");
        SetNumRows( iRows );                    // 0 through n are USED. Not n-1
        m_Rows = new CHANNEL[iRows+1];
        m_Rows[0].Pos=iPos[0];
        iLastPos=0;
        int iThisRow=1;
        for(int iThisPos=1;iThisPos<=iRows;iThisPos++)
        {
                int iWidth=iPos[iThisPos]-iPos[iLastPos];
                if( iWidth >= MIN_ROW_SPACE )
                {
                        m_Rows[iThisRow].Pos = iPos[iThisPos];
                        m_Rows[iThisRow-1].Size = iWidth;
                        m_Rows[iThisRow-1].iWeight=0;
                        m_Rows[iThisRow-1].iFixed=FALSE;
                        /*
                        TRACE(L"Row:%02d Width:%03d Pos:%03d\n",        
                                iThisRow-1, 
                                m_Rows[iThisRow-1].Size, 
                                m_Rows[iThisRow-1].Pos);
                        */
                        iLastPos=iThisPos;
                        iThisRow++;
                }
                else
                {
                        // TRACE(L"Skipping Row #%d as it's only %d wide\n",iThisPos,iWidth);
                }
        }
#ifdef _DEBUG
        if( (iThisRow-1) != iRows )
                TRACE(L"Skipped %d rows\n",iThisRow-1-iRows);
#endif
        SetNumRows( iThisRow-1 );

        delete [] iPos;
}

//
// Draws the annotations on the dialog of where the column/rows are
//
void CResizeDlg::Annotate()
{
        if(GetAnnotate()==false)
                return;

        HDC hdc=GetDC( GetWindow() );
        //
        // Draw all the control edges on the screen.
        //
        // m_ParentInfo.Annotate( hdc );

        //
        // Now show the cols/rows
        //
        int iCount=GetNumRows();
        int i;
        RECT r;
        GetWindowRect( GetWindow(), &r);
        int iWidth=r.right - r.left;
        int iHeight=r.bottom - r.top;

        HPEN hFixedPen = CreatePen( PS_SOLID, 2, RGB( 0x00,0x00,0xff) );
        HPEN hSizePen = CreatePen( PS_SOLID, 2, RGB( 0x00,0xff,0x00) );
        HGDIOBJ holdPen= SelectObject( hdc, hFixedPen);

        //
        // Horizontal lines
        //
        for(i=0;i<=iCount;i++)
        {
                if(m_Rows[i].iFixed >= 0 )
                        SelectObject( hdc, hSizePen );
                else
                        SelectObject( hdc, hFixedPen );
                MoveToEx( hdc, 0, m_Rows[i].Pos, NULL );
                LineTo( hdc, iWidth , m_Rows[i].Pos );
        }

        //
        // Vertical lines
        //
        iCount = GetNumCols();
        for(i=0;i<=iCount;i++)
        {
                if(m_Cols[i].iFixed >= 0 )
                        SelectObject( hdc, hSizePen );
                else
                        SelectObject( hdc, hFixedPen );
                MoveToEx( hdc, m_Cols[i].Pos, 0, NULL );
                LineTo( hdc, m_Cols[i].Pos, iHeight );
        }

        SelectObject(hdc, holdPen);
        DeleteObject(hFixedPen);
        DeleteObject(hSizePen);

        ReleaseDC( GetWindow(), hdc );
}

//
// 
//
int CResizeDlg::FindRow(int pos)
{
        int i=0;
        while( i<=GetNumRows() )
        {
                if( m_Rows[i].Pos > pos )
                        return i-1;
                i++;
        }
        return GetNumRows();
}

//
// 
//
int CResizeDlg::FindCol(int pos)
{
        int i=0;
        while( i<=GetNumCols() )
        {
                if( m_Cols[i].Pos > pos )
                        return i-1;
                i++;
        }
        return GetNumCols();
}

//
// Walks the rows/columns and determins if they are resizable.
//
void CResizeDlg::DeterminWeights()
{
        int iColWeight=0;
        {
                for( int fi=0;fi<= GetNumCols(); fi++)
                        m_Cols[ fi ].iFixed<0 ? 0: iColWeight+=m_Cols[fi].iWeight;
        }
        int iRowWeight=0;
        {
                for( int fi=0;fi<= GetNumRows(); fi++)
                        m_Rows[ fi ].iFixed<0 ? 0: iRowWeight+=m_Rows[fi].iWeight;
        }
        SetColWeight(iColWeight);
        SetRowWeight(iRowWeight);
}

//
// Passed in the current hit test, allows you to override it.
// return HTERROR -1 if we didn't deal with it.
//
LONG CResizeDlg::HitTest(LONG lCurrent)
{
#define WIDE 1
#define HIGH 2
        int iThisDlg = (GetRowWeight() ? HIGH : 0 ) | ( GetColWeight() ? WIDE : 0 );

        // TRACE(L"NC Hit Test %d - dlg is %d\n",lCurrent, iThisDlg);
        switch( lCurrent )
        {
                case HTLEFT: // In the left border of a window 
                case HTRIGHT: // In the rigcase HT border of a window 
                        if( iThisDlg==0)
                                return HTNOWHERE;
                        if( iThisDlg & WIDE )
                                return lCurrent;        // OK
                        return HTNOWHERE;

                case HTTOP: // In the upper horizontal border of a window 
                case HTBOTTOM: // In the lower horizontal border of a window 
                        if( iThisDlg==0)
                                return HTNOWHERE;
                        if( iThisDlg & HIGH ) 
                                return lCurrent;        // OK
                        return HTNOWHERE;               // Can't make taller

                case HTTOPLEFT: // In the upper-left corner of a window border 
                case HTTOPRIGHT: // In the upper rigcase HT corner of a window border 
                        if( iThisDlg==0)
                                return HTNOWHERE;

                        if( (iThisDlg & (HIGH | WIDE)) == (HIGH | WIDE ))
                                return lCurrent;
                        if( iThisDlg & HIGH )
                                return HTTOP;
                        if( lCurrent == HTTOPLEFT )
                                return HTLEFT;
                        return HTRIGHT;

                case HTGROWBOX: // In a size box (same as case HTSIZE) 
                        if( iThisDlg==0)
                                return HTNOWHERE;
                        if( (iThisDlg & (HIGH | WIDE)) == (HIGH | WIDE ))
                                return lCurrent;
                        if( iThisDlg & HIGH )
                                return HTBOTTOM;
                        return HTRIGHT;

                case HTBOTTOMLEFT: // In the lower-left corner of a window border 
                case HTBOTTOMRIGHT: // In the lower-rigcase HT corner of a window border 
                        if( iThisDlg==0)
                                return HTNOWHERE;
                        if( (iThisDlg & (HIGH | WIDE)) == (HIGH | WIDE ))
                                return lCurrent;
                        if( iThisDlg & HIGH )
                                return HTBOTTOM;
                        if(lCurrent == HTBOTTOMRIGHT)
                                return HTRIGHT;
                        return HTLEFT;
        }
        return HTERROR-1;
}

//
// Determins the location of the controls in the row/col space.
//
void CResizeDlg::PlaceControls()
{
        //
        // Now setup the information for all of the controls, as to which cell they are in.
        //
        int i=0;
        CResizeControl * pC;
        CConstraint     * pCons;
        while( pC=(CResizeControl *) m_ControlList.GetPointer(i++) )
        {
                int Row, Col, RowH, ColW;

                RECT r=pC->GetLocation();
                pCons=&(pC->m_Cons);

                Row  = FindRow( r.top);
                RowH = FindRow( r.bottom ) - Row +1 ;
                if( RowH + Row > GetNumRows() )
                        RowH = GetNumRows() - Row;

                Col  = FindCol( r.left);
                ColW = FindCol( r.right ) - Col + 1;
                if( ColW + Col > GetNumCols() )
                        ColW = GetNumCols() - Col;

                pCons->SetCol( Col );
                pCons->SetRow( Row );
                pCons->SetColW( ColW );
                pCons->SetRowH( RowH );

                //
                // Now adjust the padding from the edges of the cell.
                //
                pCons->SetPadTop   ( r.top    - m_Rows[ Row ].Pos );
                pCons->SetPadBottom( r.bottom - m_Rows[ Row + RowH ].Pos );
                pCons->SetPadLeft  ( r.left   - m_Cols[ Col ].Pos );
                pCons->SetPadRight ( r.right  - m_Cols[ Col + ColW ].Pos  );

                /*
                IF you're worried that you got the dimentions wrong
                TRACE(L"Component %03d [%06d] %s\n pos: l:%03d, r:%03d, t:%03d, b:%03d\nCell: l:%03d, r:%03d, t:%03d, b:%03d\n",
                        i, GetDlgCtrlID( pC->GetControl()),  pC->GetClassName(), r.left, r.right, r.top, r.bottom,
                        m_Cols[pCons->GetCol()].Pos + pCons->GetPadLeft(),
                        m_Cols[pCons->GetCol()+pCons->GetColW()].Pos + pCons->GetPadRight(),
                        m_Rows[pCons->GetRow()].Pos + pCons->GetPadTop(),
                        m_Rows[pCons->GetRow()+pCons->GetRowH()].Pos + pCons->GetPadBottom() );
                */

                TRACE(L"Component %03d [%06d] %s\n pos: Cell: %03d,%03d by %03d x %03d\n Padding:l:%03d, r:%03d, t:%03d, b:%03d\n",
                        i, GetDlgCtrlID( pC->GetControl()),  pC->GetClassName(), 
                        pCons->GetCol(), pCons->GetRow(), pCons->GetColW(), pCons->GetRowH(),
                        pCons->GetPadLeft(), pCons->GetPadRight(), pCons->GetPadTop(), pCons->GetPadBottom() );

                //
                // Mark each column this control spans as gets wider.
                //
                int iCol=pCons->GetCol();
                int ic=pCons->GetColW();
                while( ic-- )
                {
                        if( pC-> IsGrowsWide() == false )
                                m_Cols[ iCol+ic ].iFixed-=1;    // can't make wider
                        else
                        {
                                m_Cols[ iCol+ic ].iWeight++;
                                m_Cols[ iCol+ic ].iFixed+=2;    // can make wider
                        }
                }

                ic=pCons->GetRowH();
                int iRow=pCons->GetRow();
                while( ic-- )
                {
                        if( pC-> IsGrowsHigh() == false )
                                m_Rows[ iRow+ic ].iFixed-=1;    // can't make wider
                        else
                        {
                                m_Rows[ iRow+ic ].iWeight++;
                                m_Rows[ iRow+ic ].iFixed+=2;    // can make wider
                        }
                }
        }
}

//
// Determins if we can actually change size to that asked for.
//
void CResizeDlg::DoChangePos(WINDOWPOS * lpwp)
{
        if((lpwp->flags & SWP_NOSIZE) == FALSE)
        {
                //
                // We're being sized - size in screen area (ie. included title bar)
                // m_ParentInfo EXCLUDES title bar.
                //
                RECT r;
                GetWindowRect( GetWindow(), &r );
                if( GetRowWeight() <= 0 )
                        lpwp->cy=r.bottom- r.top;
                if( GetColWeight() <= 0 )
                        lpwp->cx=r.right - r.left;
                DIMENSION dMin= m_ParentInfo.GetMinimumSize();
                if( lpwp->cx < dMin.Width )
                        lpwp->cx=dMin.Width;
                if( lpwp->cy < dMin.Height )
                        lpwp->cy=dMin.Height;   
        }
}

//
// 
//
void CResizeDlg::DoInitDialog()
{
        AddToSystemMenu();
        WalkControls();
        ResizeControls( (WORD)m_ParentInfo.GetWidth() , (WORD)m_ParentInfo.GetHeight() );
}

//
// Adds an annotate option to the system menu.
//
void CResizeDlg::AddToSystemMenu()
{
        /*
        //
        // Get the system menu - add an annotate option to it?
        //
        HMENU hm=GetSystemMenu(GetWindow(), false);
        TCHAR   szAnnotate[128];
        LoadString( GetInstance(), IDS_ANNOTATE, szAnnotate,  128);
        MENUITEMINFO minfo={
                sizeof(MENUITEMINFO),
                MIIM_ID | MIIM_TYPE,
                MFT_STRING,
                0,
                IDS_ANNOTATE,           // ID
                NULL,                           // SubMenu
                NULL,                           // Checked
                NULL,                           // Unchecked
                0,                                      // Item data - app specific
                szAnnotate,                     // Content of the menu item
                lstrlen(szAnnotate)+1// Length of menu item data
        };

        InsertMenuItem( hm, -1, TRUE, &minfo);
        */
}

void CResizeDlg::AddGripper()
{
        int g_cxGrip = GetSystemMetrics( SM_CXVSCROLL );
        int g_cyGrip = GetSystemMetrics( SM_CYHSCROLL );
        RECT rc;
        GetClientRect( GetWindow(), &rc);
        m_hwndGripper = CreateWindow( TEXT("Scrollbar"),
                     NULL,
                     WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS |
                       WS_CLIPCHILDREN | SBS_BOTTOMALIGN | SBS_SIZEGRIP |
                       SBS_SIZEBOXBOTTOMRIGHTALIGN,
                     rc.right - g_cxGrip,
                     rc.bottom - g_cyGrip,
                     g_cxGrip,
                     g_cyGrip,
                     GetWindow(),
                     (HMENU)-1,
                     (HINSTANCE)GetWindowLong( GetWindow(), GWL_HINSTANCE ) , // g_hinst,
                     NULL );
}

HDWP CResizeDlg::SetGripperPos(HDWP hdwp)
{
        if( m_hwndGripper != NULL )
        {
                int g_cxGrip = GetSystemMetrics( SM_CXVSCROLL );
                int g_cyGrip = GetSystemMetrics( SM_CYHSCROLL );
                RECT rc;
                GetClientRect( GetWindow(), &rc);
                return DeferWindowPos( hdwp, m_hwndGripper, NULL,
                                 rc.right - g_cxGrip,
                                 rc.bottom - g_cyGrip,
                                 g_cxGrip,
                                 g_cyGrip,
                                        SWP_NOZORDER | SWP_NOSIZE );
        }
        else
                return hdwp;
}

//
//
//
// Construction/Destruction

CScaleDlg::CScaleDlg(int DlgID, HWND hWndParent, HINSTANCE hInst)
: BASECLASS(DlgID, hWndParent, hInst)
{
}

CScaleDlg::~CScaleDlg()
{

}

//
// Multiply the positions as a result of what they are now.
//
void CScaleDlg::ResizeControls(WORD width, WORD height)
{
        //
        // Perhaps we just scale the fontsize information too?
        //
        int OrigW = m_ParentInfo.GetRightBorder();
        OrigW = m_ParentInfo.GetWidth();
        int OrigH = m_ParentInfo.GetBottomBorder();
        OrigH = m_ParentInfo.GetHeight();

        //
        // SetDialogFont
        //
        HFONT hFont=(HFONT)SendMessage( GetWindow(), WM_GETFONT, 0,0 );
        LOGFONT lf;
        GetObject( (HGDIOBJ)hFont, sizeof(lf), &lf);
        int scalew= width * 100 / OrigW;
        int scaleh=height * 100 / OrigH;
        int scale=scalew;

        if( scalew < scaleh )
                scale=scaleh;

        lf.lfHeight = m_dwInitFontSize * scale / 100;
        HFONT hNewFont=CreateFontIndirect( &lf );

        HWND hCurrent;
        HWND hFirst;
        hCurrent=hFirst=::GetWindow(GetWindow(),GW_CHILD);
        if( hFirst )
        {
                do {
                        SendMessage( hCurrent, WM_SETFONT, (WPARAM)hNewFont, 1 );
                } while (hCurrent=::GetWindow(hCurrent,GW_HWNDNEXT));
        }

        // newX=origX * width / origParentWidth
        //
        // Now setup the information for all of the controls, as to which cell they are in.
        //
        HDWP hdwp = BeginDeferWindowPos( m_ControlList.GetControlCount() +1 ); // 1 for the gripper
        int i=0;
        CResizeControl * pC;
        while( pC=(CResizeControl *) m_ControlList.GetPointer(i++) )
        {
                int x=pC->GetLeftGap(); // GetLeftEdge()->GetPosition();
                int y=pC->GetTopGap(); // GetTopEdge()->GetPosition();
                int w=OrigW - pC->GetRightGap() - x; // GetRightEdge()-GetPosition() - x;
                int h=OrigH - pC->GetBottomGap() - y; // BottomEdge()-GetPosition() -y;

                int newx=x * width / OrigW;
                int newy=y * height / OrigH;

                int neww=w * width / OrigW;
                int newh=h * height / OrigH;


                BOOL bMove=false;
                if( (newx != x) || (newy != y))
                        bMove=true;
                
                BOOL bSize=false;
                if( (newh != h) || (neww != w))
                        bSize=true;

                hdwp = DeferWindowPos( hdwp, pC->GetControl(), NULL, 
                        newx, newy, neww , newh,
                        (bMove ? 0: SWP_NOMOVE) |       (bSize ? 0: SWP_NOSIZE) | SWP_NOZORDER );

        }

        //
        // Move the gripper
        //
        SetGripperPos(hdwp);

        EndDeferWindowPos( hdwp );

}

void CScaleDlg::DeterminWeights()
{
        SetRowWeight(1);
        SetColWeight(1);
        HFONT hFont=(HFONT)SendMessage( GetWindow(), WM_GETFONT, 0,0 );
        LOGFONT lf;
        GetObject( hFont, sizeof(lf), &lf);
        m_dwInitFontSize = lf.lfHeight;
}

void CScaleDlg::DoChangePos(WINDOWPOS * lpwp)
{
        // Lock the apsect ratio.
        if((lpwp->flags & SWP_NOSIZE) == FALSE)
        {
                if( dwLastCX != lpwp->cx )
                        dwLastCY = lpwp->cy = (lpwp->cx * m_ParentInfo.GetHeight()) / m_ParentInfo.GetWidth();

                if( dwLastCY != lpwp->cy )
                        dwLastCX = lpwp->cx = (lpwp->cy * m_ParentInfo.GetWidth()) / m_ParentInfo.GetHeight();
        }
}

void CResizeDlg::DeterminNumberOfControls()
{
        int iControlCount=0;
        HWND hCurrent;
        HWND hFirst;
        hCurrent=hFirst=::GetWindow(GetWindow(),GW_CHILD);
        if( hFirst )
        {
                do {
                        iControlCount++;
                } while (hCurrent=::GetWindow(hCurrent,GW_HWNDNEXT));
        }
        m_ControlCount=iControlCount;
}

//
// Looks for the last row/col being full of buttons.
//
void CResizeDlg::SpecialRowCol()
{
        TRACE("There are %d rows, and %d columns\n", GetNumRows(), GetNumCols() );

        //
        // Walk the controls, find the row/col they are in.
        //
        BOOL bSpecialRow=TRUE;
        BOOL bSpecialCol=TRUE;
        int iNumRows=GetNumRows()-1;
        int iNumCols=GetNumCols()-1;

        //
        // It is a special row if all the heights are the same
        // it is a special col if all the widths are the same
        //
        int iRowHeight=0;
        int iColWidth=0;

        //
        // It's a row/col if there is more than one control there
        //
        int iRowCount=0;
        int iColCount=0;

        //
        // We remember the bounds of the rows/cols
        // left/right is the left of the left button, and the right of the right
        // top/bottom is the top of the topmost, and the bottom of the bottom most.
        //
        RECT    bounds;         // this is the 
        bounds.left=m_ParentInfo.GetWidth();
        bounds.right=0;
        bounds.top=m_ParentInfo.GetHeight();
        bounds.bottom=0;

        int i=0;
        CResizeControl * pC;
        CConstraint     * pCons;
        while( pC=(CResizeControl *) m_ControlList.GetPointer(i++) )
        {
                pCons=&(pC->m_Cons);

                //
                // Column work (widths same)
                //
                if( bSpecialCol )
                {
                        if( ((pCons->GetCol() == iNumCols ) || (pCons->GetCol() + pCons->GetColW() > iNumCols) ))
                        {
                                if( iColWidth==0 )
                                        iColWidth=pC->GetWidth();
                                if( pC->GetWidth() != iColWidth )
                                        bSpecialCol=FALSE;
                                iColCount++;
                        }

                        //
                        // If this item is wholy in this column
                        //
                        if( pCons->GetCol() == iNumCols )
                        {
                                RECT r=pC->GetLocation();
                                if( r.top < bounds.top )
                                        bounds.top = r.top;
                                if( r.bottom > bounds.bottom )
                                        bounds.bottom = r.bottom;
                        }
                }

                if( bSpecialRow )
                {
                        if( (pCons->GetRow() == iNumRows ) || (pCons->GetRow() + pCons->GetRowH() > iNumRows) )
                        {
                                if( iRowHeight==0 )
                                        iRowHeight=pC->GetHeight();
                                if( pC->GetHeight() != iRowHeight )
                                        bSpecialRow=FALSE;
                                iRowCount++;
                        }

                        //
                        // If this item is wholy in this row
                        //
                        if( pCons->GetRow() == iNumRows )
                        {
                                RECT r=pC->GetLocation();
                                if( r.left < bounds.left )
                                        bounds.left = r.left;
                                if( r.right > bounds.right )
                                        bounds.right = r.right;
                        }
                }

                if( (bSpecialCol==FALSE) && ( bSpecialRow==FALSE ) )
                        break;
        }

        m_SpecialRow.bSpecial = iRowCount>1?bSpecialRow:FALSE;
        m_SpecialCol.bSpecial = iColCount>1?bSpecialCol:FALSE;

        //
        // Check the row alignment.
        //
        if( m_SpecialRow.bSpecial )
        {
                int lGap = bounds.left - m_ParentInfo.GetLeftBorder();
                int rGap = m_ParentInfo.GetWidth() - m_ParentInfo.GetRightBorder() - bounds.right;
                TRACE("Constraits on the special row are: left %d, right %d\n",bounds.left, bounds.right );
                TRACE("Parent info is: left %d, right %d\n", m_ParentInfo.GetLeftBorder(), m_ParentInfo.GetWidth() - m_ParentInfo.GetRightBorder() );
                TRACE("Gaps are: left %d, right %d\n", lGap, rGap );
                int GapDiff = lGap - rGap;
                m_SpecialRow.bSpecial = TRUE;
                m_SpecialRow.iMin = bounds.left;
                m_SpecialRow.iMax = bounds.right;
                if( GapDiff < -10 ) 
                {
                        TRACE("Probably a left aligned thing\n");
                        m_SpecialRow.iAlignment = -1;
                }
                else
                if( GapDiff > 10 )
                {
                        TRACE(" Probably a right aligned thing\n");
                        m_SpecialRow.iAlignment = 1;
                }
                else
                {
                        TRACE(" Probably a centered thing\n");
                        m_SpecialRow.iAlignment = 0;
                }
                m_SpecialRow.iDiff=GapDiff;
        }

        //
        // Check the Col alignment.
        //
        if( m_SpecialCol.bSpecial  )
        {
                int tGap = bounds.top - m_ParentInfo.GetTopBorder();
                int bGap = m_ParentInfo.GetHeight() - m_ParentInfo.GetBottomBorder() - bounds.bottom;
                TRACE("Constraits on the special Col are: top %d, bottom %d\n",bounds.top, bounds.bottom);
                TRACE("Parent info is: top %d, bottom %d\n", m_ParentInfo.GetTopBorder(), m_ParentInfo.GetHeight() - m_ParentInfo.GetBottomBorder() );
                TRACE("Gaps are: top %d, bottom %d\n", tGap, bGap );
                int GapDiff = tGap - bGap;
                m_SpecialCol.iMin = bounds.top;
                m_SpecialCol.iMax = bounds.bottom;
                if( GapDiff < -10 ) 
                {
                        TRACE("Probably a left aligned thing\n");
                        m_SpecialCol.iAlignment = -1;
                }
                else
                if( GapDiff > 10 )
                {
                        TRACE(" Probably a right aligned thing\n");
                        m_SpecialCol.iAlignment = 1;
                }
                else
                {
                        TRACE(" Probably a centered thing\n");
                        m_SpecialCol.iAlignment = 0;
                }
                m_SpecialCol.iDiff=GapDiff;
        }
}

---