Web alhem.net

Surface.cpp

Go to the documentation of this file.

/*
Copyright (C) 2004  Anders Hedstrom

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
#include <SDL.h>
#include "guitypedefs.h"
#ifdef _WIN32
#pragma warning(push)

#include <yvals.h> // warning numbers get enabled in yvals.h 

#pragma warning(disable: 4251)  
#pragma warning(disable: 4786)  // identifier was truncated to 'number' characters in the debug information

// BUG: C4786 Warning Is Not Disabled with #pragma Warning
// STATUS: Microsoft has confirmed this to be a bug in the Microsoft product. This warning can be ignored.
// This occured only in the <map> container.

#include <sge.h>

#pragma warning(pop)
#else
#include <sge.h>
#endif
//#include <iotm/Mutex.h>

//#include "TimerThread.h"
#include "SDLControl.h"
#include "SurfaceHelper.h"
#include "TTFont.h"
#include "GuiEvent.h"
#include "Xml.h"
#include "Surface.h"
#include "Button.h"
#include "Hotspot.h"
#include "Dialog.h"
#include "Edit.h"
#include "MenuItem.h"
#include "Menu.h"
#include "PopupMenuItem.h"
#include "SeparatorMenuItem.h"
#include "Output.h"
#include "Progress.h"
#include "Static.h"

using util::Xml;


namespace gui
{
unsigned long Surface::m_unique_id = 0;

Surface::Surface(SDLControl *pclControl,coord_t x,coord_t y,coord_t w,coord_t h,SurfaceHelper *pclHelper)
:m_screen(NULL)
,m_temp_screen(NULL)
,m_id(m_unique_id++)
,m_local_id(0)
,m_pclParent(NULL)
,m_pclControl(pclControl)
,m_pclHelper(pclHelper)
,m_x(x)
,m_y(y)
,m_w(w)
,m_h(h)
,m_x_absolute(0)
,m_y_absolute(0)
,m_bBgColorIsSet(false)
,m_bFgColorIsSet(false)
,m_bFrameColorIsSet(false)
,m_pclTTFont(NULL)
,m_nAlpha(0)
,m_bAlphaIsSet(0)
,m_nFrameWidth(0)
,m_bFrameWidthIsSet(false)
//,m_strName("")
//,m_style(0)
,m_bVisible(true)
,m_bChildrenVisible(true)
,m_bInverted(false)
,m_bTransparent(false)
,m_bMoveable(false)
,m_bDirty(true)
,m_bResizeArea(false)
,m_bAnchorRight(false)
,m_bAnchorDown(false)
,m_bMustBeDeleted(false)
,m_bClickable(false)
,m_bUseTemporaryScreen(false)
,m_text("")
,m_bRedrawTemporary(false)
,m_pclBond(NULL)
,m_uicommand(UICOMMAND_NONE)
{
        coord_t fw = GetFrameWidth();
        
        m_screen = CreateSDLSurface(true);

        m_clientRect.x = fw;
        m_clientRect.y = fw;
        m_clientRect.w = m_w - fw * 2;
        m_clientRect.h = m_h - fw * 2;
        m_absoluteRect.x = 0;
        m_absoluteRect.y = 0;
        m_absoluteRect.w = m_w;
        m_absoluteRect.h = m_h;
}


Surface::Surface(Surface *pclParent,coord_t x,coord_t y,coord_t w,coord_t h,SurfaceHelper *pclHelper)
:m_screen(NULL)
,m_temp_screen(NULL)
,m_id(m_unique_id++)
,m_local_id(0)
,m_pclParent(pclParent)
,m_pclControl(NULL)
,m_pclHelper(pclHelper)
,m_x(x)
,m_y(y)
,m_w(w)
,m_h(h)
,m_x_absolute(0)
,m_y_absolute(0)
,m_bBgColorIsSet(false)
,m_bFgColorIsSet(false)
,m_bFrameColorIsSet(false)
,m_pclTTFont(NULL)
,m_nAlpha(0)
,m_bAlphaIsSet(0)
,m_nFrameWidth(0)
,m_bFrameWidthIsSet(false)
//,m_strName("")
//,m_style(0)
,m_bVisible(true)
,m_bChildrenVisible(true)
,m_bInverted(false)
,m_bTransparent(false)
,m_bMoveable(false)
,m_bDirty(true)
,m_bResizeArea(false)
,m_bAnchorRight(false)
,m_bAnchorDown(false)
,m_bMustBeDeleted(false)
,m_bClickable(false)
,m_bUseTemporaryScreen(false)
,m_text("")
,m_bRedrawTemporary(false)
,m_pclBond(NULL)
,m_uicommand(UICOMMAND_NONE)
{
        coord_t fw = GetFrameWidth();

        m_screen = CreateSDLSurface(true);

        m_clientRect.x = fw;
        m_clientRect.y = fw;
        m_clientRect.w = m_w - fw * 2;
        m_clientRect.h = m_h - fw * 2;
        m_absoluteRect.x = 0;
        m_absoluteRect.y = 0;
        m_absoluteRect.w = m_w;
        m_absoluteRect.h = m_h;
}


Surface::Surface(Surface *pclParent,SurfaceHelper *pclHelper)
:m_screen(NULL)
,m_temp_screen(NULL)
,m_id(m_unique_id++)
,m_local_id(0)
,m_pclParent(pclParent)
,m_pclControl(NULL)
,m_pclHelper(pclHelper)
,m_x(0)
,m_y(0)
,m_w(0)
,m_h(0)
,m_x_absolute(0)
,m_y_absolute(0)
,m_bBgColorIsSet(false)
,m_bFgColorIsSet(false)
,m_bFrameColorIsSet(false)
,m_pclTTFont(NULL)
,m_nAlpha(0)
,m_bAlphaIsSet(0)
,m_nFrameWidth(0)
,m_bFrameWidthIsSet(false)
//,m_strName("")
//,m_style(0)
,m_bVisible(true)
,m_bChildrenVisible(true)
,m_bInverted(false)
,m_bTransparent(false)
,m_bMoveable(false)
,m_bDirty(true)
,m_bResizeArea(false)
,m_bAnchorRight(false)
,m_bAnchorDown(false)
,m_bMustBeDeleted(false)
,m_bClickable(false)
,m_bUseTemporaryScreen(false)
,m_text("")
,m_bRedrawTemporary(false)
,m_pclBond(NULL)
,m_uicommand(UICOMMAND_NONE)
{
}


Surface::~Surface()
{
        surfacevector_t::iterator it;

        // unlink bonds 
        if (GetBond())
        {
                GetBond() -> Unbond(this);
        }
        for (it = m_bonds.begin(); it != m_bonds.end(); it++)
        {
                (*it) -> SetBond(NULL);
        }
        // unlink parent stuff
        if (GetParent())
        {
                GetParent() -> Remove(this);
        }
        for (it = m_ChildList.begin(); it != m_ChildList.end(); it++)
        {
                Surface *pclSurface = *it;
                if (pclSurface -> MustBeDeleted())
                {
                        delete pclSurface;
                }
        }
        // delete screens
        if (m_screen)
        {
                SDL_FreeSurface(m_screen);
        }
        if (m_temp_screen)
        {
                SDL_FreeSurface(m_temp_screen);
        }
}


SDL_Surface *Surface::CreateSDLSurface(bool bAlpha)
{
        Uint32 rmask, gmask, bmask, amask;
        SDLControl *pcl = GetSDLControl();
        SDL_Surface *pclSurf = pcl -> GetScreen();
        int depth = pcl -> GetBpp();

        rmask = pclSurf -> format -> Rmask;
        gmask = pclSurf -> format -> Gmask;
        bmask = pclSurf -> format -> Bmask;
        amask = pclSurf -> format -> Amask;
        if (0 && !amask)
        {
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
                amask = 0x000000ff;
#else
                amask = 0xff000000;
#endif
        }

        // SDL interprets each pixel as a 32-bit number, so our masks must depend
        // on the endianness (byte order) of the machine 
        if (bAlpha)
        {
        depth = 32;
        switch (depth)
        {
        case 24:
                rmask = 0x0000003f;
                gmask = 0x00000fc0;
                bmask = 0x0003f000;
                amask = 0x00fc0000;
                break;
        case 32:
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
        rmask = 0xff000000;
        gmask = 0x00ff0000;
        bmask = 0x0000ff00;
        amask = 0x000000ff;
#else
        rmask = 0x000000ff;
        gmask = 0x0000ff00;
        bmask = 0x00ff0000;
        amask = 0xff000000;
#endif
                break;
        default:
                rmask = gmask = bmask = amask = 0;
        }
        } // if (bAlpha)

        DEB(
        printf("CreateSDLSurface() depth = %d\n", depth);
        printf(" rmask = %08x\n", rmask);
        printf(" gmask = %08x\n", gmask);
        printf(" bmask = %08x\n", bmask);
        printf(" amask = %08x\n", amask);
        )

        SDL_Surface *screen;
        if (!(screen = SDL_CreateRGBSurface(SDL_SWSURFACE, m_w, m_h, depth, rmask, gmask, bmask, amask)))
        {
                fprintf(stderr, "CreateRGBSurface failed: %s", SDL_GetError());
//              exit(1);
        }
        return screen;
}


void Surface::AddChild(Surface *pclChild)
{
        m_ChildList.insert(m_ChildList.end(), pclChild);
        pclChild -> SetLocalID( m_ChildList.size() );
        pclChild -> SetParent( this );
        CalculateAbsolute();
}


void Surface::BringToTop(Surface *pclChild)
{
        surfacevector_t::iterator it;

        if (pclChild != GetChildOnTop())
        {
                for (it = m_ChildList.begin(); it != m_ChildList.end(); it++)
                {
                        if (*it == pclChild)
                        {
                                m_ChildList.erase(it);
                                break;
                        }
                }
                if (it != m_ChildList.end())
                {
                        m_ChildList.insert(m_ChildList.end(), pclChild);
                }
        }
}


void Surface::BringToTop()
{
        Surface *pclParent = GetParent();
        
        if (pclParent)
        {
                pclParent -> BringToTop(this);
        }
}


Surface *Surface::GetChildOnTop()
{
        surfacevector_t::iterator it;
        Surface *pclTemp = NULL;
        
        for (it = m_ChildList.begin(); it != m_ChildList.end(); it++)
        {
                pclTemp = *it;
        }
        return pclTemp;
}


void Surface::Remove(Surface *pclChild)
{
        surfacevector_t::iterator it;
        
        for (it = m_ChildList.begin(); it != m_ChildList.end(); it++)
        {
                Surface *pclSurface = *it;
                if (pclSurface == pclChild)
                {
                        m_ChildList.erase(it);
                        break;
                }
        }
        if (pclChild -> MustBeDeleted())
        {
                delete pclChild;
        }
}


Surface *Surface::FindSurface(coord_t xpos,coord_t ypos,coord_t X,coord_t Y)
{
        surfacevector_t::iterator it;
        Surface *pclFound = NULL;

        if (m_bChildrenVisible)
        {
                for (it = m_ChildList.begin(); it != m_ChildList.end(); it++)
                {
                        Surface *pclTemp = *it;
                        if (pclTemp -> IsVisible())
                        {
                                if (xpos >= pclTemp -> GetAbsoluteX() &&
                                    xpos <  pclTemp -> GetAbsoluteX() + pclTemp -> GetW() &&
                                    ypos >= pclTemp -> GetAbsoluteY() &&
                                    ypos <  pclTemp -> GetAbsoluteY() + pclTemp -> GetH() )
/*
                                if (xpos > X + pclTemp -> GetX() &&
                                        xpos < X + pclTemp -> GetX() + pclTemp -> GetW() &&
                                        ypos > Y + pclTemp -> GetY() &&
                                        ypos < Y + pclTemp -> GetY() + pclTemp -> GetH())
*/
                                {
                                        pclFound = pclTemp;
                                }
                        }
                }
        }
        if (pclFound)
                return pclFound -> FindSurface(xpos,ypos); // ,X + pclFound -> GetX(),Y + pclFound -> GetY());
        else
                return this;
}


void Surface::CalculateAbsolute()
{
        surfacevector_t::iterator it;
        
        for (it = m_ChildList.begin(); it != m_ChildList.end(); it++)
        {
                Surface *pclTemp = *it;
                coord_t fw = GetFrameWidth();
                coord_t x = GetAbsoluteX() + pclTemp -> GetX() + fw;
                coord_t y = GetAbsoluteY() + pclTemp -> GetY() + fw;
                pclTemp -> SetAbsoluteX(x);
                pclTemp -> SetAbsoluteY(y);
                pclTemp -> CalculateAbsolute();
        }
}


/*
void Surface::Clip(SDL_Rect *dst)
{
        coord_t xmax = GetSDLControl() -> GetScreen() -> w;
        coord_t ymax = GetSDLControl() -> GetScreen() -> h;

        // kontroll utanfor ytan
        if (dst -> x + dst -> w > xmax)
        {
                dst -> w -= dst -> x + dst -> w - xmax;
        }
        if (dst -> y + dst -> h > ymax)
        {
                dst -> h -= dst -> y + dst -> h - ymax;
        }
        //
}
*/


void Surface::RecreateSurfaces()
{
        int xrel = 0;
        int yrel = 0;
        bool event = false;

        if (UseTemporaryScreen())
        {
                if (m_temp_screen)
                {
                        FreeSurface(m_temp_screen);
                }
        }
        if (m_screen)
        {
                xrel = GetScreen() -> w;
                yrel = GetScreen() -> h;
                event = true;
                FreeSurface(m_screen);
        }

        m_screen = CreateSDLSurface(true);
        if (UseTemporaryScreen())
        {
                CreateTemporaryScreen();
        }

        if (event)
        {
                surfacevector_t::iterator it;
                xrel = GetScreen() -> w - xrel;
                yrel = GetScreen() -> h - yrel;
                for (it = m_ChildList.begin(); it != m_ChildList.end(); it++)
                {
                        (*it) -> OnSize(*GetClientRectPtr(), xrel, yrel);
                }
        }

//      GetParent() -> CalculateAbsolute();
//      DrawAll();
//      DrawTemporaryScreen();
        SetDirty(true);
}


void Surface::FreeSurface(SDL_Surface *pclSurface)
{
        SDL_FreeSurface(pclSurface);
}


void Surface::InvalidateEv()
{
        SDL_Event e;
        
        e.type = SDL_USEREVENT;
        e.user.code = SDL_USEREVENT_INVALIDATE;
        e.user.data1 = this;
        e.user.data2 = NULL;
        SDL_PushEvent(&e);
}


void Surface::InvalidateRectEv(SDL_Rect &a)
{
        SDL_Event e;
        long xy = a.x * 0x10000 + a.y;
        long wh = a.w * 0x10000 + a.h;
        
        e.type = SDL_USEREVENT;
        e.user.code = SDL_USEREVENT_INVALIDATERECT;
        memmove(&e.user.data1, &xy, 4);
        memmove(&e.user.data2, &wh, 4);
        SDL_PushEvent(&e);
}


void Surface::FillRectEv(SDL_Rect &a)
{
        SDL_Event e;
        long xy = a.x * 0x10000 + a.y;
        long wh = a.w * 0x10000 + a.h;
        
        e.type = SDL_USEREVENT;
        e.user.code = SDL_USEREVENT_FILLRECT;
        memmove(&e.user.data1, &xy, 4);
        memmove(&e.user.data2, &wh, 4);
        SDL_PushEvent(&e);
}


void Surface::ResetFillRectsEv()
{
        SDL_Event e;
        
        e.type = SDL_USEREVENT;
        e.user.code = SDL_USEREVENT_RESETFILLRECTS;
        e.user.data1 = NULL;
        e.user.data2 = NULL;
        SDL_PushEvent(&e);
}


/*
void Surface::RedrawEv()
{
        SDL_Event e;
//      long l = SDL_GetTicks();

        e.type = SDL_USEREVENT;
        e.user.code = SDL_USEREVENT_REDRAWSURFACE;
        e.user.data1 = this;
        e.user.data2 = NULL;
//      memmove(&e.user.data2,&l,4);
        SDL_PushEvent(&e);
}
*/


/*
void Surface::Invalidate()
{
        SDLControl *pcl = GetSDLControl();
        SDL_Rect a;
        Surface *root = GetRoot();
        Surface *parent = GetParent();

        if (parent)
        {
                parent -> DrawTemporaryScreen();
        }

        pcl -> lockSurface();
        a = GetAbsoluteRect();
        root -> BlitAbsolute(&a);
        pcl -> unlockSurface();
        SDL_UpdateRects(pcl -> GetScreen(), 1, &a);

//      SDL_WarpMouse(GuiEvent::m_x, GuiEvent::m_y);
}


void Surface::InvalidateRect(SDL_Rect &a)
{
        SDLControl *pcl = GetSDLControl();
        Surface *root = GetRoot();
        Surface *parent = GetParent();

        if (parent)
        {
                parent -> DrawTemporaryScreen();
        }

        pcl -> lockSurface();
        root -> BlitAbsolute(&a);
        pcl -> unlockSurface();
        SDL_UpdateRects(pcl -> GetScreen(), 1, &a);

//      SDL_WarpMouse(GuiEvent::m_x, GuiEvent::m_y);
}
*/


void Surface::Draw()
{
}


void Surface::DrawAll()
{
        surfacevector_t::iterator it;

        if (IsDirty())
        {
                Draw();
                DrawFrame(GetScreen(), GetFrameWidth(), GetFrameColor());
                Surface *pclParent = this; //GetParent();
                while (pclParent)
                {
                        if (pclParent -> UseTemporaryScreen())
                        {
                                pclParent -> DrawTemporaryScreen();
                        }
                        pclParent = pclParent -> GetParent();
                }
                SetDirty(false);
        }
        for (it = m_ChildList.begin(); it != m_ChildList.end(); it++)
        {
                (*it) -> DrawAll();
        }
//      if (UseTemporaryScreen())
//      {
//              DrawTemporaryScreen();
//      }
}


void Surface::DrawFrame(SDL_Surface *screen,coord_t fw,Uint32 color)
{
        SDL_Rect rect;

        rect.x = 0;
        rect.y = 0;
        rect.w = m_w;
        rect.h = fw;
        SDL_FillRect(screen, &rect, color);

        rect.x = 0;
        rect.y = 0;
        rect.w = fw;
        rect.h = m_h;
        SDL_FillRect(screen, &rect, color);

        rect.x = m_w - fw;
        rect.y = 0;
        rect.w = fw;
        rect.h = m_h;
        SDL_FillRect(screen, &rect, color);

        rect.x = 0;
        rect.y = m_h - fw;
        rect.w = m_w;
        rect.h = fw;
        SDL_FillRect(screen, &rect, color);

}


void Surface::Blit(coord_t X,coord_t Y,SDL_Surface *s)
{
        SDL_Surface *pclSDLSurface = s ? s : GetSDLControl() -> GetScreen();
        coord_t xmax = pclSDLSurface->w;
        coord_t ymax = pclSDLSurface->h;

        if (m_bVisible || m_bRedrawTemporary)
        {
                SDL_Rect src;
                SDL_Rect dst;
                coord_t fw = GetParent() ? GetParent() -> GetFrameWidth() : 0;
                src.x = src.y = 0;
                dst.x = X + m_x + fw;
                dst.y = Y + m_y + fw;
                src.w = dst.w = m_w;
                src.h = dst.h = m_h;
                // kontroll utanfor ytan
                if (dst.x + dst.w > xmax)
                {
                        dst.w -= dst.x + dst.w - xmax;
                        src.w = dst.w;
                }
                if (dst.y + dst.h > ymax)
                {
                        dst.h -= dst.y + dst.h - ymax;
                        src.h = dst.h;
                }
                //
                if (UseTemporaryScreen())
                {
                        SDL_BlitSurface(GetTemporaryScreen(), &src, pclSDLSurface, &dst);
                }
                else
                {
                        if (!IsTransparent())
                        {
                                SDL_BlitSurface(GetScreen(), &src, pclSDLSurface, &dst);
                        }
                        if (m_bChildrenVisible)
                        {
                                surfacevector_t::iterator it;

                                for (it = m_ChildList.begin(); it != m_ChildList.end(); it++)
                                {
                                        (*it) -> Blit(X + m_x + fw, Y + m_y + fw, pclSDLSurface);
                                }
                        }
                }
        }
}


#define MIN(x,y) (x<y)?x:y
#define MAX(x,y) (x>y)?x:y

void Surface::BlitAbsolute(SDL_Rect *pclRect,SDL_Surface *s)
{
        SDL_Surface *pclSDLSurface = s ? s : GetSDLControl() -> GetScreen();
        coord_t xmax = pclSDLSurface->w;
        coord_t ymax = pclSDLSurface->h;

        if (m_bVisible) // || UseTemporaryScreen())
        {
                SDL_Rect dst;
                SDL_Rect *area = GetAbsoluteRectPtr();
                coord_t r;
                coord_t b;
                coord_t w;
                coord_t h;
                dst.x = MAX(pclRect -> x,area -> x);
                dst.y = MAX(pclRect -> y,area -> y);
                r = MIN(pclRect -> x + pclRect -> w,area -> x + area -> w);
                b = MIN(pclRect -> y + pclRect -> h,area -> y + area -> h);
                w = r - dst.x;
                h = b - dst.y;
                if (w > 0 && h > 0)
                {
                        SDL_Rect src;
                        src.x = dst.x - area -> x;
                        src.y = dst.y - area -> y;
                        src.w = dst.w = w;
                        src.h = dst.h = h;
                        // kontroll utanfor ytan
                        if (dst.x + dst.w > xmax)
                        {
                                dst.w -= dst.x + dst.w - xmax;
                                src.w = dst.w;
                        }
                        if (dst.y + dst.h > ymax)
                        {
                                dst.h -= dst.y + dst.h - ymax;
                                src.h = dst.h;
                        }
                        //
                        if (UseTemporaryScreen())
                        {
                                SDL_BlitSurface(GetTemporaryScreen(), &src, pclSDLSurface, &dst);
                        }
                        else
                        {
                                if (!m_bTransparent)
                                {
                                        SDL_BlitSurface(GetScreen(), &src, pclSDLSurface, &dst);
                                }

                                if (m_bChildrenVisible)
                                {
                                        surfacevector_t::iterator it;

                                        for (it = m_ChildList.begin(); it != m_ChildList.end(); it++)
                                        {
                                                (*it) -> BlitAbsolute(pclRect, pclSDLSurface);
                                        }
                                }
                        } // UseTemporaryScreen
                }
        }
}


/*
void Surface::Update8bitPalette()
{
        surfacevector_t::iterator it;

//      SDL_SetColors(m_screen, gui::Color::m_palette, 0, gui::Color::m_qcolors);
        for (it = m_ChildList.begin(); it != m_ChildList.end(); it++)
        {
                (*it) -> Update8bitPalette();
        }
}
*/


void Surface::Move(Surface *pclRootSurface,coord_t xrel,coord_t yrel)
{
        coord_t x = GetX() + xrel;
        coord_t y = GetY() + yrel;
        coord_t wmax = GetParent() -> GetW();
        coord_t hmax = GetParent() -> GetH();
                
        x = (x < 0) ? 0 : x;
        y = (y < 0) ? 0 : y;
        x = (x + GetW() > wmax) ? wmax - GetW() : x;
        y = (y + GetH() > hmax) ? hmax - GetH() : y;

        SDL_Rect a = GetAbsoluteRect();
        pclRootSurface -> InvalidateRectEv(a);
        SetX(x);
        SetY(y);
        GetParent() -> CalculateAbsolute();
        InvalidateEv();

        for (surfacevector_t::iterator it = m_bonds.begin(); it != m_bonds.end(); it++)
        {
                (*it) -> Move(pclRootSurface,xrel,yrel);
        }
}


void Surface::MoveTo(Surface *pclRootSurface,coord_t x,coord_t y,bool bVisible)
{
        int xrel = x - GetX();
        int yrel = y - GetY();
        coord_t wmax = GetParent() -> GetW();
        coord_t hmax = GetParent() -> GetH();
                
        x = (x < 0) ? 0 : x;
        y = (y < 0) ? 0 : y;
        x = (x + GetW() > wmax) ? wmax - GetW() : x;
        y = (y + GetH() > hmax) ? hmax - GetH() : y;

        if (IsVisible())
        {
                SDL_Rect a = GetAbsoluteRect();
                pclRootSurface -> InvalidateRectEv(a);
        }
        SetVisible(bVisible);
        for (surfacevector_t::iterator it = m_bonds.begin(); it != m_bonds.end(); it++)
        {
                (*it) -> SetVisible(bVisible);
                (*it) -> InvalidateEv();
        }
        if (bVisible)
        {
                SetX(x);
                SetY(y);
                GetParent() -> CalculateAbsolute();
                InvalidateEv();

                for (surfacevector_t::iterator it = m_bonds.begin(); it != m_bonds.end(); it++)
                {
                        (*it) -> Move(pclRootSurface,xrel,yrel);
                }
        }
}


void Surface::OnEvent(surface_event_t *pstEvent)
{
        Surface *pclParent = GetParent();
        
        if (pclParent)
        {
                pstEvent -> id = GetID();
                pstEvent -> local_id = GetLocalID();
                pstEvent -> ptr = this;
                pclParent -> OnEvent(pstEvent);
        }
}


void Surface::OnMouseIn()
{
//DEB(printf("OnMouseIn()\n");)
}


void Surface::OnMouseOut()
{
//DEB(printf("OnMouseOut()\n");)
}


void Surface::OnKeyDown(SDL_keysym sym)
{
//DEB(printf("OnKeyDown()\n");)
}


void Surface::OnKeyUp(SDL_keysym sym)
{
//DEB(printf("OnKeyUp()\n");)
}


void Surface::OnButton()
{
//DEB(printf("OnButton()\n");)
        Surface *pclParent = GetParent();
        if (m_uicommand != UICOMMAND_NONE)
        {
                SDL_Event e;
                e.type = SDL_USEREVENT;
                e.user.code = SDL_USEREVENT_UICOMMAND;
                memmove(&e.user.data1,this,4);
                memmove(&e.user.data2,&m_uicommand,4);
                SDL_PushEvent(&e);
        }
        if (pclParent)
        {
                surface_event_t e;
                e.type = GUI_EVENT_BUTTON;
                e.id = GetID();
                e.local_id = GetLocalID();
                e.ptr = this;
                pclParent -> OnEvent(&e);
        }
}


void Surface::OnClose()
{
        Surface *pclParent = GetParent();
        if (pclParent)
        {
                surface_event_t e;
                e.type = GUI_EVENT_CLOSE;
                e.id = GetID();
                e.local_id = GetLocalID();
                e.ptr = this;
                pclParent -> OnEvent(&e);
        }
}


void Surface::OnFocus()
{
}


void Surface::OnLostFocus()
{
}


void Surface::OnHide()
{
}


void Surface::OnShow()
{
}


void Surface::OnSize(SDL_Rect &r,int xrel,int yrel)
{
        // kolla anchor, stretch
        if (IsAnchorRight())
        {
                SetX(GetX() + xrel);
        }
        if (IsAnchorDown())
        {
                SetY(GetY() + yrel);
        }
}


void Surface::OnMouseMove(coord_t x,coord_t y,coord_t xrel,coord_t yrel)
{
}


void Surface::OnRightClick(coord_t x,coord_t y)
{
        Surface *pclParent = GetParent();
        
        if (pclParent)
        {
                pclParent -> OnRightClick(x,y);
        }
}


void Surface::OnClick(coord_t x,coord_t y)
{
        Surface *pclParent = GetParent();
        
        if (pclParent)
        {
                pclParent -> OnClick(x,y);
        }
}


void Surface::OnTimer(long id)
{
}


/*
void Surface::SetTimer(long time_ms,long id,bool bRepeating)
{
        GetSDLControl() -> GetTimerThread() -> Add(this, time_ms, id, bRepeating);
}
*/


void Surface::SetParent(Surface *s)
{
        m_pclParent = s;
}


void Surface::SetX(coord_t x)
{
        m_x = x;
}


void Surface::SetY(coord_t y)
{
        m_y = y;
}


void Surface::SetW(coord_t w,bool bRealloc)
{
        m_clientRect.w = w - GetFrameWidth() * 2;
        m_absoluteRect.w = w;
        m_w = w;

        if (bRealloc)
        {
                RecreateSurfaces();
        }
}


void Surface::SetH(coord_t h,bool bRealloc)
{
        m_clientRect.h = h - GetFrameWidth() * 2;
        m_absoluteRect.h = h;
        m_h = h;

        if (bRealloc)
        {
                RecreateSurfaces();
        }
}


void Surface::SetAlpha(alpha_t a,bool bRecurse)
{
        surfacevector_t::iterator it;
        m_nAlpha = a;
        m_bAlphaIsSet = true;
        SDL_SetAlpha(m_screen, SDL_SRCALPHA|SDL_RLEACCEL, a);
        if (bRecurse)
        {
                for (it = m_ChildList.begin(); it != m_ChildList.end(); it++)
                {
                        (*it) -> UpdateAlpha(a);
                }
        }
}


void Surface::UpdateAlpha(alpha_t a)
{
        surfacevector_t::iterator it;
        if (!m_bAlphaIsSet)
        {
                m_nAlpha = a;
                SDL_SetAlpha(m_screen, SDL_SRCALPHA|SDL_RLEACCEL, a);
        }
        for (it = m_ChildList.begin(); it != m_ChildList.end(); it++)
        {
                (*it) -> UpdateAlpha(a);
        }
}


void Surface::SetAbsoluteX(coord_t x)
{
        m_absoluteRect.x = x;
        m_x_absolute = x;
}


void Surface::SetAbsoluteY(coord_t y)
{
        m_absoluteRect.y = y;
        m_y_absolute = y;
}


void Surface::SetVisible(bool b)
{
        surfacevector_t::iterator it;

        if (b != m_bVisible)
        {
                m_bVisible = b;
                for (it = m_ChildList.begin(); it != m_ChildList.end(); it++)
                {
                        if (b)
                        {
                                (*it) -> OnShow();
                        }
                        else
                        {
                                (*it) -> OnHide();
                        }
                }
                if (!b)
                {
                }
//              if (b)
//              {
//                      BringToTop();
//              }
        }
}


void Surface::SetChildrenVisible(bool b)
{
        m_bChildrenVisible = b;
}


/*
void Surface::SetBgColor(color_t pclColor)
{
        m_BgColor = pclColor;
        m_bBgColorIsSet = true;
}
*/


void Surface::SetBgColor(Uint8 r,Uint8 g,Uint8 b,Uint8 alpha)
{
        m_bgColor.r = r;
        m_bgColor.g = g;
        m_bgColor.b = b;
        m_bgColor.unused = alpha;
        m_bBgColorIsSet = true;
}


/*
void Surface::SetFgColor(color_t pclColor)
{
        m_FgColor = pclColor;
        m_bFgColorIsSet = true;
}
*/


void Surface::SetFgColor(Uint8 r,Uint8 g,Uint8 b,Uint8 alpha)
{
        m_fgColor.r = r;
        m_fgColor.g = g;
        m_fgColor.b = b;
        m_fgColor.unused = alpha;
        m_bFgColorIsSet = true;
}


void Surface::SetTTFont(TTFont *pclTTFont)
{
        m_pclTTFont = pclTTFont;
}


void Surface::SetFrameWidth(coord_t fw)
{
        m_nFrameWidth = fw;
        m_bFrameWidthIsSet = true;

        CalculateClientRect();
}


void Surface::CalculateClientRect()
{
        coord_t fw = GetFrameWidth();

        m_clientRect.x = fw;
        m_clientRect.y = fw;
        m_clientRect.w = m_w - fw * 2;
        m_clientRect.h = m_h - fw * 2;

        for (surfacevector_t::iterator it = m_ChildList.begin(); it != m_ChildList.end(); it++)
        {
                (*it) -> CalculateClientRect();
        }
}


/*
void Surface::SetFrameColor(color_t pclColor)
{
        m_FrameColor = pclColor;
        m_bFrameColorIsSet = true;
}
*/


void Surface::SetFrameColor(Uint8 r,Uint8 g,Uint8 b,Uint8 alpha)
{
        m_frameColor.r = r;
        m_frameColor.g = g;
        m_frameColor.b = b;
        m_frameColor.unused = alpha;
        m_bFrameColorIsSet = true;
}


SDL_Surface *Surface::GetScreen()
{
        return m_screen;
}


Surface *Surface::GetParent()
{
        return m_pclParent;
}


Surface *Surface::GetRoot()
{
        return m_pclParent ? m_pclParent -> GetRoot() : this;
}


color_t Surface::GetBgColor()
{
        if (IsInverted())
        {
                if (m_bFgColorIsSet)
                {
                        return SDL_MapRGBA(m_screen->format, m_fgColor.r, m_fgColor.g, m_fgColor.b, m_fgColor.unused);
                }
                if (m_pclParent)
                {
                        return m_pclParent -> GetFgColor();
                }
                return 0;
        }
        else
        {
                if (m_bBgColorIsSet)
                {
                        return SDL_MapRGBA(m_screen->format, m_bgColor.r, m_bgColor.g, m_bgColor.b, m_bgColor.unused);
                }
        }
        if (m_pclParent)
        {
                return m_pclParent -> GetBgColor();
        }
        return 0;
}


void Surface::GetBgColor(SDL_Color &color)
{
        if (IsInverted())
        {
                if (m_bFgColorIsSet)
                {
                        color = m_fgColor;
                        return;
                }
                if (m_pclParent)
                {
                        m_pclParent -> GetFgColor(color);
                }
        }
        else
        {
                if (m_bBgColorIsSet)
                {
                        color = m_bgColor;
                        return;
                }
                if (m_pclParent)
                {
                        m_pclParent -> GetBgColor(color);
                }
        }
}


color_t Surface::GetFgColor()
{
        if (IsInverted())
        {
                if (m_bBgColorIsSet)
                {
                        return SDL_MapRGBA(m_screen->format, m_bgColor.r, m_bgColor.g, m_bgColor.b, m_bgColor.unused);
                }
                if (m_pclParent)
                {
                        return m_pclParent -> GetBgColor();
                }
                return 0;
        }
        else
        {
                if (m_bFgColorIsSet)
                {
                        return SDL_MapRGBA(m_screen->format, m_fgColor.r, m_fgColor.g, m_fgColor.b, m_fgColor.unused);
                }
        }
        if (m_pclParent)
        {
                return m_pclParent -> GetFgColor();
        }
        return 0;
}


void Surface::GetFgColor(SDL_Color &color)
{
        if (IsInverted())
        {
                if (m_bBgColorIsSet)
                {
                        color = m_bgColor;
                        return;
                }
                if (m_pclParent)
                {
                        m_pclParent -> GetBgColor(color);
                }
        }
        else
        {
                if (m_bFgColorIsSet)
                {
                        color = m_fgColor;
                        return;
                }
                if (m_pclParent)
                {
                        m_pclParent -> GetFgColor(color);
                }
        }
}


TTFont *Surface::GetTTFont()
{
        return m_pclTTFont ? m_pclTTFont : (m_pclParent ? m_pclParent -> GetTTFont() : NULL);
}


alpha_t Surface::GetAlpha()
{
        if (m_bAlphaIsSet)
        {
                return m_nAlpha;
        }
        if (m_pclParent)
        {
                return m_pclParent -> GetAlpha();
        }
        return 0;
}


coord_t Surface::GetFrameWidth()
{
        if (m_bFrameWidthIsSet)
        {
                return m_nFrameWidth;
        }
        if (m_pclParent)
        {
                return m_pclParent -> GetFrameWidth();
        }
        return 0;
}


color_t Surface::GetFrameColor()
{
        if (m_bFrameColorIsSet)
        {
                return SDL_MapRGBA(m_screen->format, m_frameColor.r, m_frameColor.g, m_frameColor.b, m_frameColor.unused);
        }
        if (m_pclParent)
        {
                return m_pclParent -> GetFrameColor();
        }
        return 0;
}


void Surface::GetFrameColor(SDL_Color &color)
{
        if (m_bFrameColorIsSet)
        {
                color = m_frameColor;
                return;
        }
        if (m_pclParent)
        {
                m_pclParent -> GetFrameColor(color);
        }
}


SDL_Rect *Surface::GetClientRectPtr()
{
        return &m_clientRect;
}


SDL_Rect Surface::GetClientRect()
{
        return m_clientRect;
}


SDL_Rect *Surface::GetAbsoluteRectPtr()
{
        return &m_absoluteRect;
}


SDL_Rect Surface::GetAbsoluteRect()
{
        return m_absoluteRect;
}


SDLControl *Surface::GetSDLControl()
{
        return m_pclControl ? m_pclControl : (m_pclParent ? m_pclParent -> GetSDLControl() : NULL);
}


void Surface::SetLocalID(unsigned long l)
{
        m_local_id = l;
}


unsigned long Surface::GetID()
{
        return m_id;
}


unsigned long Surface::GetLocalID()
{
        return m_local_id;
}


/*
void Surface::SetName(const string &str)
{
        m_strName = str;
}


const char *Surface::GetName()
{
        return m_strName.c_str();
}
*/


coord_t Surface::GetX()
{
        return m_x;
}


coord_t Surface::GetY()
{
        return m_y;
}


bool Surface::IsVisible()
{
        return m_bVisible;
}


coord_t Surface::GetW()
{
        return m_w;
}


coord_t Surface::GetH()
{
        return m_h;
}


coord_t Surface::GetAbsoluteX()
{
        return m_x_absolute;
}


coord_t Surface::GetAbsoluteY()
{
        return m_y_absolute;
}


void Surface::SetInverted(bool b)
{
        m_bInverted = b;
}


bool Surface::IsInverted()
{
        return m_bInverted;
}


void Surface::SetTransparent(bool b)
{
        m_bTransparent = b;
}


bool Surface::IsTransparent()
{
        return m_bTransparent;
}


/*
void Surface::SetStyle(style_t b)
{
        m_style = b;
}


style_t Surface::GetStyle()
{
        return m_style;
}
*/


void Surface::SetMoveable(bool b)
{
        m_bMoveable = b;
}


bool Surface::IsMoveable()
{
        return m_bMoveable;
}


void Surface::SetDirty(bool b,bool bInvalidate)
{
        if (b && !m_bDirty && bInvalidate)
        {
                m_bDirty = b;
                InvalidateEv();
        }
        else
        {
                m_bDirty = b;
        }
}


bool Surface::IsDirty()
{
        return m_bDirty;
}


void Surface::CreateTemporaryScreen()
{
        m_temp_screen = CreateSDLSurface(false);
        SetUseTemporaryScreen(true);
        SDL_SetAlpha(m_temp_screen, SDL_SRCALPHA|SDL_RLEACCEL, 192); //SDL_ALPHA_OPAQUE);
}


void Surface::DrawTemporaryScreen()
{
        if (UseTemporaryScreen() && m_temp_screen)
        {
                SetUseTemporaryScreen(false);
                m_bRedrawTemporary = true;
                Blit(-GetX(),-GetY(),m_temp_screen);
                SetUseTemporaryScreen(true);
                m_bRedrawTemporary = false;
        }
}


void Surface::SetUseTemporaryScreen(bool b)
{
        m_bUseTemporaryScreen = b;
}


bool Surface::UseTemporaryScreen()
{
        return m_bUseTemporaryScreen;
}


SDL_Surface *Surface::GetTemporaryScreen()
{
        return m_temp_screen;
}


void Surface::SetText(const string &str)
{
        m_text = str;
        SetDirty(true);
}


const char *Surface::GetText()
{
        return m_text.c_str();
}


void Surface::SetResizeArea(bool b)
{
        m_bResizeArea = b;
}


bool Surface::IsResizeArea()
{
        return m_bResizeArea;
}


void Surface::SetAnchorRight(bool b)
{
        m_bAnchorRight = b;
}


bool Surface::IsAnchorRight()
{
        return m_bAnchorRight;
}


void Surface::SetAnchorDown(bool b)
{
        m_bAnchorDown = b;
}


bool Surface::IsAnchorDown()
{
        return m_bAnchorDown;
}


void Surface::SetMustBeDeleted(bool b)
{
        m_bMustBeDeleted = b;
}


bool Surface::MustBeDeleted()
{
        return m_bMustBeDeleted;
}


void Surface::SetClickable(bool b)
{
        m_bClickable = b;
}


bool Surface::IsClickable()
{
        return m_bClickable;
}


void Surface::Bond(Surface *s)
{
        surfacevector_t::iterator it;
        
        for (it = m_bonds.begin(); it != m_bonds.end(); it++)
        {
                if (*it == s)
                {
                        return;
                }
        }
        m_bonds.insert(m_bonds.end(), s);
        s -> SetBond(this);
}


void Surface::Unbond(Surface *s)
{
        surfacevector_t::iterator it;
        
        for (it = m_bonds.begin(); it != m_bonds.end(); it++)
        {
                if (*it == s)
                {
                        m_bonds.erase(it);
                        s -> SetBond(NULL);
                        return;
                }
        }
}


void Surface::SetBond(Surface *s)
{
        m_pclBond = s;
}


Surface *Surface::GetBond()
{
        return m_pclBond;
}


void Surface::RemoveAllBonds()
{
        SetBond(NULL);
        while (m_bonds.size() > 0)
        {
                surfacevector_t::iterator it = m_bonds.begin();
                (*it) -> RemoveAllBonds();
                m_bonds.erase(it);
        }
}


void Surface::CloseAll()
{
        surfacevector_t::iterator it;
        
        OnClose();
        for (it = m_bonds.begin(); it != m_bonds.end(); it++)
        {
                (*it) -> CloseAll();
        }
}


void Surface::GetExtents(SDL_Rect &r)
{
        SDL_Rect a = GetAbsoluteRect();
        coord_t right = a.x + a.w;
        coord_t bottom = a.y + a.h;

        r.x = a.x < r.x ? a.x : r.x;
        r.y = a.y < r.y ? a.y : r.y;
        r.w = right > r.w ? right : r.w;
        r.h = bottom> r.h ? bottom: r.w;

        for (surfacevector_t::iterator it = m_bonds.begin(); it != m_bonds.end(); it++)
        {
                (*it) -> GetExtents(r);
        }
}


void Surface::SetUICommand(long id)
{
        m_uicommand = id;
}


long Surface::GetUICommand()
{
        return m_uicommand;
}


void Surface::Dump(FILE *fil)
{
        string tag;
        if (dynamic_cast<Button *>(this))
        {
                tag = "Button";
        }
        else
        if (dynamic_cast<Dialog *>(this))
        {
                tag = "Dialog";
        }
        else
        if (dynamic_cast<Edit *>(this))
        {
                tag = "Edit";
        }
        else
        if (dynamic_cast<Hotspot *>(this))
        {
                tag = "Hotspot";
        }
        else
        if (dynamic_cast<Menu *>(this))
        {
                tag = "Menu";
        }
        else
        if (dynamic_cast<MenuItem *>(this))
        {
                tag = "MenuItem";
        }
        else
        if (dynamic_cast<Output *>(this))
        {
                tag = "Output";
        }
        else
        if (dynamic_cast<PopupMenuItem *>(this))
        {
                tag = "PopupMenuItem";
        }
        else
        if (dynamic_cast<Progress *>(this))
        {
                tag = "Progress";
        }
        else
        if (dynamic_cast<SeparatorMenuItem *>(this))
        {
                tag = "SeparatorMenuItem";
        }
        else
        if (dynamic_cast<Static *>(this))
        {
                tag = "Static";
        }
        else
        {
                tag = "no_cast";
        }
        
        fprintf(fil,"<%s>\n",tag.c_str());
        DumpMembers(fil);
        for (surfacevector_t::iterator it = m_ChildList.begin(); it != m_ChildList.end(); it++)
        {
                (*it) -> Dump(fil);
        }
        fprintf(fil,"</%s>\n",tag.c_str());
}


/*
        coord_t  m_x;                           ok
        coord_t  m_y;                           ok
        coord_t  m_w;                           ok
        coord_t  m_h;                           ok
        coord_t  m_x_absolute;                  -
        coord_t  m_y_absolute;                  -
        SDL_Color m_bgColor;                    ok
        bool     m_bBgColorIsSet;               ok
        SDL_Color m_fgColor;                    ok
        bool     m_bFgColorIsSet;               ok
        SDL_Color m_frameColor;                 ok
        bool     m_bFrameColorIsSet;            ok
        TTFont * m_pclTTFont;                   ?
        alpha_t  m_nAlpha;                      ok
        bool     m_bAlphaIsSet;                 ok
        coord_t  m_nFrameWidth;                 ok
        bool     m_bFrameWidthIsSet;            ok
        SDL_Rect m_clientRect;                  -
        string   m_strName;                     ? rensas?
        SDL_Rect m_absoluteRect;                -
        style_t  m_style;                       ? rensas?
        // flags
        bool     m_bVisible;                    ok
        bool     m_bChildrenVisible;            ok
        bool     m_bInverted;                   -
        bool     m_bTransparent;                ok
        bool     m_bMoveable;                   ok
        bool     m_bDirty;                      -
        bool     m_bResizeArea;                 ok
        bool     m_bAnchorRight;                ok
        bool     m_bAnchorDown;                 ok
        bool     m_bMustBeDeleted;              -
        bool     m_bClickable;                  ok
        // end of flags
        bool     m_bUseTemporaryScreen;         ok
        string   m_text;                        ok
        bool     m_bRedrawTemporary;            -
        surfacevector_t m_bonds;                -
        Surface *m_pclBond;                     -
        long     m_uicommand;                   ok
*/
void Surface::DumpMembers(FILE *fil)
{
        Xml xml(fil);

        xml.Write("TEXT",m_text);
        if (m_uicommand != UICOMMAND_NONE)
        {
                xml.Write("UICOMMAND",m_uicommand);
        }
        xml.Write("X", (long)m_x);
        xml.Write("Y", (long)m_y);
        xml.Write("WIDTH", (long)m_w);
        xml.Write("HEIGHT", (long)m_h);
        xml.Write("BGCOLORISSET",m_bBgColorIsSet);
        if (m_bBgColorIsSet)
        {
                xml.Write("BGCOLOR",m_bgColor);
        }
        xml.Write("FGCOLORISSET",m_bFgColorIsSet);
        if (m_bFgColorIsSet)
        {
                xml.Write("FGCOLOR",m_fgColor);
        }
        xml.Write("FRAMECOLORISSET",m_bFrameColorIsSet);
        if (m_bFrameColorIsSet)
        {
                xml.Write("FRAMECOLOR",m_frameColor);
        }
        xml.Write("ALPHAISSET",m_bAlphaIsSet);
        if (m_bAlphaIsSet)
        {
                xml.Write("ALPHA", (long)m_nAlpha);
        }
        xml.Write("FRAMEWIDTHISSET",m_bFrameWidthIsSet);
        if (m_bFrameWidthIsSet)
        {
                xml.Write("FRAMEWIDTH", (long)m_nFrameWidth);
        }
        xml.Write("VISIBLE",m_bVisible);
        xml.Write("CHILDRENVISIBLE",m_bChildrenVisible);
        xml.Write("TRANSPARENT",m_bTransparent);
        xml.Write("MOVEABLE",m_bMoveable);
        xml.Write("RESIZEAREA",m_bResizeArea);
        xml.Write("ANCHORRIGHT",m_bAnchorRight);
        xml.Write("ANCHORDOWN",m_bAnchorDown);
        xml.Write("CLICKABLE",m_bClickable);
        xml.Write("USETEMPORARYSCREEN",m_bUseTemporaryScreen);
}


void Surface::SaveDialogs()
{
        if (dynamic_cast<Dialog *>(this))
        {
                FILE *fil;
                char fn[200];

                sprintf(fn,"%s.xml",GetText());
                if (strlen(fn) > 4)
                {
                        if ((fil = fopen(fn,"wt")) != NULL)
                        {
                                fprintf(fil,"<?xml version=\"1.0\"?>\n");
                                Dump(fil);
                                fclose(fil);
                        }
                }
        }
        for (surfacevector_t::iterator it = m_ChildList.begin(); it != m_ChildList.end(); it++)
        {
                (*it) -> SaveDialogs();
        }
}


} // namespace

---

www.TV-friendship.com The matchmaking service with an all new twist.

Quantum 'Teleportation' Some thoughts

Page, code, and content Copyright (C) 2004 by Anders Hedström