edge.cpp

Go to the documentation of this file.

// Edge.cpp: implementation of the CEdge class.
//

#include "pch.h"

#include "Edge.h"
#include "debug.h"
#include "persctl.h"

// Construction/Destruction

CEdge::CEdge()
: m_Guide( new CGuide() ), m_Attatched(NULL)
{
        SetGuide(m_Guide);
}

CEdge::~CEdge()
{

}

CEdge::CEdge( int Position, int Axis, BOOL Flexible, int Offset)
: m_Guide( new CGuide(Position, Axis, Flexible) ), m_Attatched(NULL)
{
        SetOffsetFromGuide(Offset);
        SetGuide(m_Guide);
}

CEdge::CEdge( CGuide * pGuide, int Offset)
: m_Guide(pGuide), m_Attatched(NULL)
{
        SetOffsetFromGuide(Offset);
        SetGuide(m_Guide);
}

//
// Need to take all the attatched components from this guide, and
// add them to the other guide.
//
void    CEdge::SetGuide(CGuide * pGuide)
{ 
        //
        // We still have the same number of controls attatched to this edge
        // remove these controls from the guide.
        //
        if( pGuide != m_Guide )
        {
                TRACE(L"Changing the guide - need to re-attatch?\n");
                m_Guide->DeAttatch(this);
        }

        m_Guide=pGuide;
        pGuide->Attatch( this );
}

void CEdge::Attatch(CResizeControl * pC)
{
        if(m_Attatched==NULL)
                m_Attatched=new CControlList();
        m_Attatched->Append(pC);
}

int CEdge::Attatchment()
{
        CResizeControl * pControl;
        int iRet=0;
        int iNumControls=GetControlCount();
        while( --iNumControls >= 0)
        {
                pControl = GetControl(iNumControls);
                iRet |= pControl->Attatchment( GetGuide() );
        }
        return iRet;
}

//
//
//
CEdgeCache::CEdgeCache()
{
        m_NumVert=0;
        m_NumHoriz=0;
}

CEdgeCache::~CEdgeCache()
{

}

CEdge * CEdgeCache::Create(int Position, int Axis, int Flexible, int Offset)
{
        CEdge * pEdge=new CEdge(Position, Axis, Flexible, Offset);
        AddEdge(pEdge);
        return pEdge;
}

CEdge * CEdgeCache::Create( CGuide * pGuide, int Offset )
{
        CEdge * pEdge=new CEdge(pGuide, Offset);
        AddEdge(pEdge);
        return pEdge;
}

BOOL CEdgeCache::AddEdge(CEdge *pEdge)
{
        if( pEdge->IsHorizontal() )
                SetNumHoriz( GetNumHoriz() + 1 );
        else
                SetNumVert( GetNumVert() + 1 );
        return Append( pEdge );
}

//
//
//
// Construction/Destruction

CGuide::CGuide()
 : m_Axis(0), m_Position(0), m_Flexible(FALSE)
{
        m_Attatched=NULL;
}

CGuide::~CGuide()
{
        if(m_Attatched)
                delete m_Attatched;
}

CGuide::CGuide(int Position, int Axis, BOOL Flexible)
{
        m_Attatched=NULL;
        SetPosition(Position);
        SetAxis(Axis);
        SetFlexible(Flexible);
}

//
// Guides remember what edges are attatched to them.
//
void CGuide::Attatch(CEdge * pEdge)
{
        if(m_Attatched==NULL)
                m_Attatched=new CEdgeList();
        m_Attatched->Append(pEdge);
}

BOOL CGuide::IsEqual(CGuide *pGuide)
{
        return pGuide == this;
}

void CGuide::Adjust(int adjust)
{
        SetPosition( GetPosition() + adjust );
}

int CGuide::NumAttatchments()
{
        if(m_Attatched==NULL)
                return 0;

        int iRet=0;
        int iCount=0;
        int iNumEdges= m_Attatched->GetEdgeCount();
        while( --iNumEdges>=0 )
        {
                CEdge * pEdge= GetEdge(iNumEdges);
                iRet += pEdge->GetControlCount();
        }
        return iRet;
}

//
// Attempts to work out if this is a top/bottom/left/right guide.
//
int CGuide::Attatchment()
{
        if(m_Attatched==NULL)
                return 0;

        int iRet=0;
        int iCount=0;
        int iNumEdges= m_Attatched->GetEdgeCount();
        while( --iNumEdges>=0 )
        {
                CEdge * pEdge= GetEdge(iNumEdges);
                iRet |= pEdge->Attatchment();
        }
        return iRet;
}

CEdge * CGuide::GetEdge(int i)
{
        if(m_Attatched==NULL)
                return NULL;
        return m_Attatched->GetEdge(i);
}

void CGuide::DeAttatch( CEdge * pEdge )
{
        //
        // Go throught the list - null our this edge - it's no longer ours.
        //
        int iCount=m_Attatched->GetEdgeCount();
        while (--iCount>=0)
        {
                CEdge * p=GetEdge(iCount);
                if(p==pEdge)
                        m_Attatched->Remove(iCount);
        }
}

//
//
//
// Constraint.cpp: implementation of the CConstraint class.
//


// Construction/Destruction

CConstraint::CConstraint()
{

}

CConstraint::~CConstraint()
{

}

//
//
//
// ControlList.cpp: implementation of the CControlList class.
//

// Construction/Destruction

CControlList::CControlList()
{

}

CControlList::~CControlList()
{

}

---