pgwidget.h

Go to the documentation of this file.

/*
    ParaGUI - crossplatform widgetset
    Copyright (C) 2000,2001,2002  Alexander Pipelka
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 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
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
    Alexander Pipelka
    pipelka@teleweb.at
 
    Last Update:      $Author: mbickel $
    Update Date:      $Date: 2007-04-13 16:15:57 $
    Source File:      $Source: /home/cvspsrv/cvsroot/games/asc/source/libs/paragui/include/pgwidget.h,v $
    CVS/RCS Revision: $Revision: 1.2 $
    Status:           $State: Exp $
*/

#ifndef PG_WIDGET_H
#define PG_WIDGET_H

#include "pgmessageobject.h"
#include "pgrectlist.h"
#include "pgfont.h"
#include "pgstring.h"

#include MAP_INC

class PG_Widget;
class PG_WidgetDataInternal;

class DECLSPEC PG_Widget : public PG_MessageObject, public PG_Rect  {
public:


        typedef enum {
            ACT_ACTIVATE,       
            ACT_DEACTIVATE,     
            ACT_OK,     
            ACT_CANCEL, 
            ACT_LEFT,   
            ACT_RIGHT,  
            ACT_UP,     
            ACT_DOWN    
        } KeyAction;

        //PG_Widget(PG_Widget* parent, const PG_Rect& rect);

        PG_Widget(PG_Widget* parent, const PG_Rect& rect = PG_Rect::null, bool bObjectSurface = false);

        virtual ~PG_Widget();

        void LoadThemeStyle(const std::string& widgettype);

        virtual void LoadThemeStyle(const std::string& widgettype, const std::string& objectname);

        void StartWidgetDrag();

        void WidgetDrag(int x, int y);

        void EndWidgetDrag(int x, int y);

        bool MoveWidget(int x, int y, bool update = true);

        bool MoveWidget(const PG_Rect& r, bool update = true);

        virtual bool SizeWidget(Uint16 w, Uint16 h, bool update = true);

        PG_Point ClientToScreen(int x, int y);

        PG_Point ScreenToClient(int x, int y);

        SDL_Surface* GetWidgetSurface();

        bool IsVisible();

        PG_Widget* GetParent();

        virtual void AddChild(PG_Widget* child);

        virtual bool ProcessEvent(const SDL_Event* event, bool bModal = false);

        void SetID(int id);

        int GetID();

        PG_Widget* FindChild(int id, bool recursive = false );

        PG_Widget* FindChild(const std::string& name, bool recursive = false);

        bool IsMouseInside();

        bool Redraw(bool update = true);

        virtual void Blit(bool recursive = true, bool restore = true);

        void Update(bool doBlit = true);

        static void UpdateRect(const PG_Rect& r);

        static void UpdateScreen();

        virtual void Show(bool fade = false);

        virtual void Hide(bool fade = false);

        bool IsInFrontOf(PG_Widget*);

        void SendToBack();

        void BringToFront();

        PG_Widget* GetToplevelWidget();

        static void HideAll();

        void RecalcClipRect();

        virtual bool RestoreBackground(PG_Rect* clip = NULL, bool force = false);

        static PG_Widget* FindWidgetFromPos(int x, int y);

        void SetVisible(bool visible);

        void SetFadeSteps(int steps);

        void SetChildTransparency(Uint8 t);

        PG_RectList* GetChildList();

        int GetChildCount();

        void MoveRect(int x, int y);

        static void BulkBlit();

        // Navigation

        virtual bool Action(KeyAction action);

        static PG_RectList* GetWidgetList();

        void SetName(const std::string& name);

        const std::string& GetName();

        bool LoadLayout(const std::string& name);

        bool LoadLayout(const std::string& name, void (* WorkCallback)(int now, int max));

        bool LoadLayout(const std::string& name, void (* WorkCallback)(int now, int max), void *UserSpace);

        void RemoveAllChilds();

        void SetUserData(void *userdata, int size);

        virtual int GetUserDataSize();

        virtual void GetUserData(void *userdata);

        void ReleaseUserData();

        bool virtual RemoveChild(PG_Widget* child);

        virtual void SetText(const std::string& text);

        void AddText(const std::string& text, bool update = false);

        virtual void SetTextFormat(const char* text, ...);

        virtual const PG_String& GetText();

        void GetTextSize(Uint16& w, Uint16& h, const std::string& text = PG_NULLSTR);

        static void GetTextSize(Uint16& w, Uint16& h, const PG_String& text, PG_Font* font);

        int GetTextWidth();

        int GetTextHeight();

        int GetFontAscender();

        int GetFontHeight();

        PG_Color GetFontColor();

   PG_Color GetFontHighlightColor();
   
        void SetFontColor(const PG_Color& Color, bool bRecursive = false);

   void SetFontHighlightColor(const PG_Color& Color, bool bRecursive = false);
   
        void SetFontAlpha(int Alpha, bool bRecursive = false);

        void SetFontStyle(PG_Font::Style Style, bool bRecursive = false);

        void SetFontSize(int Size, bool bRecursive = false);

        void SetFontIndex(int Index, bool bRecursive = false);

        void SetFontName(const std::string& Name, bool bRecursive = false);

        void SetSizeByText(int Width = 0, int Height = 0, const std::string& Text = PG_NULLSTR);

        int GetFontSize();

        PG_Font* GetFont();

        void SetFont(PG_Font* font);

        void DrawText(const PG_Rect& rect, const PG_String& text);

        void DrawText(int x, int y, const PG_String& text);

        void DrawText(int x, int y, const PG_String& text, const PG_Rect& cliprect);

        void DrawText(const PG_Rect& rect, const PG_String& text, const PG_Color& c);

        void DrawText(int x, int y, const PG_String& text, const PG_Color& c);

        void DrawBorder(const PG_Rect& r, int size, bool up = true);

        virtual void SetTransparency(Uint8 t, bool bRecursive = false);

        Uint8 GetTransparency();

        void SetClipRect( const PG_Rect& r);

        PG_Rect* GetClipRect();

        bool IsClippingEnabled();

        void GetClipRects(PG_Rect& src, PG_Rect& dst);

        void GetClipRects(PG_Rect& src, PG_Rect& dst, const PG_Rect& displayrect);

        void SetPixel(int x, int y, const PG_Color& c);

        void DrawHLine(int x, int y, int w, const PG_Color& c);

        void DrawVLine(int x, int y, int h, const PG_Color& c);

        void DrawRectWH(int x, int y, int w, int h, const PG_Color& c);

        void DrawLine(Uint32 x0, Uint32 y0, Uint32 x1, Uint32 y1, const PG_Color& color, Uint8 width=1);

        virtual int RunModal();

        bool QuitModal();

        bool WillQuitModal();

        void StopQuitModal();

        void SetDirtyUpdate(bool bDirtyUpdate);

        void UpdateOverlappingSiblings( bool enable, bool recursive = true );

        bool GetDirtyUpdate();

        virtual void eventMouseLeave();

        virtual void eventMouseEnter();

        void SetHidden(bool hidden);

        bool IsHidden();

        void SetModalStatus(int status);

        void EnableReceiver(bool enable, bool bRecursive = false);

        template<class datatype = PG_Pointer>
class SignalMouseEnter : public PG_Signal0<datatype> {}
        ;

        template<class datatype = PG_Pointer>
class SignalMouseLeave : public PG_Signal0<datatype> {}
        ;

        SignalMouseEnter<> sigMouseEnter;

        SignalMouseLeave<> sigMouseLeave;

        void SetParent(PG_Widget* parent);

        void SetBorderSize(int b);

        int GetBorderSize();

   void activateHotkey( int keymodifier );
   int getHotkeyModifier();
   
protected:

        //bool eventMessage(MSG_MESSAGE* msg);

        virtual void eventMoveWidget(int x, int y);

        virtual void eventSizeWidget(Uint16 w, Uint16 h);

        virtual void eventDraw(SDL_Surface* surface, const PG_Rect& rect);

        virtual void eventBlit(SDL_Surface* surface, const PG_Rect& src, const PG_Rect& dst);

        virtual void eventShow();

        virtual void eventHide();

        virtual bool eventQuitModal(int id, PG_MessageObject* widget, unsigned long data);

        void FadeOut();

        void FadeIn();

        bool AcceptEvent(const SDL_Event* event);

        void RemoveFromWidgetList();

        void AddToWidgetList();

        SDL_Surface* my_srfObject;

        PG_String my_text;

        PG_Color my_colorBorder[2][2];

        int my_bordersize;

   static bool RenderText(SDL_Surface *Surface, const PG_Rect& ClipRect, int BaseLineX, int BaseLineY, const PG_String& Text, PG_Font* ParamIn);

   PG_Char extractHotkey( const std::string& s );
   bool extractAndStoreHotkey( const std::string& s );
   bool checkForHotkey( const SDL_KeyboardEvent* key );

   
private:

        PG_Widget(const PG_Widget&);

        PG_Widget& operator=(const PG_Widget&);

        static int my_ObjectCounter;

        static PG_RectList widgetList;

        // this is a bit rude but neccessary for future binary compatibility
        // because adding non-static data members would break the ABI.
        // For this we put all private data into a dynamically created struct.
        PG_WidgetDataInternal* _mid;
};

#endif // PG_WIDGET_H

---