Initial commit

engines/ags/shared/gui/gui_main.h

@@ -0,0 +1,301 @@
+/* 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_MAIN_H
+#define AGS_SHARED_GUI_GUI_MAIN_H
+
+#include "common/std/vector.h"
+#include "ags/engine/ac/draw.h"
+#include "ags/shared/ac/common.h"
+#include "ags/shared/ac/common_defines.h" // TODO: split out gui drawing helpers
+#include "ags/shared/gfx/gfx_def.h" // TODO: split out gui drawing helpers
+#include "ags/shared/gui/gui_defines.h"
+#include "ags/shared/util/error.h"
+#include "ags/shared/util/geometry.h"
+#include "ags/shared/util/string.h"
+
+namespace AGS3 {
+
+// Forward declaration
+namespace AGS {
+namespace Shared {
+class Stream;
+}
+}
+using namespace AGS; // FIXME later
+
+class SplitLines;
+
+#define LEGACY_MAX_OBJS_ON_GUI             30
+
+#define GUIMAIN_LEGACY_RESERVED_INTS       5
+#define GUIMAIN_LEGACY_NAME_LENGTH         16
+#define GUIMAIN_LEGACY_EVENTHANDLER_LENGTH 20
+#define GUIMAIN_LEGACY_TW_FLAGS_SIZE       4
+
+namespace AGS {
+namespace Shared {
+
+// Legacy GUIMain visibility state, which combined Visible property and override factor
+enum LegacyGUIVisState {
+	kGUIVisibility_LockedOff = -1, // locked hidden (used by PopupMouseY guis)
+	kGUIVisibility_Off = 0, // hidden
+	kGUIVisibility_On = 1  // shown
+};
+
+class Bitmap;
+class GUIObject;
+
+
+class GUIMain {
+public:
+	static String FixupGUIName(const String &name);
+
+public:
+	GUIMain();
+
+	void	InitDefaults();
+
+	// Tells if the gui background supports alpha channel
+	bool	HasAlphaChannel() const;
+	// Tells if GUI will react on clicking on it
+	bool	IsClickable() const { return (_flags & kGUIMain_Clickable) != 0; }
+	// Tells if GUI's visibility is overridden and it won't be displayed on
+	// screen regardless of Visible property (until concealed mode is off).
+	bool	IsConcealed() const { return (_flags & kGUIMain_Concealed) != 0; }
+	// Tells if gui is actually meant to be displayed on screen.
+	// Normally Visible property determines whether GUI is allowed to be seen,
+	// but there may be other settings that override it.
+	bool	IsDisplayed() const { return IsVisible() && !IsConcealed(); }
+	// Tells if given coordinates are within interactable area of gui
+	// NOTE: this currently tests for actual visibility and Clickable property
+	bool	IsInteractableAt(int x, int y) const;
+	// Tells if gui is a text window
+	bool	IsTextWindow() const { return (_flags & kGUIMain_TextWindow) != 0; }
+	// Tells if GUI is *allowed* to be displayed and interacted with.
+	// This does not necessarily mean that it is displayed right now, because
+	// GUI may be hidden for other reasons, including overriding behavior.
+	// For example GUI with kGUIPopupMouseY style will not be shown unless
+	// mouse cursor is at certain position on screen.
+	bool	IsVisible() const { return (_flags & kGUIMain_Visible) != 0; }
+
+	// Tells if GUI has graphically changed recently
+	bool	HasChanged() const { return _hasChanged; }
+	bool	HasControlsChanged() const { return _hasControlsChanged; }
+	// Manually marks GUI as graphically changed
+	// NOTE: this only matters if GUI's own graphic changes (content, size etc),
+	// but not its state (visible) or texture drawing mode (transparency, etc).
+	void	MarkChanged();
+	// Marks GUI as having any of its controls changed its looks.
+	void	MarkControlChanged();
+	// Clears changed flag
+	void	ClearChanged();
+	// Notify GUI about any of its controls changing its location.
+	void	NotifyControlPosition();
+	// Notify GUI about one of its controls changing its interactive state.
+	void	NotifyControlState(int objid, bool mark_changed);
+	// Resets control-under-mouse detection.
+	void	ResetOverControl();
+
+	// Finds a control under given screen coordinates, returns control's child ID.
+	// Optionally allows extra leeway (offset in all directions) to let the user grab tiny controls.
+	// Optionally only allows clickable controls, ignoring non-clickable ones.
+	int32_t FindControlAt(int atx, int aty, int leeway = 0, bool must_be_clickable = true) const;
+	// Gets the number of the GUI child controls
+	int32_t GetControlCount() const;
+	// Gets control by its child's index
+	GUIObject *GetControl(int32_t index) const;
+	// Gets child control's type, looks up with child's index
+	GUIControlType GetControlType(int32_t index) const;
+	// Gets child control's global ID, looks up with child's index
+	int32_t GetControlID(int32_t index) const;
+	// Gets an array of child control indexes in the z-order, from bottom to top
+	const std::vector<int> &GetControlsDrawOrder() const;
+
+	// Child control management
+	// Note that currently GUIMain does not own controls (should not delete them)
+	void    AddControl(GUIControlType type, int32_t id, GUIObject *control);
+	void    RemoveAllControls();
+
+	// Operations
+	bool    BringControlToFront(int32_t index);
+	void    DrawSelf(Bitmap *ds);
+	void    DrawWithControls(Bitmap *ds);
+	// Polls GUI state, providing current cursor (mouse) coordinates
+	void    Poll(int mx, int my);
+	HError  RebuildArray();
+	void    ResortZOrder();
+	bool    SendControlToBack(int32_t index);
+	// Sets whether GUI should react to player clicking on it
+	void    SetClickable(bool on);
+	// Override GUI visibility; when in concealed mode GUI won't show up
+	// even if Visible = true
+	void    SetConceal(bool on);
+	// Attempts to change control's zorder; returns if zorder changed
+	bool    SetControlZOrder(int32_t index, int zorder);
+	// Changes GUI style to the text window or back
+	void    SetTextWindow(bool on);
+	// Sets GUI transparency as a percentage (0 - 100) where 100 = invisible
+	void    SetTransparencyAsPercentage(int percent);
+	// Sets whether GUI is allowed to be displayed on screen
+	void    SetVisible(bool on);
+
+	// Events
+	void    OnMouseButtonDown(int mx, int my);
+	void    OnMouseButtonUp();
+
+	// Serialization
+	void    ReadFromFile(Stream *in, GuiVersion gui_version);
+	void    WriteToFile(Stream *out) const;
+	// TODO: move to engine, into gui savegame component unit
+	// (should read/write GUI properties accessing them by interface)
+	void    ReadFromSavegame(Stream *in, GuiSvgVersion svg_version);
+	void    WriteToSavegame(Stream *out) const;
+
+private:
+	void    DrawBlob(Bitmap *ds, int x, int y, color_t draw_color);
+	// Same as FindControlAt but expects local space coordinates
+	int32_t FindControlAtLocal(int atx, int aty, int leeway, bool must_be_clickable) const;
+
+	// TODO: all members are currently public; hide them later
+public:
+	int32_t ID;             // GUI identifier
+	String  Name;           // the name of the GUI
+
+	int32_t X;
+	int32_t Y;
+	int32_t Width;
+	int32_t Height;
+	color_t BgColor;        // background color
+	int32_t BgImage;        // background sprite index
+	color_t FgColor;        // foreground color (used as border color in normal GUIs,
+	// and text color in text windows)
+	int32_t Padding;        // padding surrounding a GUI text window
+	GUIPopupStyle PopupStyle; // GUI popup behavior
+	int32_t PopupAtMouseY;  // popup when _G(mousey) < this
+	int32_t Transparency;   // "incorrect" alpha (in legacy 255-range units)
+	int32_t ZOrder;
+
+	int32_t FocusCtrl;      // which control has the focus
+	int32_t HighlightCtrl;  // which control has the bounding selection rect
+	int32_t MouseOverCtrl;  // which control has the mouse cursor over it
+	int32_t MouseDownCtrl;  // which control has the mouse button pressed on it
+	Point   MouseWasAt;     // last mouse cursor position
+
+	String  OnClickHandler; // script function name
+
+private:
+	int32_t _flags;         // style and behavior flags
+	bool    _hasChanged;    // flag tells whether GUI has graphically changed recently
+	bool    _hasControlsChanged;
+	bool	_polling; // inside the polling process
+
+	// Array of types and control indexes in global GUI object arrays;
+	// maps GUI child slots to actual controls and used for rebuilding Controls array
+	typedef std::pair<GUIControlType, int32_t> ControlRef;
+	std::vector<ControlRef> _ctrlRefs;
+	// Array of child control references (not exclusively owned!)
+	std::vector<GUIObject *> _controls;
+	// Sorted array of controls in z-order.
+	std::vector<int>         _ctrlDrawOrder;
+};
+
+
+namespace GUI {
+extern GuiVersion GameGuiVersion;
+extern GuiOptions Options;
+
+// Applies current text direction setting (may depend on multiple factors)
+String ApplyTextDirection(const String &text);
+// Calculates the text's draw position, given the alignment
+// optionally returns the real graphical rect that the text would occupy
+Point CalcTextPosition(const char *text, int font, const Rect &frame, FrameAlignment align, Rect *gr_rect = nullptr);
+// Calculates the text's draw position and horizontal extent,
+// using strictly horizontal alignment
+Line CalcTextPositionHor(const char *text, int font, int x1, int x2, int y, FrameAlignment align);
+// Calculates the graphical rect that the text would occupy
+// if drawn at the given coordinates
+Rect CalcTextGraphicalRect(const char *text, int font, const Point &at);
+// Calculates the graphical rect that the text would occupy
+// if drawn aligned to the given frame
+Rect CalcTextGraphicalRect(const char *text, int font, const Rect &frame, FrameAlignment align);
+// Calculates a vertical graphical extent for a given font,
+// which is a top and bottom offsets in zero-based coordinates.
+// NOTE: this applies font size fixups.
+Line CalcFontGraphicalVExtent(int font);
+// Draw standart "shading" effect over rectangle
+void DrawDisabledEffect(Bitmap *ds, const Rect &rc);
+// Draw text aligned inside rectangle
+void DrawTextAligned(Bitmap *ds, const char *text, int font, color_t text_color, const Rect &frame, FrameAlignment align);
+// Draw text aligned horizontally inside given bounds
+void DrawTextAlignedHor(Bitmap *ds, const char *text, int font, color_t text_color, int x1, int x2, int y, FrameAlignment align);
+
+// Parses the string and returns combination of label macro flags
+GUILabelMacro FindLabelMacros(const String &text);
+// Applies text transformation necessary for rendering, in accordance to the
+// current game settings, such as right-to-left render, and anything else
+String TransformTextForDrawing(const String &text, bool translate, bool apply_direction);
+// Wraps given text to make it fit into width, stores it in the lines;
+// apply_direction param tells whether text direction setting should be applied
+size_t SplitLinesForDrawing(const char *text, bool apply_direction, SplitLines &lines, int font, int width, size_t max_lines = -1);
+
+// Mark all existing GUI for redraw
+void MarkAllGUIForUpdate(bool redraw, bool reset_over_ctrl);
+// Mark all translatable GUI controls for redraw
+void MarkForTranslationUpdate();
+// Mark all GUI which use the given font for recalculate/redraw;
+// pass -1 to update all the textual controls together
+void MarkForFontUpdate(int font);
+// Mark labels that acts as special text placeholders for redraw
+void MarkSpecialLabelsForUpdate(GUILabelMacro macro);
+// Mark inventory windows for redraw, optionally only ones linked to given character;
+// also marks buttons with inventory icon mode
+void MarkInventoryForUpdate(int char_id, bool is_player);
+
+// Reads all GUIs and their controls.
+// WARNING: the data is read into the global arrays (guis, guibuts, and so on)
+// TODO: remove is_savegame param after dropping support for old saves
+// because only they use ReadGUI to read runtime GUI data
+HError ReadGUI(Stream *in, bool is_savegame = false);
+// Writes all GUIs and their controls.
+// WARNING: the data is written from the global arrays (guis, guibuts, and so on)
+void WriteGUI(Stream *out);
+// Converts legacy GUIVisibility into appropriate GUIMain properties
+void ApplyLegacyVisibility(GUIMain &gui, LegacyGUIVisState vis);
+
+// Rebuilds GUIs, connecting them to the child controls in memory.
+// WARNING: the data is processed in the global arrays (guis, guibuts, and so on)
+HError RebuildGUI();
+}
+
+} // namespace Shared
+} // namespace AGS
+
+extern int get_adjusted_spritewidth(int spr);
+extern int get_adjusted_spriteheight(int spr);
+extern bool is_sprite_alpha(int spr);
+
+extern void set_eip_guiobj(int eip);
+extern int get_eip_guiobj();
+
+} // namespace AGS3
+
+#endif