CATPictureMulti.cpp

Go to the documentation of this file.

//---------------------------------------------------------------------------
/// \file CATPictureMulti.cpp
/// \brief Multiple pictures (like switch multi, but no mouse interaction)
/// \ingroup CATGUI
///
/// Copyright (c) 2003-2008 by Michael Ellison.
/// See COPYING.txt for the \ref gaslicense License (MIT License).
///
// $Author: mikeellison $
// $Date: 2008-01-23 01:43:25 -0600 (Wed, 23 Jan 2008) $
// $Revision:   $
// $NoKeywords: $
//
//---------------------------------------------------------------------------
#include "CATPictureMulti.h"
#include "CATApp.h"
//---------------------------------------------------------------------------
// CATPictureMulti constructor (inherited from CATControl->CATXMLObject)
// \param element - Type name ("Picture")
// \param attribs - attribute information for the window
// \param parent - parent XML object (should be a "Window" element)
// \param rootDir - root directory of skin for bin/png loads
//---------------------------------------------------------------------------
CATPictureMulti::CATPictureMulti(const CATString&             element, 
                                 const CATString&             rootDir)
                                 : CATControl(element,  rootDir)
{
    fBackgroundColor = CATColor(0,0,255);
    fNumImages  = 0;
    fValue      = 0.0f;  
}

/// IsFocusable() returns true if the control can receive
/// focus, and false otherwise.
bool CATPictureMulti::IsFocusable() const
{
    return false;
}
//---------------------------------------------------------------------------
/// CATPictureMulti destructor
//---------------------------------------------------------------------------
CATPictureMulti::~CATPictureMulti()
{
    // Let parent release fImage!
    CATImage *tmpImage = 0;
    while (CATSUCCEEDED(fMasterSet.Pop(tmpImage)))
    {
        CATImage::ReleaseImage(tmpImage);
    }
}

/// ParseAttributes() parses the known attributes for an object.
CATResult CATPictureMulti::ParseAttributes()
{
    CATResult result = CATControl::ParseAttributes();
    CATString attrib;

    fNumImages = GetAttribute(L"NumImage",fNumImages);
    CATUInt32 actualImages = 0;

    for (CATUInt32 i = 0; i < fNumImages; i++)
    {
        CATResult tmpResult;
        CATString attribName;
        CATImage* tmpImage = 0;

        attribName.Format(L"Image_%d",i+1);
        attrib = GetAttribute(attribName);
        if (!attrib.IsEmpty())
        {
            tmpResult = LoadSkinImage(attrib,tmpImage);
            if (CATFAILED(tmpResult))
            {
                result = tmpResult;
            }
            else
            {
                actualImages++;
                fImageList.push_back(tmpImage);

                if (fImage == 0)
                    fImage = tmpImage;
                else
                    fMasterSet.Push(tmpImage);
            }
        }
    }

    if (actualImages != fNumImages)
    {
        CATTRACE("Warning: Multi-Picture didn't have specified number of images.");
        fNumImages = actualImages;
    }

    return result;
}

//---------------------------------------------------------------------------
// Draw() draws the control into the parent window
// \param dirtyRect - portion of control (in window coordinates)
//        that requires redrawing.
//---------------------------------------------------------------------------
void CATPictureMulti::Draw(CATImage* image, const CATRect& dirtyRect)
{
    if (this->IsVisible() == false)
    {
        return;
    }

    // sanity check parent image / dirty rectangle
    CATRect imgRect(0,0,image->Width(), image->Height());
    CATASSERT(imgRect.Inside(dirtyRect), "Update rect is outside of img rect!");

    // Find intersection between dirty rect and us
    CATRect drawRect;
    bool   drawn = false;

    CATUInt32 index = (CATUInt32)fValue;

    if (index >= fNumImages)
    {
        CATASSERT(false,"Invalid value for PictureMulti.");
        index = 0;
    }

    CATImage* normal = fImageList[index];

    CATResult result = CAT_SUCCESS;
    // By default, CATPictureMulti tiles similarly to the window background if the
    // rectangles don't fit.
    if (this->fRect.Intersect(dirtyRect, &drawRect))
    {  
        if (normal)
        {
            if ((normal->Width() == fRect.Width()) && 
                (normal->Height() == fRect.Height()))
            {
                CATRect ourRect = drawRect;
                ourRect.Offset(-fRect.left, -fRect.top);
                // Picture is the size of the rect, so just draw the
                // portion that's dirty.
                result = image->Overlay(normal,drawRect.left,drawRect.top,ourRect.left,ourRect.top,drawRect.Width(),drawRect.Height());
            }
            else
            {
                // OK... gotta do tiling of the picture, but only within the
                // rectangle.
                CATInt32 yPos = drawRect.top;
                CATInt32 totalHeight = drawRect.Height();
                CATInt32 offsetY = (yPos - fRect.top) % normal->Height();

                while (totalHeight > 0)
                {
                    CATInt32 xPos = drawRect.left;
                    CATInt32 copyHeight = CATMin(normal->Height() - offsetY, totalHeight);
                    CATInt32 totalWidth = drawRect.Width();
                    CATInt32 offsetX = (xPos - fRect.left) % normal->Width();

                    while (totalWidth > 0)
                    {
                        CATInt32 copyWidth = CATMin(normal->Width() - offsetX, totalWidth);               
                        result = image->Overlay(normal,xPos,yPos,offsetX,offsetY,copyWidth,copyHeight);
                        xPos += copyWidth;
                        totalWidth -= copyWidth;
                        offsetX = 0;
                    }

                    offsetY = 0;
                    yPos += copyHeight;
                    totalHeight -= copyHeight;
                }
            }
        }
        else
        {
            // No image - 
            result = image->FillRect(drawRect,this->fBackgroundColor);
        }
    }
}

---