pawsmanager.h

Go to the documentation of this file.

/*
 * pawsmanager.h - Author: Andrew Craig
 *
 * Copyright (C) 2003 Atomic Blue (info@planeshift.it, http://www.atomicblue.org)
 *
 *
 * 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 (version 2 of the License)
 * 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.
 *
 *
 * pawsmanager.h: interface for the PawsManager class.
 *
 *----------------------------------------------------------------------------
 */

#ifndef PAWS_MANAGER_HEADER
#define PAWS_MANAGER_HEADER

#include <csutil/ref.h>
#include <csutil/parray.h>
#include <csutil/hash.h>
#include <csutil/csstring.h>
#include <csgeom/vector3.h>

#include <iutil/vfs.h>
#include <iutil/document.h>

#include "util/mathscript.h"
#include "util/log.h"

#include "pawsmouse.h"
#include "psmousebinds.h"
#include "pawsstyles.h"

struct iObjectRegistry;
struct iGraphics2D;
struct iGraphics3D;
struct iXWindow;
struct iEvent;
class psLocalization;

struct iSoundManager;

class pawsWidget;
class pawsWidgetFactory;

class pawsMainWidget;
class pawsTextureManager;
class pawsPrefManager;

struct iPAWSSubscriber;
struct PAWSData;
struct PAWSSubscription;

typedef csHash<PAWSSubscription*,csString> PAWSSubscriptionsHash;

#if defined(CS_PLATFORM_UNIX) && defined(INCLUDE_CLIPBOARD)

#define csevSelectionNotify(reg) (csEventNameRegistry::GetID((reg), "crystalspace.xwindow.clipboard.selection.notify"))

#endif

#define CONFIG_TOOLTIPS_FILE_NAME       "/planeshift/userdata/options/tooltips.xml"
#define CONFIG_TOOLTIPS_FILE_NAME_DEF   "/planeshift/data/options/tooltips_def.xml"

class PawsManager : public Singleton<PawsManager>
{
public:

    PawsManager(iObjectRegistry* objectReg, const char* skin, const char* skinBase = NULL);

    virtual ~PawsManager();

    void SetMainWidget(pawsMainWidget* widg);

    bool HandleEvent(iEvent &event);

    void Draw();

    void Draw3D();

    iGraphics2D* GetGraphics2D()
    {
        return graphics2D;
    }

    iGraphics3D* GetGraphics3D()
    {
        return graphics3D;
    }

    iObjectRegistry* GetObjectRegistry()
    {
        return objectReg;
    }

    iEventNameRegistry* GetEventNameRegistry()
    {
        return nameRegistry;
    }

    pawsTextureManager* GetTextureManager()
    {
        return textureManager;
    }

    void UseR2T(bool r2t)
    {
        render2texture = r2t;
    }

    bool UsingR2T() const
    {
        return render2texture;
    }

    bool LoadSkinDefinition(const char* zip);

    void RegisterWidgetFactory(pawsWidgetFactory* factory);

    bool LoadWidget(const char* widgetFile);

    pawsWidget* LoadWidgetFromString(const char* widgetDefinition);


    pawsWidget* LoadWidget(iDocumentNode* widgetNode);

    bool LoadChildWidgets(const char* widgetFile, csArray<pawsWidget*> &loadedWidgets);


    pawsWidget* CreateWidget(const char* factoryName);

    pawsWidget* CreateWidget(const char* factoryName, const pawsWidget* origin);

    void AddObjectView(pawsWidget* widget)
    {
        objectViews.Push(widget);
    }

    bool LoadObjectViews();

    void RemoveObjectView(pawsWidget* widget)
    {
        objectViews.Delete(widget);
    }

    pawsWidget* GetCurrentFocusedWidget()
    {
        return currentFocusedWidget;
    }

    bool GetFocusOverridesControls()
    {
        return focusOverridesControls;
    }

    pawsWidget* GetModalWidget()
    {
        return modalWidget;
    }

    void SetCurrentFocusedWidget(pawsWidget* widget);

    void SetModalWidget(pawsWidget* widget);

    void OnWidgetDeleted(pawsWidget* widget);

    void OnWidgetHidden(pawsWidget* widget);

    void MovingWidget(pawsWidget* moving);

    void ResizingWidget(pawsWidget* widget, int flags);

    pawsPrefManager* GetPrefs()
    {
        return prefs;
    }

    pawsMouse* GetMouse()
    {
        return mouse;
    }

    iPawsImage* GetResizeImage()
    {
        return resizeImg;
    }

    pawsWidget* FindWidget(const char* name, bool complain=true);

    bool RemoveWidget(const char* widgetName, bool complain);

    pawsMainWidget* GetMainWidget()
    {
        return mainWidget;
    }

    psLocalization* GetLocalization()
    {
        return localization;
    }

    csString Translate(const csString &orig);

    pawsWidget* GetDragDropWidget();

    void SetDragDropWidget(pawsWidget* dragDropWidget);

    float GetFontFactor()
    {
        return fontFactor;
    };

    void CreateWarningBox(const char* message, pawsWidget* notify = NULL, bool modal = true);

    void CreateYesNoBox(const char* message, pawsWidget* notify = NULL, bool modal = true, bool translate = true);

    bool ApplyStyle(const char* name, iDocumentNode* target);

    /*                          ToolTips Functions/Variables
    ------------------------------------------------------------------------*/
    int  TooltipsColors[3];      
    bool ToolTipEnable;          
    bool ToolTipEnableBgColor;   

    bool LoadTooltips(const char* fileName);
    csString getToolTipSkinPath();
    bool getToolTipEnable()
    {
        return ToolTipEnable;
    };
    void setToolTipEnable(bool state)
    {
        ToolTipEnable = state;
    };
    bool getToolTipEnableBgColor()
    {
        return ToolTipEnableBgColor;
    };
    void setToolTipEnableBgColor(bool state)
    {
        ToolTipEnableBgColor = state;
    };
    int getTooltipsColors(int element)
    {
        return TooltipsColors[element];
    };
    void setTooltipsColors(int element, int param)
    {
        TooltipsColors[element] = param;
    };

    /*                          Sound Functions
    ------------------------------------------------------------------------*/

    iSoundManager* GetSoundManager()
    {
        return soundManager;
    };

    /*                       Subcription Functions
    ------------------------------------------------------------------------*/

    void UnSubscribe(iPAWSSubscriber* listener);

    void Subscribe(const char* dataname,iPAWSSubscriber* listener);

    void Publish(const csString &dataname,PAWSData &data);

    void Publish(const csString &dataname,const char* datavalue);

    void Publish(const csString &dataname,bool  datavalue);

    void Publish(const csString &dataname,int   datavalue);

    void Publish(const csString &dataname,unsigned int   datavalue);

    void Publish(const csString &dataname,float datavalue);

    void Publish(const csString &dataname, const char* datavalue, int color);

    void Publish(const csString &dataname);

    csArray<iPAWSSubscriber*> ListSubscribers(const char* dataname);

    MathEnvironment &ExtraScriptVars()
    {
        return extraScriptVars;
    }

    csString &getVFSPathToSkin()
    {
        return vfsPathToSkin;
    }

#if defined(CS_PLATFORM_UNIX) && defined(INCLUDE_CLIPBOARD)

    void RequestClipboardContent();
#endif

protected:
    MathEnvironment extraScriptVars;

    psPoint MouseLocation(iEvent &ev);

    csString vfsPathToSkin;

    psLocalization* localization;

    pawsPrefManager* prefs;

    pawsWidget* currentFocusedWidget;

    bool focusOverridesControls;

    pawsWidget* mouseoverWidget;

    pawsWidget* lastfadeWidget;

    csTicks timeOver;

    int tipDelay;

    pawsWidget* movingWidget;

    pawsWidget* modalWidget;

    pawsWidget* resizingWidget;

    int resizingFlags;

    void RegisterFactories();

    bool HandleMouseMove(csMouseEventData &data);

    bool HandleMouseDown(csMouseEventData &data);


    bool HandleDoubleClick(csMouseEventData &data);

    bool HandleMouseUp(csMouseEventData &data);

    bool HandleKeyDown(iEvent &event);

#if defined(CS_PLATFORM_UNIX) && defined(INCLUDE_CLIPBOARD)

    bool HandleSelectionNotify(iEvent &event);
#endif

    iObjectRegistry* objectReg;

    csRef<iGraphics2D> graphics2D;

    csRef<iGraphics3D> graphics3D;

    csRef<iEventNameRegistry> nameRegistry;

    pawsMainWidget* mainWidget;

    csArray<pawsWidget*> objectViews;

    pawsTextureManager* textureManager;

    pawsMouse* mouse;

    csRef<iPawsImage> resizeImg;

    csPDelArray<pawsWidgetFactory> factories;

    csRef<iVFS> vfs;

    csRef<iDocumentSystem>  xml;

    bool hadKeyDown;

    csRef<iTextureHandle> guiTexture;

    bool render2texture;

    pawsWidget* dragDropWidget;

    float fontFactor;


    /*                      Sound Member Variables
    ------------------------------------------------------------------------*/

    csRef<iSoundManager> soundManager;  

    csPtr<iDocumentNode> ParseWidgetFile(const char* widgetFile);

    pawsStyles* styles;

    PAWSSubscriptionsHash subscriptions;


    /*                      Shortcuts for events
    ------------------------------------------------------------------------*/
    csEventID MouseMove;
    csEventID MouseDown;
    csEventID MouseDoubleClick;
    csEventID MouseUp;
    csEventID KeyboardDown;
    csEventID KeyboardUp;

    /*                      X Clipboard
    ------------------------------------------------------------------------*/
#if defined(CS_PLATFORM_UNIX) && defined(INCLUDE_CLIPBOARD)
    csRef<iXWindow> xwin;

    csEventID SelectionNotifyEvent;

#endif
};


enum PAWSDATATYPE
{
    PAWS_DATA_UNKNOWN,
    PAWS_DATA_STR,
    PAWS_DATA_BOOL,
    PAWS_DATA_INT,
    PAWS_DATA_UINT,
    PAWS_DATA_FLOAT,
    PAWS_DATA_INT_STR
};


struct PAWSData
{
    static csString temp_buffer;

    PAWSDATATYPE type;
    union
    {
        int intval;
        unsigned int uintval;
        float floatval;
        bool boolval;
    };
    csString str;  //csString cannot be inside union

    PAWSData()
    {
        type=PAWS_DATA_UNKNOWN;
    }
    PAWSData &operator=(PAWSData &other)
    {
        type = other.type;
        intval = other.intval;
        str = other.str;
        return *this;
    }

    bool IsData()
    {
        return type != PAWS_DATA_UNKNOWN;
    }

    const char* GetStr();
    float GetFloat();
    int GetInt();
    unsigned int GetUInt();
    bool GetBool();
};


struct iPAWSSubscriber
{
    virtual void OnUpdateData(const char* name,PAWSData &data) = 0;
    virtual void NewSubscription(const char* name) = 0;
    virtual ~iPAWSSubscriber() {};
};

struct PAWSSubscription
{
    PAWSData lastKnownValue;
    iPAWSSubscriber* subscriber;
};

#endif