Web alhem.net

GuiEvent.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"
#include "guicolors.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 "Surface.h"
#include "SDLControl.h"
#include "Static.h"
#include "Button.h"
#include "Edit.h"
#include "Hotspot.h"
#include "Dialog.h"
#include "MenuItem.h"
#include "Menu.h"
#include "HotButton.h"
#include "GuiEvent.h"


namespace gui
{
Surface *GuiEvent::m_mouse = NULL;
Surface *GuiEvent::m_selected = NULL;
Surface *GuiEvent::m_focus = NULL;
Surface *GuiEvent::m_moving = NULL;
Surface *GuiEvent::m_sizing = NULL;
Surface *GuiEvent::m_trackbutton = NULL;
Surface *GuiEvent::m_default_focus = NULL;
//coord_t GuiEvent::m_x = 0;
//coord_t GuiEvent::m_y = 0;


GuiEvent::GuiEvent()
:m_pclRootSurface(NULL)
,m_pclControl(NULL)
,m_bLeftButtonPressed(false)
,m_bMiddleButtonPressed(false)
,m_bRightButtonPressed(false)
,m_bQuit(false)
,m_sizing_w(0)
,m_sizing_h(0)
{
}


GuiEvent::~GuiEvent()
{
}


void GuiEvent::SetRootSurface(Surface *s)
{
        m_pclRootSurface = s;
}


void GuiEvent::SetSDLControl(SDLControl *s)
{
        m_pclControl = s;
}


void GuiEvent::KeyboardEvent(SDL_KeyboardEvent &e)
{
        Surface *focus;

        if (m_focus)
        {
                if (dynamic_cast<Edit *>(m_focus))
                {
                        focus = m_focus;
                }
                else
                {
                        focus = m_default_focus;
                }
        }
        else
        {
                focus = m_default_focus;
        }
        if (focus)
        {
                switch (e.type)
                {
                case SDL_KEYDOWN:
                        focus -> OnKeyDown(e.keysym);
                        break;
                case SDL_KEYUP:
                        focus -> OnKeyUp(e.keysym);
                        break;
                }
        }
}


void GuiEvent::MouseMotionEvent(SDL_MouseMotionEvent &e)
{
        // we're moving a surface
        if (m_moving && m_moving != m_pclRootSurface)
        {
                Surface *head = m_moving;
                SDL_Rect rect;
                coord_t xmax = rect.x = m_pclControl->GetScreen()->w;
                coord_t ymax = rect.y = m_pclControl->GetScreen()->h;
                coord_t xrel = e.xrel;
                coord_t yrel = e.yrel;
                rect.w = 0;
                rect.h = 0;
                while (head -> GetBond())
                {
                        head = head -> GetBond();
                }
                head -> GetExtents(rect);
                if (rect.x + xrel < 0)
                {
                        xrel = -rect.x;
                }
                if (rect.w + xrel >= xmax)
                {
                        xrel = xmax - rect.w;
                }
                if (rect.y + yrel < 0)
                {
                        yrel = -rect.y;
                }
                if (rect.h + yrel >= ymax)
                {
                        yrel = ymax - rect.h;
                }
                head -> Move(m_pclRootSurface,xrel,yrel);
        }
        else

        // we're resizing a surface
        if (m_sizing && m_sizing != m_pclRootSurface)
        {
                coord_t ww = m_sizing_w + e.xrel;
                coord_t hh = m_sizing_h + e.yrel;

                // trace a temporary rectangle on screen
                // reallocate and draw surface when resize is done
                SDL_Rect r;
                coord_t x = m_sizing -> GetAbsoluteX();
                coord_t y = m_sizing -> GetAbsoluteY();
                coord_t w = m_sizing_w;
                coord_t h = m_sizing_h;

                if (m_sizing_w < 0)
                {
                        r.x = x + m_sizing_w;
                        r.w = -m_sizing_w;
                }
                else
                {
                        r.x = x;
                        r.w = m_sizing_w;
                }
                r.x -= 4;
                r.w += 8;
                if (m_sizing_h < 0)
                {
                        r.y = y + m_sizing_h;
                        r.h = -m_sizing_h;
                }
                else
                {
                        r.y = y;
                        r.h = m_sizing_h;
                }
                r.y -= 4;
                r.h += 8;
                m_pclRootSurface -> InvalidateRectEv(r);

                m_sizing_w = w = ww;
                m_sizing_h = h = hh;

                m_pclRootSurface -> ResetFillRectsEv();

                if (m_sizing_w < 0)
                {
                        x = x + m_sizing_w;
                        w = -m_sizing_w;
                }
                else
                {
                        w = m_sizing_w;
                }
                if (m_sizing_h < 0)
                {
                        y = y + m_sizing_h;
                        h = -m_sizing_h;
                }
                else
                {
                        h = m_sizing_h;
                }

                r.x = x;
                r.y = y;
                r.w = 4;
                r.h = h;
                m_pclRootSurface -> FillRectEv(r);
                r.w = w;
                r.h = 4;
                m_pclRootSurface -> FillRectEv(r);
                r.y = y + h - 4;
                m_pclRootSurface -> FillRectEv(r);
                r.x = x + w - 4;
                r.y = y;
                r.w = 4;
                r.h = h;
                m_pclRootSurface -> FillRectEv(r);
        }
        else
        
        // we're tracking a button
        if (m_trackbutton)
        {
                coord_t x = m_trackbutton -> GetAbsoluteX();
                coord_t y = m_trackbutton -> GetAbsoluteY();
                coord_t w = m_trackbutton -> GetW();
                coord_t h = m_trackbutton -> GetH();
                bool ch = false;
                if (m_trackbutton -> IsInverted()) // mouse is in
                {
                        if (e.x < x || e.x >= x + w || e.y < y || e.y >= y + h)
                        {
                                ch = true;
                        }
                }
                else
                {
                        if (e.x >= x && e.x < x + w && e.y >= y && e.y < y + h)
                        {
                                ch = true;
                        }
                }
                if (ch)
                {
                        m_trackbutton -> SetInverted( !m_trackbutton -> IsInverted() );
                        m_trackbutton -> GetParent() -> DrawTemporaryScreen();
                        m_trackbutton -> InvalidateEv();
                }
        }
        else
        {
                // find surface at new position
                Surface *pclSurface = m_pclRootSurface -> FindSurface(e.x,e.y);
                if (pclSurface != m_mouse)
                {
                        if (m_mouse)
                        {
                                m_mouse -> OnMouseOut();
                        }
                        pclSurface -> OnMouseIn();
                        m_mouse = pclSurface;
                }
                m_mouse -> OnMouseMove(e.x,e.y,e.xrel,e.yrel);
        }
}


void GuiEvent::MouseButtonEvent(SDL_MouseButtonEvent &e)
{
//      SDLMod mod = SDL_GetModState(); // & KMOD_LALT osv...

        if (e.type == SDL_MOUSEBUTTONDOWN &&
                e.button == SDL_BUTTON_LEFT &&
                m_mouse)
        {
                if (m_mouse != m_pclRootSurface)
                {
                        SetSelected(m_mouse);
                }
                else
                {
                        SetSelected(NULL);
                }
        }

        if (!m_moving && 
                !m_sizing && 
                e.type == SDL_MOUSEBUTTONDOWN && 
                e.button == SDL_BUTTON_LEFT &&
                dynamic_cast<Button *>(m_mouse) &&
                !dynamic_cast<HotButton *>(m_mouse))
        {
                m_trackbutton = m_mouse;
                m_trackbutton -> SetInverted(true);
                m_trackbutton -> GetParent() -> DrawTemporaryScreen();
                m_trackbutton -> InvalidateEv();
        }
        else
        if (e.type == SDL_MOUSEBUTTONUP && 
                e.button == SDL_BUTTON_LEFT && 
                m_trackbutton)
        {
                if (m_trackbutton -> IsInverted()) // hit
                {
                        m_trackbutton -> SetInverted(false);
                        m_trackbutton -> GetParent() -> DrawTemporaryScreen();
                        m_trackbutton -> InvalidateEv();
                        m_trackbutton -> OnButton();
                }
                m_trackbutton = NULL;
        }
        else
        {
                if (e.button == SDL_BUTTON_LEFT)
                {
                        if (e.type == SDL_MOUSEBUTTONDOWN)
                        {
                                // MenuItem OnClick
                                if (m_mouse && 
//                                      dynamic_cast<MenuItem *>(m_mouse) &&
                                        m_mouse -> IsClickable())
                                {
                                        m_mouse -> OnClick(e.x,e.y);
//                                      m_mouse -> GetParent() -> OnClose();
                                }
                                else
                                // Things that can get focus
                                if (m_mouse && (
                                        dynamic_cast<Edit *>(m_mouse) ||
                                        dynamic_cast<Button *>(m_mouse)
                                        ))
                                {
                                        SetFocus( m_mouse );
                                }
                                else
                                // Resize Dialog
                                if (m_mouse &&
                                        dynamic_cast<Hotspot *>(m_mouse) &&
                                        m_mouse -> IsResizeArea() &&
                                        m_mouse -> GetParent() &&
                                        dynamic_cast<Dialog *>(m_mouse -> GetParent())
                                        )
                                {
                                        m_sizing = m_mouse -> GetParent();
                                        m_sizing_w = m_sizing -> GetW();
                                        m_sizing_h = m_sizing -> GetH();
                                }
                                else
                                {
                                        // Check Moveable
                                        if (m_mouse && m_mouse -> IsMoveable())
                                        {
                                                m_moving = m_mouse;
                                        }
                                        else
                                        if (m_mouse && !m_mouse -> IsMoveable())
                                        {
                                                Surface *pclParent = m_mouse -> GetParent();
                                                while (pclParent)
                                                {
                                                        if (pclParent -> IsMoveable())
                                                        {
                                                                m_moving = pclParent;
                                                                break;
                                                        }
                                                        pclParent = pclParent -> GetParent();
                                                }
                                        }
                                        // Bring Dialog/Menu to top
                                        if (m_mouse && (
                                                dynamic_cast<Dialog *>(m_mouse) ||
                                                dynamic_cast<Menu *>(m_mouse)
                                                ))
                                        {
                                                m_mouse -> BringToTop();
                                                m_mouse -> InvalidateEv();
                                        }
                                        else
                                        if (m_mouse && !dynamic_cast<Dialog *>(m_mouse))
                                        {
                                                Surface *pclParent = m_mouse -> GetParent();
                                                while (pclParent)
                                                {
                                                        if (dynamic_cast<Dialog *>(pclParent))
                                                        {
                                                                pclParent -> BringToTop();
                                                                pclParent -> InvalidateEv();
                                                                break;
                                                        }
                                                        pclParent = pclParent -> GetParent();
                                                }
                                        }
                                } // m_sizing
                        }
                        if (e.type == SDL_MOUSEBUTTONUP)
                        {
                                if (m_moving)
                                {
                                        m_moving = NULL;
                                }
                                if (m_sizing)
                                {
                                        SDL_Rect a = m_sizing -> GetAbsoluteRect();
                                        m_pclRootSurface -> ResetFillRectsEv();
                                        m_pclRootSurface -> InvalidateRectEv(a);
                                        if (m_sizing_w < 0)
                                        {
                                                m_sizing -> SetX(m_sizing -> GetX() + m_sizing_w);
                                                m_sizing -> SetW(-m_sizing_w, false);
                                        }
                                        else
                                        {
                                                m_sizing -> SetW(m_sizing_w, false);
                                        }
                                        if (m_sizing_h < 0)
                                        {
                                                m_sizing -> SetY(m_sizing -> GetY() + m_sizing_h);
                                                m_sizing -> SetH(-m_sizing_h, false);
                                        }
                                        else
                                        {
                                                m_sizing -> SetH(m_sizing_h, false);
                                        }
                                        m_sizing -> RecreateSurfaces();
                                        m_sizing -> SetDirty(true);
                                        m_sizing = NULL;
                                }
                        }
                }
                if (e.button == SDL_BUTTON_RIGHT)
                {
                        if (e.type == SDL_MOUSEBUTTONDOWN)
                        {
                                if (m_mouse)
                                {
                                        m_mouse -> OnRightClick(e.x,e.y);
                                }
                        }
                }
        } // not a button hit

        switch (e.type)
        {
        case SDL_MOUSEBUTTONDOWN:
                switch (e.button)
                {
                case SDL_BUTTON_LEFT:
                        m_bLeftButtonPressed = true;
                        m_leftx = e.x;
                        m_lefty = e.y;
                        break;
                case SDL_BUTTON_MIDDLE:
                        m_bMiddleButtonPressed = true;
                        m_middlex = e.x;
                        m_middley = e.y;
                        break;
                case SDL_BUTTON_RIGHT:
                        m_bRightButtonPressed = true;
                        m_rightx = e.x;
                        m_righty = e.y;
                        break;
                }
                break;
        case SDL_MOUSEBUTTONUP:
                switch (e.button)
                {
                case SDL_BUTTON_LEFT:
                        m_bLeftButtonPressed = false;
                        break;
                case SDL_BUTTON_MIDDLE:
                        m_bMiddleButtonPressed = false;
                        break;
                case SDL_BUTTON_RIGHT:
                        m_bRightButtonPressed = false;
                        break;
                }
                break;
        }
}


bool GuiEvent::RightMouseButtonDown()
{
        return m_bRightButtonPressed;
}


void GuiEvent::UserEvent(SDL_UserEvent &event)
{
        switch (event.code)
        {
        case SDL_USEREVENT_PAINT:
                // copy surfaces to screen
                m_pclControl -> lockSurface();
                m_pclRootSurface -> Blit();
                m_pclControl -> unlockSurface();
                SDL_UpdateRect(m_pclControl -> GetScreen(), 0, 0, 0, 0);
                break;
        case SDL_USEREVENT_INVALIDATE:
                {
//DEB(printf("Invalidate event\n");)
                        Surface *pcs = reinterpret_cast<Surface *>(event.data1);
//                      long ticks;
//                      memmove(&ticks,&event.data2,4);
//                      DEB(printf(" * event ticks diff %ld\n",SDL_GetTicks() - ticks);)
//                      pcs -> Invalidate();
                        m_vecInvalidRects.insert(m_vecInvalidRects.end(), pcs -> GetAbsoluteRect());
                }
                break;
        case SDL_USEREVENT_INVALIDATERECT:
                {
                        SDL_Rect r;
                        long xy;
                        long wh;
                        memmove(&xy, &event.data1, 4);
                        memmove(&wh, &event.data2, 4);
                        r.x = xy / 0x10000;
                        r.y = xy & 0xffff;
                        r.w = wh / 0x10000;
                        r.h = wh & 0xffff;
//DEB(printf("InvalidateRectEv(%d,%d,%d,%d)\n",r.x,r.y,r.w,r.h);
//fflush(stdout);)
//                      m_pclRootSurface -> InvalidateRect(r);
                        m_vecInvalidRects.insert(m_vecInvalidRects.end(), r);
//DEB(printf(" * insert ok\n");
//fflush(stdout);)
                }
                break;
        case SDL_USEREVENT_LOSTFOCUS:
                {
                        Surface *pcs = reinterpret_cast<Surface *>(event.data1);
                        if (pcs == m_focus && m_focus)
                        {
                                m_focus -> OnLostFocus();
                                m_focus = NULL;
                        }
                }
                break;
        case SDL_USEREVENT_FILLRECT:
                {
                        SDL_Rect r;
                        long xy;
                        long wh;
                        memmove(&xy, &event.data1, 4);
                        memmove(&wh, &event.data2, 4);
                        r.x = xy / 0x10000;
                        r.y = xy & 0xffff;
                        r.w = wh / 0x10000;
                        r.h = wh & 0xffff;
                        m_vecFillRects.insert(m_vecFillRects.end(), r);
                }
                break;
        case SDL_USEREVENT_RESETFILLRECTS:
                while (m_vecFillRects.size())
                {
                        rectvector_t::iterator it = m_vecFillRects.begin();
                        m_vecFillRects.erase(it);
                }
                break;
        case SDL_USEREVENT_UICOMMAND:
                {
                        Surface *s;
                        long id;
                        memmove(&s,&event.data1,4);
                        memmove(&id,&event.data2,4);
                        UICOMMAND func = m_uicmdmap[id];
                        if (func)
                        {
                                (*func)(s,id);
                        }
                }
                break;
        case SDL_USEREVENT_TIMER:
//              printf("SDL_USEREVENT_TIMER\n");
                {
                        Surface *s;
                        long id;
                        memmove(&s,&event.data1,4);
                        memmove(&id,&event.data2,4);
                        s -> OnTimer(id);
                }
                break;
        }
}


void GuiEvent::SetDefaultFocus(Surface *s)
{
        m_default_focus = s;
}


void GuiEvent::SetQuit(bool b)
{
        m_bQuit = b;
}


void GuiEvent::SetFocus(Surface *s)
{
        if (m_focus && s != m_focus)
        {
                m_focus -> OnLostFocus();
                m_focus = s;
                m_focus -> OnFocus();
        }
        else
        if (s != m_focus)
        {
                m_focus = s;
                m_focus -> OnFocus();
        }
}


void GuiEvent::SetSelected(Surface *s)
{
//      Uint32 x;
        
        if (s != m_selected)
        {
                if (m_selected)
                {
/*
                        x = m_selected -> GetBgColor();
                        m_selected -> SetBgColor(m_selected -> GetFgColor());
                        m_selected -> SetFgColor(x);
                        m_selected -> SetDirty(true);
*/
                }
                m_selected = s;
/*
                if (m_selected)
                {
                        x = m_selected -> GetBgColor();
                        m_selected -> SetBgColor(m_selected -> GetFgColor());
                        m_selected -> SetFgColor(x);
                        m_selected -> SetDirty(true);
                }
*/
        }
}


void GuiEvent::EventLoop()
{
        SDL_Event event;

        // make sure every surface is drawn before we start processing events
        m_pclRootSurface -> DrawAll();
        m_pclRootSurface -> CalculateAbsolute();

        while (!m_bQuit)
        {
                // Force leaving this loop after a user input event
                // to permit updating the screen?
                while (SDL_PollEvent(&event))
                {
                        switch (event.type)
                        {
                        case SDL_USEREVENT:
                                UserEvent(event.user);
                                break;
                        case SDL_MOUSEMOTION:
                                MouseMotionEvent(event.motion);
                                break;
                        case SDL_MOUSEBUTTONUP:
                                MouseButtonEvent(event.button);
                                break;
                        case SDL_MOUSEBUTTONDOWN:
                                MouseButtonEvent(event.button);
                                break;
                        case SDL_KEYUP:
                                KeyboardEvent(event.key);
                                break;
                        case SDL_KEYDOWN:
                                KeyboardEvent(event.key);
                                break;
                        case SDL_QUIT:
                                m_bQuit = true;
                                break;
                        }
                }
                if (!m_bQuit)
                {
//#warning "Screen update events above are cached until this point"
//#warning "when an 'optimized' redraw will be done - see pseudo below"
//                      UpdateScreen();
// UpdateScreen:
//  if (any areas invalidated)
//  {
//    RootSurface->DrawAll()  -- draws dirty surfaces
//    BlitOptimizedRects()    -- blits to screen
//    SDL_UpdateRects()       -- updates screen
//  }
                        if (m_vecInvalidRects.size() > 0)
                        {
                                SDL_Rect cheat;
//DEB(printf(" * Updating %d areas\n",m_vecInvalidRects.size());)
                                //
                                cheat.x = m_pclControl -> GetScreen() -> w; // l
                                cheat.y = m_pclControl -> GetScreen() -> h; // t
                                cheat.w = 0; // r
                                cheat.h = 0; // b
                                //
                                m_pclRootSurface -> DrawAll();
                                m_pclRootSurface -> CalculateAbsolute();
                                //
                                while (m_vecInvalidRects.size() > 0)
                                {
                                        rectvector_t::iterator it = m_vecInvalidRects.begin();
                                        SDL_Rect r = *it;
                                        r.w += r.x; // right
                                        r.h += r.y; // bottom
                                        cheat.x = r.x < cheat.x ? r.x : cheat.x;
                                        cheat.y = r.y < cheat.y ? r.y : cheat.y;
                                        cheat.w = r.w > cheat.w ? r.w : cheat.w;
                                        cheat.h = r.h > cheat.h ? r.h : cheat.h;
                                        m_vecInvalidRects.erase(it);
                                }
                                //
                                for (rectvector_t::iterator it = m_vecFillRects.begin(); it != m_vecFillRects.end(); it++)
                                {
                                        SDL_Rect r = *it;
                                        r.w += r.x;
                                        r.h += r.y;
                                        cheat.x = r.x < cheat.x ? r.x : cheat.x;
                                        cheat.y = r.y < cheat.y ? r.y : cheat.y;
                                        cheat.w = r.w > cheat.w ? r.w : cheat.w;
                                        cheat.h = r.h > cheat.h ? r.h : cheat.h;
                                }
                                if (cheat.w > m_pclControl -> GetScreen() -> w)
                                {
                                        cheat.w = m_pclControl -> GetScreen() -> w;
                                }
                                if (cheat.h > m_pclControl -> GetScreen() -> h)
                                {
                                        cheat.h = m_pclControl -> GetScreen() -> h;
                                }
                                cheat.w = cheat.w - cheat.x;
                                cheat.h = cheat.h - cheat.y;
                                //
                                m_pclControl -> lockSurface();
                                m_pclRootSurface -> BlitAbsolute(&cheat);
                                while (m_vecFillRects.size() > 0)
                                {
//DEB(printf(" * Drawing %d FillRects\n",m_vecFillRects.size());)
                                        rectvector_t::iterator it = m_vecFillRects.begin();
                                        SDL_Rect rf = *it;
                                        SDL_FillRect(m_pclControl -> GetScreen(), &rf, 
                                                SDL_MapRGB(m_pclControl -> GetScreen() -> format, 255, 255, 255));
                                        m_vecFillRects.erase(it);
                                }
                                m_pclControl -> unlockSurface();
                                SDL_UpdateRects(m_pclControl -> GetScreen(), 1, &cheat);
                        }
                }
                // we shouldn't delay after a user input event, that's ignoring the user right?
                // ...update events generated by a user event is caught immediately above,
                // so it's ok to delay always here...
                SDL_Delay(10);
        }
}


void GuiEvent::RegUICmdMethod(long id,UICOMMAND func)
{
        m_uicmdmap[id] = func;
}


} // 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