scummvm-cursorfix/engines/agds/screen.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 SCREEN_H
#define SCREEN_H

#include "agds/screenLoadingType.h"
#include "common/array.h"
#include "common/ptr.h"
#include "common/rect.h"
#include "common/scummsys.h"
#include "common/str.h"

namespace Graphics {
struct Surface;
}

namespace AGDS {

class AGDSEngine;
class Animation;
using AnimationPtr = Common::SharedPtr<Animation>;
class Object;
using ObjectPtr = Common::SharedPtr<Object>;
struct Region;
using RegionPtr = Common::SharedPtr<Region>;
struct Patch;
using PatchPtr = Common::SharedPtr<Patch>;

struct ScreenAnimationDesc {
	AnimationPtr animation;
	bool removed = false;
	ScreenAnimationDesc(const AnimationPtr &a) : animation(a) {
	}
};

class Screen {
	static int ObjectZCompare(const ObjectPtr &a, const ObjectPtr &b);
	static int AnimationZCompare(const ScreenAnimationDesc &a, const ScreenAnimationDesc &b);

	using Animations = Common::SortedArray<ScreenAnimationDesc, const ScreenAnimationDesc &>;
	using Children = Common::SortedArray<ObjectPtr, const ObjectPtr &>;

	AGDSEngine *_engine;
	ObjectPtr _object;
	Object *_background;
	Common::Point _scroll;
	Common::String _name;
	ScreenLoadingType _loadingType;
	Common::String _previousScreen;
	Children _children;
	Animations _animations;
	RegionPtr _region;
	bool _applyingPatch;
	int _characterNear, _characterFar;
	int _fade;

public:
	struct KeyHandler {
		ObjectPtr object;
		uint ip;

		KeyHandler() : object(), ip() {}
		KeyHandler(Object *o, uint i) : object(o), ip(i) {}
	};

	Screen(AGDSEngine *engine, ObjectPtr object, ScreenLoadingType loadingType, const Common::String &prevScreen);
	~Screen();

	int fade() const {
		return _fade;
	}

	void fade(int fade) {
		_fade = fade;
	}

	void setCharacterNearFar(int near, int far) {
		_characterNear = near;
		_characterFar = far;
	}

	float getZScale(int y) const;

	bool applyingPatch() const {
		return _applyingPatch;
	}

	ObjectPtr getObject() {
		return _object;
	}

	const Common::String &getName() const {
		return _name;
	}

	const Common::String &getPreviousScreenName() const {
		return _previousScreen;
	}

	ScreenLoadingType loadingType() const {
		return _loadingType;
	}

	const RegionPtr &region() const {
		return _region;
	}

	void region(RegionPtr region) {
		_region = region;
	}

	const Children &children() const {
		return _children;
	}

	const Animations &animations() const {
		return _animations;
	}
	void scrollTo(Common::Point scroll);
	Common::Point scrollPosition() const {
		return _scroll;
	}

	bool add(ObjectPtr object);
	void add(AnimationPtr animation);
	bool remove(const AnimationPtr &animation);

	void update(const ObjectPtr &object) {
		bool found = remove(object);
		if (found)
			add(object);
	}

	void setBackground(Object *object) {
		_background = object;
	}

	bool remove(const Common::String &name);
	bool remove(const ObjectPtr &object);

	void tick();
	void paint(Graphics::Surface &backbuffer) const;
	Common::Array<ObjectPtr> find(Common::Point pos) const;
	ObjectPtr find(const Common::String &name);
	KeyHandler findKeyHandler(const Common::String &keyName);
	AnimationPtr findAnimationByPhaseVar(const Common::String &phaseVar);

	void load(const PatchPtr &patch);
	void save(const PatchPtr &patch);
};

} // End of namespace AGDS

#endif /* AGDS_SCREEN_H */