wg_window.h

// wg_window.h
//
// CWindow interface
// this serves as the base of all window derived classes
//
// Copyright (c) 2002-2004 Rob Wiskow
// rob-dev@boxedchaos.com
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//


#ifndef _WG_WINDOW_H_
#define _WG_WINDOW_H_

#include "wg_rect.h"
#include "wg_color.h"
#include "wg_message_client.h"
#include <string>
#include <list>
#include <typeinfo>
#include "SDL.h"


namespace wGui
{

// forward declaration of the view class
class CView;




class CWindow : public CMessageClient
{
public:
     CWindow(const CRect& WindowRect, CWindow* pParent);

     virtual ~CWindow(void);

     virtual std::string GetClassName(void) const { return typeid(*this).name(); }

     virtual void SetWindowRect(const CRect& WindowRect);

     virtual CRect GetWindowRect(void) const { return m_WindowRect; }

     virtual void MoveWindow(const CPoint& MoveDistance);

     virtual CRect GetClientRect(void) const { return m_ClientRect; }

     virtual void SetBackgroundColor(const CRGBColor& Color) { m_BackgroundColor = Color; }

     virtual CRGBColor GetBackgroundColor(void) { return m_BackgroundColor; }

     enum EAncestor {
          PARENT, 
          ROOT 
     };
     virtual CWindow* GetAncestor(EAncestor eAncestor) const;

     virtual std::list<CWindow*> GetChildWindows(void) const { return m_ChildWindows; }

     virtual CView* GetView(void) const;

     virtual bool IsChildOf(CWindow* pWindow) const;

     virtual bool IsVisible(void) { return m_bVisible; }

     virtual void SetVisible(bool bVisible);

     virtual SDL_Surface* GetSDLSurface(void) { return m_pSDLSurface; }

     virtual CRect ClientToView(const CRect& Rect) const;

     virtual CPoint ClientToView(const CPoint& Point) const;

     virtual CRect ViewToClient(const CRect& Rect) const;

     virtual CPoint ViewToClient(const CPoint& Point) const;

     virtual CRect ViewToWindow(const CRect& Rect) const;

     virtual CPoint ViewToWindow(const CPoint& Point) const;

     virtual void SetWindowText(const std::wstring& sText);

     virtual std::wstring GetWindowText(void) { return m_sWindowText; }

     virtual bool HitTest(const CPoint& Point) const;

     virtual void Draw(void) const;

     virtual void PaintToSurface(SDL_Surface& ScreenSurface, SDL_Surface& FloatingSurface, const CPoint& Offset) const;

     virtual void SetNewParent(CWindow* pNewParent);

     virtual bool OnMouseButtonDown(CPoint Point, unsigned int Button);

     virtual bool OnMouseButtonUp(CPoint Point, unsigned int Button);


     // CMessageClient overrides
     virtual bool HandleMessage(CMessage* pMessage);


protected:
     // Registering and Deregistering child windows is automatically handled by the constructors and destructors

     virtual void RegisterChildWindow(CWindow* pWindow);

     virtual void DeregisterChildWindow(CWindow* pWindow);


     std::wstring m_sWindowText;

     CRect m_WindowRect;

     CRGBColor m_BackgroundColor;

     CRect m_ClientRect;

     CWindow* m_pParentWindow;

     std::list<CWindow*> m_ChildWindows;

     SDL_Surface* m_pSDLSurface;

     bool m_bVisible;

private:
     void operator=(CWindow) { }  
};

}


#include "unit_tests/wg_window_unittests.h"

#endif // _WG_WINDOW_H_

---