Initial commit

engines/bagel/spacebar/baglib/object.h

@@ -0,0 +1,368 @@
+
+/* 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 BAGEL_BAGLIB_OBJECT_H
+#define BAGEL_BAGLIB_OBJECT_H
+
+#include "bagel/spacebar/baglib/expression.h"
+#include "bagel/spacebar/baglib/res.h"
+#include "bagel/spacebar/boflib/gfx/bitmap.h"
+#include "bagel/boflib/string.h"
+#include "bagel/spacebar/baglib/parse_object.h"
+
+namespace Bagel {
+namespace SpaceBar {
+
+class CBagObject;
+typedef void *(*BagFuncPtr)(int, void *);
+
+enum BagObjectType {
+	BASE_OBJ = 0x0000,
+	BMP_OBJ = BOF_BMP_OBJ,
+	SPRITE_OBJ = BOF_SPRITE_OBJ,
+	BUTTON_OBJ = BOF_BUTTON_OBJ,
+	SOUND_OBJ = BOF_SOUND_OBJ,
+	LINK_OBJ = BOF_LINK_OBJ,
+	TEXT_OBJ = BOF_TEXT_OBJ,
+	CHAR_OBJ = BOF_CHAR_OBJ,
+	VAR_OBJ = BOF_VAR_OBJ,
+	AREA_OBJ = BOF_AREA_OBJ,
+	EXPRESS_OBJ = BOF_EXPRESS_OBJ,
+	COMMAND_OBJ = BOF_COMM_OBJ,
+	MOVIE_OBJ = BOF_MOVIE_OBJ,
+	THING_OBJ = BOF_THING_OBJ,
+	RESPRNT_OBJ = BOF_RESPRNT_OBJ,
+	DOSSIER_OBJ = BOF_DOSSIER_OBJ,
+	USER_OBJ = 0x1000
+};
+
+enum BAG_OBJECT_PROPERTIES {
+	NONE = 0x0000,
+	MOVABLE = 0x0001,
+	MODAL = 0x0002,
+	VISIBLE = 0x0004,
+	HIGHLIGHT = 0x0008,
+	ACTIVE = 0x0010,
+	TRANSPAR = 0x0020,
+	HIDEONCLK = 0x0040,
+	IMRUN = 0x0080,
+	LOCAL = 0x0100,
+	NEGATIVE = 0x0200,
+	CONUPDATE = 0x0400,
+	STRETCH = 0x0800,
+	TIMELESS = 0x1000,
+	FLOATING = 0x2000,
+	PRELOAD = 0x4000,
+	FOREGROUND = 0x8000
+};
+
+class CBagMenu;
+class CBagStorageDev;
+
+CBofString getStringTypeOfObject(BagObjectType n);
+
+/**
+ * CBofBagObject is an object that can be place within the slide window.
+ */
+class CBagObject : public CBagParseObject, public CBofObject, public CBofError {
+private:
+	CBofString _sFileName;         // File name contain object look/feel data
+	CBofString *_psName = nullptr; // Name of this object, needed by movable objects only, it equals file name unless specified.
+	CBagMenu *_pMenu = nullptr;    // Menu for the object
+	CBagExpression *_pEvalExpr = nullptr;  // Pointer to expression to be evaluated by
+	CBofString _emptyString;
+
+	int16 _nState = 0;         // Current state of the object
+	uint16 _nId = 0;           // Ref Id for an object
+
+protected:
+	uint16 _xObjType = AREA_OBJ;
+
+private:
+	uint16 _nProperties = 0;   // Properties of object
+
+	int16 _nX = 0;             // Replaces _xPosition
+	int16 _nY = 0;
+
+	byte _nOverCursor = 0;    // Ref Id for the objects over cursor
+	byte _bDirty : 1;         // Object needs redrawing or not?
+	byte _bMsgWaiting : 1;    // Event needing to be played?
+	byte _bAlwaysUpdate : 1;  // For message light
+	byte _bNoMenu : 1;        // Used by AS NOMENU
+
+protected:
+	byte _bInteractive = 0;
+
+	// Object property functionality
+	bool isProperty(BAG_OBJECT_PROPERTIES xProp) {
+		return _nProperties & xProp;
+	}
+
+	void setProperty(BAG_OBJECT_PROPERTIES xProp, bool bVal);
+
+public:
+	CBagObject();
+	virtual ~CBagObject();
+
+	bool isInteractive() {
+		return _bInteractive;
+	}
+	void setInteractive(bool b) {
+		_bInteractive = (byte)b;
+	}
+
+	// Callback function functionality - probably can be phased out
+	virtual bool runCallBack() {
+		return false;
+	}
+
+	virtual BagFuncPtr getCallBack() {
+		return nullptr;
+	}
+
+	// Run Object is called when there is no callback and the item was selected
+	virtual bool runObject();
+
+	void setExpression(CBagExpression *pExpr) {
+		_pEvalExpr = pExpr;
+	}
+	CBagExpression *getExpression() const {
+		return _pEvalExpr;
+	}
+
+	// Return true if the Object had members that are properly initialized/de-initialized
+	ErrorCode attach() override;
+	ErrorCode detach() override;
+
+	BagObjectType getType() {
+		return (BagObjectType)_xObjType;
+	}
+	void setType(BagObjectType nType) {
+		_xObjType = (uint16)nType;
+	}
+
+	// Object can be moved within a screen
+	virtual bool isInside(const CBofPoint &xPoint) {
+		return getRect().ptInRect(xPoint);
+	}
+
+	// Object can be moved within a screen
+	bool isMovable() {
+		return isProperty(MOVABLE);
+	}
+	void setMovable(bool b = true) {
+		setProperty(MOVABLE, b);
+	}
+	// Object can be stretched within a screen
+	bool isStretchable() {
+		return isProperty(STRETCH);
+	}
+	void setStretchable(bool b = true) {
+		setProperty(STRETCH, b);
+	}
+	// Object has exclusive updates to a screen
+	bool isModal() {
+		return isProperty(MODAL);
+	}
+	void setModal(bool b = true) {
+		setProperty(MODAL, b);
+	}
+	virtual bool isModalDone() {
+		return true;
+	}
+	//  Is object visible within scene
+	bool isVisible() {
+		return isProperty(VISIBLE);
+	}
+	void setVisible(bool b = true) {
+		setProperty(VISIBLE, b);
+	}
+	// Should object be highlighted when the mouse is over
+	bool isHighlight() {
+		return isProperty(HIGHLIGHT);
+	}
+	void setHighlight(bool b = true) {
+		setProperty(HIGHLIGHT, b);
+	}
+	// Is the object active in this world
+	bool isActive() {
+		return isProperty(ACTIVE);
+	}
+	void setActive(bool b = true) {
+		setProperty(ACTIVE, b);
+	}
+	// Is the object has a transparent background
+	bool isTransparent() {
+		return isProperty(TRANSPAR);
+	}
+
+	virtual void setTransparent(bool b = true) {
+		setProperty(TRANSPAR, b);
+	}
+	// Should the object be hidden when clicked on
+	bool isHideOnClick() {
+		return isProperty(HIDEONCLK);
+	}
+	void setHideOnClick(bool b = true) {
+		setProperty(HIDEONCLK, b);
+	}
+	// Should the object run and then be destroyed after the attach
+	bool isImmediateRun() {
+		return isProperty(IMRUN);
+	}
+	void setImmediateRun(bool b = true) {
+		setProperty(IMRUN, b);
+	}
+	// Is the object currently local to the object
+	bool isLocal() {
+		return isProperty(LOCAL);
+	}
+	void setLocal(bool b = true) {
+		setProperty(LOCAL, b);
+	}
+	// Is the object expression negative
+	bool isNegative() {
+		return isProperty(NEGATIVE);
+	}
+	void setNegative(bool b = true) {
+		setProperty(NEGATIVE, b);
+	}
+	// Should the object be constantly updated, even when not on screen
+	bool isConstantUpdate() {
+		return isProperty(CONUPDATE);
+	}
+	void setConstantUpdate(bool b = true) {
+		setProperty(CONUPDATE, b);
+	}
+	// Does this objects action take up time
+	bool isTimeless() {
+		return isProperty(TIMELESS);
+	}
+
+	void setTimeless(bool b = true);
+	// Does this objects have a set position/or should the sdev provide one when it is attached
+	bool isFloating() {
+		return isProperty(FLOATING);
+	}
+	void setFloating(bool b = true) {
+		setProperty(FLOATING, b);
+	}
+	// Does this objects have a set position/or should the sdev provide one when it is attached
+	bool isPreload() {
+		return isProperty(PRELOAD);
+	}
+	void setPreload(bool b = true) {
+		setProperty(PRELOAD, b);
+	}
+	// Does this objects have a set position/or should the sdev provide one when it is attached
+	bool isForeGround();
+	void setForeGround(bool b = true);
+	int getProperties();
+	void setProperties(int nProperties);
+
+	// Init variables
+	virtual const CBofString *getInitInfo() const;
+	virtual void setInitInfo(const CBofString &) {
+	}
+	virtual int getProperty(const CBofString &sProp);
+	virtual void setProperty(const CBofString &, int nVal);
+
+	bool isDirty() {
+		return _bDirty != 0;
+	}
+
+	void setDirty(bool b = true) {
+		_bDirty = (byte)b;
+	}
+
+	// If this thing is getting purged but is awaiting playback, then mark it as such.
+	bool isMsgWaiting() {
+		return _bMsgWaiting != 0;
+	}
+
+	void setMsgWaiting(bool b = true) {
+		_bMsgWaiting = (byte)b;
+	}
+
+	bool isAlwaysUpdate() {
+		return _bAlwaysUpdate != 0;
+	}
+
+	void setAlwaysUpdate(bool b = true) {
+		_bAlwaysUpdate = (byte)b;
+	}
+
+	bool isNoMenu() {
+		return _bNoMenu;
+	}
+
+	void setNoMenu(bool b = true) {
+		_bNoMenu = (byte)b;
+	}
+
+	virtual CBofPoint getPosition();
+	virtual int getRefId();
+	virtual int getOverCursor();
+	virtual int getState();
+	virtual CBofRect getRect();
+	virtual const CBofString &getFileName();
+	CBagMenu *getMenuPtr();
+	virtual const CBofString &getRefName();
+	virtual void setRefName(const CBofString &s);
+	virtual void setFileName(const CBofString &s);
+	virtual void setSize(const CBofSize &) {
+	}
+	virtual void setRefId(int id);
+	virtual void setOverCursor(int curs);
+	virtual void setState(int state);
+	virtual void setMenuPtr(CBagMenu *pm);
+	virtual void setPosition(const CBofPoint &pos);
+
+	/**
+	 * Takes in info and then removes the relative information and returns
+	 * UNKNOWN_TOKEN    if nothing has changed
+	 * UPDATED_OBJECT   if something has changed
+	 * PARSING_DONE     if done processing
+	 */
+	ParseCodes setInfo(CBagIfstream &istr) override;
+
+	virtual ErrorCode update(CBofBitmap *pBmp, CBofPoint pt, CBofRect *pSrcRect = nullptr, int /*nMaskColor*/ = -1);
+	virtual bool onObjInteraction(CBagObject * /*pObj*/, CBagStorageDev * /*pSDev*/);
+	virtual void onLButtonDown(uint32 /*nFlags*/, CBofPoint */*xPoint*/, void * = nullptr) {
+	}
+	virtual void onLButtonUp(uint32 /*nFlags*/, CBofPoint */*xPoint*/, void * = nullptr); // run menu if available
+	virtual bool onMouseMove(uint32 /*nFlags*/, CBofPoint /*xPoint*/, void * = nullptr);
+	virtual bool onMouseOver(uint32 /*nFlags*/, CBofPoint /*xPoint*/, void * = nullptr);
+};
+
+inline void CBagObject::setFileName(const CBofString &s) {
+	_sFileName = s;
+}
+
+inline void CBagObject::setMenuPtr(CBagMenu *pm) {
+	_pMenu = pm;
+}
+
+} // namespace SpaceBar
+} // namespace Bagel
+
+#endif