pgapplication.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: 2008-04-20 16:44:33 $
    Source File:      $Source: /home/cvspsrv/cvsroot/games/asc/source/libs/paragui/include/pgapplication.h,v $
    CVS/RCS Revision: $Revision: 1.3 $
    Status:           $State: Exp $
*/

#ifndef PG_APPLICATION_H
#define PG_APPLICATION_H

#include "pgmessageobject.h"
#include "pgfilearchive.h"
#include "pgfont.h"
#include "pgdraw.h"

class PG_EventSupplier;

class PG_Theme;
class PG_Widget;

class PG_XMLTag;

class DECLSPEC PG_Application : public PG_MessageObject, public PG_FileArchive, public PG_FontEngine  {
public:

        typedef enum {
            QUERY, 
            NONE,  
            HARDWARE, 
            SOFTWARE 
        } CursorMode;

        enum {
            IDAPPLICATION = PG_WIDGETID_INTERNAL + 100
        };

        template<class datatype = PG_Pointer>
class SignalXMLTag : public PG_Signal1<PG_XMLTag*, datatype> {}
        ;
        template<class datatype = PG_Pointer>
class SignalAppIdle : public PG_Signal1<PG_MessageObject*, datatype> {}
        ;

        PG_Application();

        ~PG_Application();

        bool InitScreen(int w, int h, int depth=0, Uint32 flags = SDL_SWSURFACE /* | SDL_FULLSCREEN*/ | SDL_HWPALETTE);

        PG_Theme* LoadTheme(const std::string& xmltheme, bool asDefault = true, const std::string& searchpath = PG_NULLSTR);

        void Run();

        virtual void RunEventLoop();

        void Quit();

        SDL_Surface* SetScreen(SDL_Surface* screen, bool initialize = true);

        static inline SDL_Surface* GetScreen() {
                return screen;
        }

        inline static bool LockScreen() {
           return SDL_mutexP(mutexScreen) == 0;
        }
        
        
        inline static bool UnlockScreen() {
           return (SDL_mutexV(mutexScreen) == 0);          
        }

        bool SetBackground(const std::string& filename, PG_Draw::BkMode mode=PG_Draw::TILE);

        bool SetBackground(SDL_Surface* surface, PG_Draw::BkMode mode=PG_Draw::TILE, bool freeBackground = false );

        static void RedrawBackground(const PG_Rect& rect);

        void SetEmergencyQuit(bool esc);

        static const std::string& GetRelativePath(const std::string& file);

        static int GetScreenHeight();

        static int GetScreenWidth();

        static void FlipPage();

        void PrintVideoTest();

        static PG_Theme* GetTheme();

        static bool GetBulkMode();

        static void SetBulkMode(bool bulk = true);

        //static bool GetGLMode();

        void EnableBackground(bool enable = true);

        void DeleteBackground();

        void EnableAppIdleCalls(bool enable = true);

        void SetIcon(const std::string& filename);

        void SetCaption(const std::string& title, const std::string& icon = PG_NULLSTR);

        void GetCaption(std::string& title, std::string& icon);

        int Iconify(void);

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

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

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

        static PG_Widget *GetWidgetByName(const std::string& Name);

        template<class T>
        static T* GetWidget(const std::string& Name) {
                return static_cast<T*>(GetWidgetByName(Name));
        }

        template<class T>
        static T* GetWidget(int id) {
                return static_cast<T*>(GetWidgetById(id));
        }

        static PG_Widget *GetWidgetById(int id);

        static void SetFontColor(const PG_Color& Color);

        static void SetFontAlpha(int Alpha);

        static void SetFontStyle(PG_Font::Style Style);

        static void SetFontSize(int Size);

        static void SetFontIndex(int Index);

        static void SetFontName(const std::string& Name);


        static void SetCursor(SDL_Surface *image);


        static void DrawCursor(bool update = true);


        static CursorMode ShowCursor(CursorMode mode);


        static void DisableDirtyUpdates(bool disable);


        static bool GetDirtyUpdatesDisabled();

        static PG_Application* GetApp();

        static PG_Font* DefaultFont;

        bool GetAppIdleCallsEnabled();

        /*
        This function savely discards all events in the eventqueue.
        All pending messages will be deleted and the memory freed.
        \note Your memory will leak if you just do a SDL_PollEvent
        because this won't delete pending usermessages.
        */
        static void FlushEventQueue();


        static void ClearOldMousePosition();

        static void TranslateNumpadKeys(SDL_KeyboardEvent *key);

        bool PumpIntoEventQueue(const SDL_Event* event);


        static void SetEventSupplier( PG_EventSupplier* eventSupplier );

        static  PG_EventSupplier* GetEventSupplier();

        static void SetUpdateOverlappingSiblings(bool update = true);

        static bool GetUpdateOverlappingSiblings();

   static void SetHighlightingTag( PG_Char c );
   
   static PG_Char GetHighlightingTag();

   static void UpdateRect(SDL_Surface *screen, Sint32 x, Sint32 y, Sint32 w, Sint32 h);
   static void UpdateRects(SDL_Surface *screen, int numrects, SDL_Rect *rects);
   
        SignalXMLTag<> sigXMLTag;
        SignalAppIdle<> sigAppIdle;


   class BulkModeActivator {
      bool active;
   public:
      BulkModeActivator() {
         active = PG_Application::GetBulkMode();
         if ( !active )
            PG_Application::SetBulkMode( true );
      };
      void disable() {
         if ( !active )
            PG_Application::SetBulkMode( false );
         active = true;
      }
      ~BulkModeActivator() {
         disable();
      };
   };

   class ScreenLocker {
      bool active;
   public:
      ScreenLocker() {
         active = false;
      };
      ScreenLocker( bool doLock) {
         active = false;
         if ( doLock )
            lock();
      };
      void lock() {
         if ( !active ) {
            LockScreen();
            active = true;
         }
      }
      void unlock() {
         if ( active ) {
            UnlockScreen();
            active = false;
         }
      }
      ~ScreenLocker() {
         unlock();
      };
   };
   


protected:

        void Shutdown();

        bool eventKeyUp(const SDL_KeyboardEvent* key);

        bool eventKeyDown(const SDL_KeyboardEvent* key);

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

        bool eventResize(const SDL_ResizeEvent* event);

        virtual void eventInit();

        virtual void eventIdle();

        bool my_quitEventLoop;



private:

        // disable the copy operators
        PG_Application(const PG_Application&);
        PG_Application& operator=(const PG_Application&);

        bool my_freeBackground;
        static SDL_Surface* my_background;
        static SDL_Surface* my_scaled_background;
        static PG_Color my_backcolor;
        static PG_Draw::BkMode my_backmode;

        static PG_Theme* my_Theme;

        //static std::string app_path;

        static PG_Application* pGlobalApp;
        static SDL_Surface* screen;

        static bool bulkMode;
        //static bool glMode;
        bool emergencyQuit;
        static bool enableBackground;
        bool enableAppIdleCalls;
        static PG_EventSupplier* my_eventSupplier;
        static PG_EventSupplier* my_defaultEventSupplier;

        static SDL_Surface* my_mouse_pointer;
        static SDL_Surface* my_mouse_backingstore;
        static PG_Rect my_mouse_position;
        static CursorMode my_mouse_mode;
        static SDL_mutex* mutexScreen;
        static bool disableDirtyUpdates;
        static bool defaultUpdateOverlappingSiblings;

   static PG_Char highlightingTag;
};

int PG_main(int argc, char **argv, PG_Application *app);

#endif // PG_APPLICATION_H

---