pawswidget.h

Go to the documentation of this file.

/*
 * pawswidget.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.
 *
 *
 * pawswidget.h: interface for the pawsWidget class.
 ---------------------------------------------------------------------------*/

#ifndef PAWS_WIDGET_HEADER
#define PAWS_WIDGET_HEADER

#include <ivideo/graph2d.h>

#include <csutil/array.h>
#include <csutil/csstring.h>

#include <csgeom/csrectrg.h>
#include <csgeom/vector2.h>

#include <iutil/document.h>

//#include "net/cmdbase.h"
#include "pawsmanager.h"
#include "util/scriptvar.h"

#define ATTACH_LEFT     2
#define ATTACH_RIGHT    4
#define ATTACH_BOTTOM   8
#define ATTACH_TOP      16
#define PROPORTIONAL_LEFT   32
#define PROPORTIONAL_RIGHT  64
#define PROPORTIONAL_TOP    128
#define PROPORTIONAL_BOTTOM 256

#define SCROLL_UP     -1000
#define SCROLL_DOWN   -2000
#define SCROLL_THUMB  -3000
#define SCROLL_AUTO   -4000
#define SCROLL_SET    -5000

#define DEFAULT_MIN_HEIGHT  5
#define DEFAULT_MIN_WIDTH   5


#define RESIZE_LEFT    2
#define RESIZE_RIGHT   4
#define RESIZE_TOP     8
#define RESIZE_BOTTOM 16

enum
{
    ALIGN_LEFT,
    ALIGN_CENTER,
    ALIGN_RIGHT
};

#define BORDER_INNER_BEVEL 0x1
#define BORDER_OUTER_BEVEL 0x2
#define BORDER_REVERSED    0x4
#define BORDER_BUMP        (BORDER_OUTER_BEVEL)
#define BORDER_RAISED      (BORDER_INNER_BEVEL|BORDER_OUTER_BEVEL)
#define BORDER_SUNKEN      (BORDER_REVERSED|BORDER_OUTER_BEVEL)
#define BORDER_ETCHED      (BORDER_REVERSED|BORDER_RAISED)


#define DEFAULT_FONT_SIZE   12

#define DEFAULT_FONT_STYLE     0
#define FONT_STYLE_DROPSHADOW  1
#define FONT_STYLE_BOLD        2


enum PAWS_WIDGET_SCRIPT_EVENTS
{
    PW_SCRIPT_EVENT_SHOW = 0,
    PW_SCRIPT_EVENT_HIDE,
    PW_SCRIPT_EVENT_MOUSEDOWN,
    PW_SCRIPT_EVENT_MOUSEUP,
    PW_SCRIPT_EVENT_VALUECHANGED,

    PW_SCRIPT_EVENT_COUNT
};

struct iPawsImage;
class PawsManager;
class pawsBorder;
class pawsScrollBar;
class pawsListBox;
class pawsButton;
class pawsMenu;
class pawsMenuAction;
class WidgetConfigWindow;
class pawsScript;
class pawsTitle;

class pawsWidget : public iPAWSSubscriber, public iScriptableVar
{
public:
    class iWidgetData {};

protected:
    csString factory;

    int id;

    pawsWidget* parent;

    csRef<iGraphics2D> graphics2D;

    csRect defaultFrame;

    csRect screenFrame;

    csRect clipRect;

    pawsTitle* titleBar;

    csString filename;

    pawsButton* close_widget;

    csArray<pawsWidget*> children;

    csArray<pawsWidget*> taborder;

    pawsWidget* onEnter;

    bool visible;

    bool saveWidgetPositions;

    bool configurable;

    bool movable;

    bool isResizable;

    bool showResize;

    bool resizeToScreen;

    bool keepaspect;

    bool alwaysOnTop;

    int min_width;

    int min_height;

    int max_width;

    int max_height;

    csString name;

    csString closeName;

    csString subscribedVar;

    int bgColour;

    csRef<iPawsImage> bgImage;

    pawsBorder* border;

    bool borderTitleShadow;

    int attachFlags;

    bool hasFocus;

    bool hasMouseFocus;

    float fadeVal;

    int alpha;

    int alphaMin;

    bool fade;

    float fadeSpeed;

    csString contextMenuFile;

    pawsMenu* contextMenu;

    int borderColours[5];

    bool hasBorderColours;

    csRef<iFont> myFont;

    int defaultFontColour;

    int defaultFontShadowColour;

    float defaultFontSize;

    float fontSize;

    bool scaleFont;

    csString fontName;

    int fontStyle;

    csString xmlbinding;

    csString toolTip;

    csString defaultToolTip;

    csRef<iPawsImage> maskImage;

    bool ignore;

    int margin;

    iWidgetData* extraData;

    bool needsRender;

    bool parentDraw;

    bool overwrite_subscription;

    csString subscription_format;

    pawsScript* scriptEvents[PW_SCRIPT_EVENT_COUNT];

    csHash<csString,csString> defaultWidgetStyles;

    bool ReadDefaultWidgetStyles(iDocumentNode* node);

    bool showOnMouseOver;

    csString showOnMouseOver_image;

public:

    pawsWidget();
    pawsWidget(const pawsWidget &origin);


    virtual ~pawsWidget();

    virtual pawsWidget* WidgetAt(int x, int y);

    virtual void Ignore(bool ig)
    {
        ignore = ig;
    }

    virtual void PerformAction(const char* action);

    virtual csRect GetScreenFrame();

    virtual csRect GetDefaultFrame()
    {
        return defaultFrame;
    }

    bool IsVisible()
    {
        return visible && (!parent || parent->IsVisible());
    }

    void SetVisibility(bool visible)
    {
        if(visible) Show();
        else Hide();
    }

    virtual void Show();

    virtual void ShowBehind();

    virtual void Hide();

    virtual void Close()
    {
        Hide();
    }

    virtual bool CheckButtonPressed(int button, int modifiers, pawsWidget* pressedWidget);

    virtual bool CheckButtonReleased(int button, int modifiers, pawsWidget* pressedWidget);

    virtual bool CheckKeyHandled(int /*keyCode*/)
    {
        return false;
    }

    void AddChild(pawsWidget* widget);

    void AddChild(size_t Index, pawsWidget* widget);

    virtual void DeleteChild(pawsWidget* widget);

    void DeleteYourself()
    {
        parent->DeleteChild(this);
    }

    void RemoveChild(pawsWidget* widget);

    pawsWidget* GetChild(size_t i)
    {
        return children.Get(i);
    }

    size_t GetChildrenCount()
    {
        return children.GetSize();
    }

    bool IsIndirectChild(pawsWidget* widget);

    bool IsChildOf(pawsWidget* someParent);

    bool Includes(pawsWidget* widget);

    void SetParent(pawsWidget* widget);

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

    pawsWidget* FindWidget(int id, bool complain = true);

    pawsWidget* FindWidgetXMLBinding(const char* xmlbinding);

    virtual const csString &GetXMLBinding()
    {
        return xmlbinding;
    }

    virtual void SetXMLBinding(csString &xmlbinding)
    {
        this->xmlbinding = xmlbinding;
    }

    pawsWidget* GetParent()
    {
        return parent;
    }

    virtual bool Load(iDocumentNode* node);

    virtual bool LoadAttributes(iDocumentNode* node);

    virtual bool LoadEventScripts(iDocumentNode* node);

    virtual bool LoadChildren(iDocumentNode* node);

    bool LoadFromFile(const csString &fileName);

    virtual bool Setup(iDocumentNode* /*node*/)
    {
        return true;
    }

    virtual bool PostSetup()
    {
        return true;
    }

    virtual bool SelfPopulateXML(const char* xmlstr);

    virtual bool SelfPopulate(iDocumentNode* node);

    bool DrawWindow();

    void DrawForeground();

    virtual void Draw();

    virtual void Draw3D(iGraphics3D*) {}

    virtual void DrawBackground();

    virtual void DrawChildren();

    virtual void DrawMask();

    virtual bool ParentDraw() const
    {
        return parentDraw || !PawsManager::GetSingleton().UsingR2T();
    }

    bool IsResizable()
    {
        return isResizable;
    }

    void SetResizeShow(bool v)
    {
        showResize = v;
    }

    void SetModalState(bool isModal);

    virtual bool OnGainFocus(bool /*notifyParent*/ = true)
    {
        hasFocus = true;
        if(hasFocus) return true;
        if(parent) parent->OnGainFocus();
        return true;
    }

    virtual void OnLostFocus()
    {
        if(!hasFocus) return;
        hasFocus = false;
        if(parent) parent->OnLostFocus();
    }

    virtual void OnResize();

    virtual void StopResize();

    virtual int GetBorderColour(int which);

    virtual void SetRelativeFrame(int x, int y, int width, int height);

    virtual void ResetToDefaultFrame()
    {
        screenFrame = defaultFrame;
    }

    virtual void SetRelativeFramePos(int x, int y);

    virtual void SetRelativeFrameSize(int width, int height);

    virtual void SetAttachFlags(int flags)
    {
        attachFlags = flags;
    }

    virtual bool OnMouseDown(int button, int modifiers, int x, int y);

    virtual bool OnMouseUp(int button, int modifiers, int x, int y);

    virtual bool OnDoubleClick(int button, int modifiers, int x, int y);


    virtual bool OnMouseEnter();

    virtual bool OnMouseExit();

    virtual bool OnChildMouseEnter(pawsWidget* child);

    virtual bool OnChildMouseExit(pawsWidget* child);

    virtual bool OnKeyDown(utf32_char keyCode, utf32_char keyChar, int modifiers);

    virtual bool OnJoypadDown(int key, int modifiers);

    virtual bool OnClipboard(const csString &content);

    virtual bool HasFocus()
    {
        return hasFocus;
    }

    virtual bool GetFocusOverridesControls() const
    {
        return false;
    }

    virtual void BringToTop(pawsWidget* widget);

    virtual void SendToBottom(pawsWidget* widget);

    const char* GetName()
    {
        return name;
    }

    void SetName(const char* newName)
    {
        name.Replace(newName);
        closeName = name;
        closeName.Append("_close");
    }

    const char* GetCloseName()
    {
        return closeName;
    }

    virtual void MoveDelta(int dx, int dy);

    virtual void MoveTo(int x, int y);

    virtual void CenterTo(int x, int y);

    virtual void CenterToMouse();

    virtual void Resize(int flags);

    virtual void Resize(int dx, int dy, int flags);

    virtual void SetSize(int newWidth, int newHeight);

    virtual void SetForceSize(int newWidth, int newHeight);

    virtual void UseBorder(const char* style = 0);

    virtual pawsBorder* GetBorder()
    {
        return border;
    }

    virtual int GetBorderStyle()
    {
        return BORDER_BUMP;
    }

    virtual void SetBackground(const char* imageName);

    csString GetBackground();

    virtual void SetBackgroundAlpha(int alphaValue);

    virtual void Resize();

    virtual bool OnButtonPressed(int button, int keyModifier, pawsWidget* widget)
    {
        if(parent)
            return parent->OnButtonPressed(button, keyModifier, widget);

        return true;
    }

    virtual bool OnButtonReleased(int button, int keyModifier, pawsWidget* widget)
    {
        if(parent)
            return parent->OnButtonReleased(button, keyModifier, widget);
        return false;
    }

    virtual bool OnScroll(int scrollDirection, pawsScrollBar* widget)
    {
        if(parent) return parent->OnScroll(scrollDirection, widget);
        return false;
    }

    virtual bool OnSelected(pawsWidget* widget);

    virtual bool OnMenuAction(pawsWidget* widget, const pawsMenuAction &action);

    virtual bool OnChange(pawsWidget* widget);

    void SetID(int newID)
    {
        id = newID;
    }

    int  GetID()
    {
        return id;
    }

    bool IsAlwaysOnTop()
    {
        return alwaysOnTop;
    }

    void SetAlwaysOnTop(bool value)
    {
        alwaysOnTop = value;
        if(parent)
            parent->BringToTop(this);
    }

    void SetMovable(bool value)
    {
        movable = value;
    }

    void SetToolTip(const char* text)
    {
        toolTip.Replace(text);
    }

    csString &GetToolTip()
    {
        return toolTip;
    }

    void FormatToolTip(const char* fmt, ...);

    void SetDefaultToolTip()
    {
        toolTip.Replace(defaultToolTip);
    }

    virtual void OnListAction(pawsListBox* selected, int status)
    {
        if(parent) parent->OnListAction(selected,status);
    }

    virtual void SavePosition();

    virtual csRect LoadPositions();

    void SetFactory(const char* myfactory)
    {
        factory = myfactory;
    }

    const char* GetType()
    {
        return factory;
    }

    int GetActualWidth(int myValue=-1)
    {
        if(myValue == -1)
            return screenFrame.Width();

        if(!resizeToScreen)
            return myValue;

        int desktop = graphics2D->GetWidth();
        if(myValue > 800)
            return desktop;

        float value = (float)myValue;

        float ret = (value * desktop) / 800.0f + 0.5f;
        return ((int)ret);
    }

    int GetActualHeight(int myValue=-1)
    {
        if(myValue == -1)
            return screenFrame.Height();

        if(!resizeToScreen)
            return myValue;

        int desktop = graphics2D->GetHeight();
        if(myValue > 600)
            return desktop;

        float value = (float)myValue;

        float ret = (value * desktop) / 600.0f + 0.5f;
        return ((int)ret);
    }

    int GetLogicalWidth(int myValue)
    {
        if(!resizeToScreen)
            return myValue;

        int desktop = graphics2D->GetWidth();
        myValue *= 800;
        myValue /= desktop;
        return myValue;
    }

    int GetLogicalHeight(int myValue)
    {
        if(!resizeToScreen)
            return myValue;

        int desktop = graphics2D->GetHeight();
        myValue *= 600;
        myValue /= desktop;
        return myValue;
    }

    virtual void MouseOver(bool value);

    void SetFade(bool value);

    void SetFontScaling(bool value);

    void DrawWidgetText(const char* text, int x, int y, int style=-1);

    csRect GetWidgetTextRect(const char* text, int x, int y, int style=-1);

    void SetMinSize(int width, int height)
    {
        min_width = width;
        min_height = height;
    }

    void GetMinSize(int &width, int &height)
    {
        width = min_width;
        height = min_height;
    }

    void SetMaxSize(int width, int height)
    {
        max_width = width;
        max_height = height;
    }


    void SetContextMenu(const csString &fileName)
    {
        contextMenuFile = fileName;
    }

    void MakeFullyVisible();

    void RecalcScreenPositions();

    void ClipToParent(bool allowForBackgroundBorder);

    csRect ClipRect()
    {
        return clipRect;
    }

    void SetColour(int newColour = -2);

    void SetFont(const char* fontName, int Size=0);

    void ChangeFontSize(float newSize);

    float GetFontSize();

    iFont* GetFont(bool scaled = true);

    virtual int GetFontColour();

    int    GetFontShadowColour();

    int    GetFontStyle();

    void   SetFontStyle(int style);

    virtual bool Contains(int x, int y);

    virtual void CreateWidgetConfigWindow();

    virtual void DestroyWidgetConfigWindow();

    int GetMinAlpha()
    {
        return alphaMin;
    };

    int GetMaxAlpha()
    {
        return alpha;
    };

    int GetFadeVal()
    {
        return (int)fadeVal;
    };

    void SetMinAlpha(int value)
    {
        alphaMin=value;
    };

    void SetMaxAlpha(int value)
    {
        alpha=value;
    };

    bool isFadeEnabled()
    {
        return fade;
    };

    float GetFadeSpeed()
    {
        return fadeSpeed;
    };

    void SetFadeSpeed(float speed)
    {
        fadeSpeed=speed;
    };

    bool isScalingFont()
    {
        return scaleFont;
    }

    void SetTitle(const char* title);

    virtual void SaveSettings();

    virtual void LoadSettings();

    virtual void DrawToolTip(int x, int y);

    virtual void Dump(csString tab = "");

    csString GetPathInWidgetTree();

    void SetMaskingImage(const char* image);

    void ClearMaskingImage();

    void SetBackgroundColor(int r,int g, int b);

    void ClearBackgroundColor()
    {
        bgColour = -1;
    }

    void SetFilename(const char* name);

    const char* GetFilename();

    void ReloadWidget();

    void SetExtraData(iWidgetData* data)
    {
        delete extraData;
        extraData = data;
    }

    iWidgetData* GetExtraData()
    {
        return extraData;
    }

    bool IsConfigurable()
    {
        return configurable;
    }

    virtual void OnUpdateData(const char* /*dataname*/, PAWSData & /*data*/) {}
    virtual void NewSubscription(const char* dataname)
    {
        subscribedVar = dataname;
    }

    bool SetTitle(const char* text, const char* image, const char* align, const char* close_button, const bool shadowTitle = true);

    void RemoveTitle();

    const char* FindDefaultWidgetStyle(const char* factoryName);

    void SetNeedsRender(bool needs)
    {
        if(parent)
            parent->SetNeedsRender(needs);
        else
            needsRender = needs;
    }

    bool NeedsRender() const
    {
        return needsRender;
    }

protected:
    int ResizeFlags(int mouseX, int mouseY);

    bool CreateContextMenu();

    int CalcChildPosition(pawsWidget* child);

    void LoadBorderColours(iDocumentNode* node);

    void SetCloseButtonPos();

    int GetAttachFlag(const char* flag);

public:
    void RunScriptEvent(PAWS_WIDGET_SCRIPT_EVENTS event);

    const char* ToString()
    {
        return name.GetDataSafe();
    }
    virtual double GetProperty(MathEnvironment* env, const char* ptr);
    virtual double CalcFunction(MathEnvironment* env, const char* functionName, const double* params);
    virtual void SetProperty(const char* ptr, double value);

    csArray<csString> publishList;
};

//----------------------------------------------------------------------------



class pawsWidgetFactory
{
public:
    virtual ~pawsWidgetFactory() {};

    virtual pawsWidget* Create();

    virtual pawsWidget* Create(const pawsWidget* origin);

    virtual const char* GetName()
    {
        return factoryName;
    }

protected:
    virtual void Register(const char* name);


    csString factoryName;
};

//---------------------------------------------------------------------------


class pawsBaseWidgetFactory : public pawsWidgetFactory
{
public:
    pawsBaseWidgetFactory()
    {
        Register("pawsWidget");
    }

    pawsWidget* Create()
    {
        return new pawsWidget();
    }
};


#define CREATE_PAWS_FACTORY( factoryName ) \
class factoryName##Factory : public pawsWidgetFactory \
{ \
public: \
    factoryName##Factory( ) \
    { \
        Register( #factoryName ); \
    } \
 \
    pawsWidget* Create() \
    { \
        return new factoryName( ); \
    } \
    pawsWidget* Create(const pawsWidget* origin)\
    {\
        const factoryName * widget = dynamic_cast<const factoryName *>(origin);\
        if(widget)\
        {\
            return new factoryName(*widget);\
        }\
        return NULL;\
    }\
}




#endif