gui_object.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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, either version 3 of the License, or
 * (at your option) any later version.
 *
 * 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, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef AGS_SHARED_GUI_GUI_OBJECT_H
#define AGS_SHARED_GUI_GUI_OBJECT_H
 
#include "ags/shared/core/types.h"
#include "ags/shared/gfx/bitmap.h"
#include "ags/shared/gui/gui_defines.h"
#include "ags/shared/util/string.h"
#include "ags/globals.h"
 
namespace AGS3 {
 
struct KeyInput;
 
namespace AGS {
namespace Shared {
 
enum LegacyGUIAlignment {
    kLegacyGUIAlign_Left = 0,
    kLegacyGUIAlign_Right = 1,
    kLegacyGUIAlign_Center = 2
};
 
class GUIObject {
public:
    GUIObject();
    virtual ~GUIObject() {}
 
    String          GetScriptName() const;
 
    String          GetEventArgs(int event) const;
    int             GetEventCount() const;
    String          GetEventName(int event) const;
    bool            IsClickable() const { return (Flags & kGUICtrl_Clickable) != 0; }
    bool            IsDeleted() const { return (Flags & kGUICtrl_Deleted) != 0; }
    bool            IsEnabled() const { return (Flags & kGUICtrl_Enabled) != 0; }
    bool            IsTranslated() const { return (Flags & kGUICtrl_Translated) != 0; }
    bool            IsVisible() const { return (Flags & kGUICtrl_Visible) != 0; }
    // overridable routine to determine whether the mouse is over the control
    virtual bool    IsOverControl(int x, int y, int leeway) const;
    Size            GetSize() const { return Size(_width, _height); }
    int             GetWidth() const { return _width; }
    int             GetHeight() const { return _height; }
    int             GetTransparency() const { return _transparency; }
    // Compatibility: should the control's graphic be clipped to its x,y,w,h
    virtual bool    IsContentClipped() const { return true; }
    // Tells if the object image supports alpha channel
    virtual bool    HasAlphaChannel() const { return false; }
 
    // Operations
    // Returns the (untransformed!) visual rectangle of this control,
    // in *relative* coordinates, optionally clipped by the logical size
    virtual Rect    CalcGraphicRect(bool /*clipped*/) {
        return RectWH(0, 0, _width, _height);
    }
    virtual void    Draw(Bitmap *ds, int x = 0, int y = 0) {
        (void)ds; (void)x; (void)y;
    }
    void            SetClickable(bool on);
    void            SetEnabled(bool on);
    void            SetSize(int width, int height);
    inline void     SetWidth(int width) { SetSize(width, _height); }
    inline void     SetHeight(int height) { SetSize(_width, height); }
    void            SetTranslated(bool on);
    void            SetVisible(bool on);
    void            SetTransparency(int trans);
 
    // Events
    // Key pressed for control
    virtual void    OnKeyPress(const KeyInput &) {}
    // Mouse button down - return 'True' to lock focus
    virtual bool    OnMouseDown() {
        return false;
    }
    // Mouse moves onto control
    virtual void    OnMouseEnter() {
    }
    // Mouse moves off control
    virtual void    OnMouseLeave() {
    }
    // Mouse moves over control - x,y relative to gui
    virtual void    OnMouseMove(int /*x*/, int /*y*/) {
    }
    // Mouse button up
    virtual void    OnMouseUp() {
    }
    // Control was resized
    virtual void    OnResized() { MarkPositionChanged(true); }
 
    // Serialization
    virtual void    ReadFromFile(Shared::Stream *in, GuiVersion gui_version);
    virtual void    WriteToFile(Shared::Stream *out) const;
    virtual void    ReadFromSavegame(Shared::Stream *in, GuiSvgVersion svg_ver);
    virtual void    WriteToSavegame(Shared::Stream *out) const;
 
    // TODO: these members are currently public; hide them later
public:
    // Manually marks GUIObject as graphically changed
    // NOTE: this only matters if control's own graphic changes, but not its
    // logical (visible, clickable, etc) or visual (e.g. transparency) state.
    void    MarkChanged();
    // Notifies parent GUI that this control has changed its visual state
    void    MarkParentChanged();
    // Notifies parent GUI that this control has changed its location (pos, size)
    void    MarkPositionChanged(bool self_changed);
    // Notifies parent GUI that this control's interactive state has changed
    void    MarkStateChanged(bool self_changed, bool parent_changed);
    bool    HasChanged() const { return _hasChanged; };
    void    ClearChanged();
 
    int32_t  Id;         // GUI object's identifier
    int32_t  ParentId;   // id of parent GUI
    String   Name;       // script name
 
    int32_t  X;
    int32_t  Y;
    int32_t  ZOrder;
    bool     IsActivated; // signals user interaction
 
    String   EventHandlers[MAX_GUIOBJ_EVENTS]; // script function names
 
protected:
    uint32_t Flags;      // generic style and behavior flags
    int32_t  _width;
    int32_t  _height;
    int32_t  _transparency; // "incorrect" alpha (in legacy 255-range units)
    bool     _hasChanged;
 
    // TODO: explicit event names & handlers for every event
    // FIXME: these must be static!! per type
    int32_t  _scEventCount;                    // number of supported script events
    String   _scEventNames[MAX_GUIOBJ_EVENTS]; // script event names
    String   _scEventArgs[MAX_GUIOBJ_EVENTS];  // script handler params
};
 
// Converts legacy alignment type used in GUI Label/ListBox data (only left/right/center)
HorAlignment ConvertLegacyGUIAlignment(LegacyGUIAlignment align);
LegacyGUIAlignment GetLegacyGUIAlignment(HorAlignment align);
 
} // namespace Shared
} // namespace AGS
 
// Tells if all controls are disabled
 
// Tells if the given control is considered enabled, taking global flag into account
inline bool IsGUIEnabled(AGS::Shared::GUIObject *g) {
    return (_G(all_buttons_disabled) < 0) && g->IsEnabled();
}
 
} // namespace AGS3
 
#endif