Initial commit

backends/platform/psp/image_viewer.cpp

@@ -0,0 +1,320 @@
+/* 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/>.
+ *
+ */
+
+// Disable symbol overrides so that we can use system headers.
+#define FORBIDDEN_SYMBOL_ALLOW_ALL
+
+#include "common/scummsys.h"
+#include "common/str.h"
+#include "common/stream.h"
+#include "common/archive.h"
+#include "common/events.h"
+#include "common/ptr.h"
+#include "gui/message.h"
+#include "engines/engine.h"
+#include "backends/platform/psp/input.h"
+#include "backends/platform/psp/display_manager.h"
+#include "backends/platform/psp/display_client.h"
+#include "backends/platform/psp/image_viewer.h"
+#include "backends/platform/psp/png_loader.h"
+#include "backends/platform/psp/thread.h"
+
+static const char *imageName = "psp_image";
+#define PSP_SCREEN_HEIGHT 272
+#define PSP_SCREEN_WIDTH 480
+
+bool ImageViewer::load(int imageNum) {
+	if (_init)
+		unload();
+
+	// build string
+	Common::Path specificImageName(Common::String::format("%s%d.png",imageName, imageNum));
+
+	// search for image file
+	if (!SearchMan.hasFile(specificImageName)) {
+		PSP_ERROR("file %s not found\n", specificImageName.toString(Common::Path::kNativeSeparator).c_str());
+		return false;
+	}
+
+	Common::ScopedPtr<Common::SeekableReadStream> file(SearchMan.createReadStreamForMember(specificImageName));
+
+	_buffer = new Buffer();
+	_palette = new Palette();
+	_renderer = new GuRenderer();
+
+	assert(_buffer);
+	assert(_palette);
+	assert(_renderer);
+
+	// Load a PNG into our buffer and palette. Size it by the actual size of the image
+	PngLoader image(*file, *_buffer, *_palette, Buffer::kSizeBySourceSize);
+
+	PngLoader::Status status = image.allocate();	// allocate the buffers for the file
+
+	char error[100];
+	if (status == PngLoader::BAD_FILE) {
+		Common::sprintf_s(error, "Cannot display %s. Not a proper PNG file", specificImageName.toString(Common::Path::kNativeSeparator).c_str());
+		GUI::TimedMessageDialog dialog(Common::U32String(error), 4000);
+		dialog.runModal();
+		return false;
+	} else if (status == PngLoader::OUT_OF_MEMORY) {
+		Common::sprintf_s(error, "Out of memory loading %s. Try making the image smaller", specificImageName.toString(Common::Path::kNativeSeparator).c_str());
+		GUI::TimedMessageDialog dialog(Common::U32String(error), 4000);
+		dialog.runModal();
+		return false;
+	}
+	// try to load the image file
+	if (!image.load()) {
+		Common::sprintf_s(error, "Cannot display %s. Not a proper PNG file", specificImageName.toString(Common::Path::kNativeSeparator).c_str());
+		GUI::TimedMessageDialog dialog(Common::U32String(error), 4000);
+		dialog.runModal();
+		return false;
+	}
+
+	setConstantRendererOptions();
+	setFullScreenImageParams();		// prepare renderer for full screen view
+
+	_imageNum = imageNum;			// now we can say we displayed this image
+	_init = true;
+
+	return true;
+}
+
+void ImageViewer::setConstantRendererOptions() {
+	_renderer->setBuffer(_buffer);
+	_renderer->setPalette(_palette);
+
+	_renderer->setAlphaBlending(false);
+	_renderer->setColorTest(false);
+	_renderer->setUseGlobalScaler(false);
+	_renderer->setStretch(true);
+	_renderer->setOffsetInBuffer(0, 0);
+	_renderer->setDrawWholeBuffer();
+}
+
+void ImageViewer::unload() {
+	_init = false;
+	delete _buffer;
+	delete _palette;
+	delete _renderer;
+	_buffer = 0;
+	_palette = 0;
+	_renderer = 0;
+}
+
+void ImageViewer::resetOnEngineDone() {
+	_imageNum = 0;
+}
+
+void ImageViewer::setVisible(bool visible) {
+	DEBUG_ENTER_FUNC();
+
+	if (_visible == visible)
+		return;
+
+	// from here on, we're making the loader visible
+	if (visible && g_engine) {	// we can only run the image viewer when there's an engine
+		_pauseToken = g_engine->pauseEngine();
+
+		load(_imageNum ? _imageNum : 1); 	// load the 1st image or the current
+	}
+
+	if (visible && _init) {	// we managed to load
+		_visible = true;
+		setViewerButtons(true);
+
+		{ // so dialog goes out of scope, destroying all allocations
+			GUI::TimedMessageDialog dialog(Common::U32String("Image Viewer"), 1000);
+			dialog.runModal();
+		}
+
+		runLoop();	// only listen to viewer events
+	} else {	// we were asked to make invisible or failed to load
+		_visible = false;
+		unload();
+		setViewerButtons(false);
+
+		if (g_engine && g_engine->isPaused())
+			_pauseToken.clear();
+	}
+	setDirty();
+}
+
+// This is the only way we can truly pause the games
+// Sad but true.
+void ImageViewer::runLoop() {
+	while (_visible) {
+		Common::Event event;
+		PspThread::delayMillis(30);
+		_inputHandler->getAllInputs(event);
+		_displayManager->renderAll();
+	}
+}
+
+void ImageViewer::setViewerButtons(bool active) {
+	_inputHandler->setImageViewerMode(active);
+}
+
+void ImageViewer::loadNextImage() {
+	if (!load(_imageNum+1)) {		// try to load the next image
+		if (!load(_imageNum))		// we failed, so reload the current image
+			setVisible(false);		// just hide
+	}
+	setDirty();
+}
+
+void ImageViewer::loadLastImage() {
+	if (_imageNum - 1 > 0) {
+		if (!load(_imageNum-1))
+			if (!load(_imageNum))
+				setVisible(false);	// we can't even show the old image so hide
+	}
+	setDirty();
+}
+
+void ImageViewer::setFullScreenImageParams() {
+	// we try to fit the image fullscreen at least in one dimension
+	uint32 width = _buffer->getSourceWidth();
+	uint32 height = _buffer->getSourceHeight();
+
+	_centerX = PSP_SCREEN_WIDTH / 2.0f;
+	_centerY = PSP_SCREEN_HEIGHT / 2.0f;
+
+	// see if we fit width wise
+	if (PSP_SCREEN_HEIGHT >= (int)((height * PSP_SCREEN_WIDTH) / (float)width)) {
+		setZoom(PSP_SCREEN_WIDTH / (float)width);
+	} else {
+		setZoom(PSP_SCREEN_HEIGHT / (float)height);
+	}
+}
+
+void ImageViewer::render() {
+	if (_init) {
+		assert(_buffer);
+		assert(_renderer);
+
+		// move the image slightly. Note that we count on the renderer's timing
+		switch (_movement) {
+		case EVENT_MOVE_LEFT:
+			moveImageX(-_visibleWidth / 100.0f);
+			break;
+		case EVENT_MOVE_UP:
+			moveImageY(-_visibleHeight / 100.0f);
+			break;
+		case EVENT_MOVE_RIGHT:
+			moveImageX(_visibleWidth / 100.0f);
+			break;
+		case EVENT_MOVE_DOWN:
+			moveImageY(_visibleHeight / 100.0f);
+			break;
+		default:
+			break;
+		}
+		_renderer->render();
+	}
+}
+
+void ImageViewer::modifyZoom(bool up) {
+	float factor = _zoomFactor;
+	if (up)
+		factor += 0.1f;
+	else // down
+		factor -= 0.1f;
+
+	setZoom(factor);
+}
+
+void ImageViewer::setZoom(float value) {
+	if (value <= 0.0f)		// don't want 0 or negative zoom
+		return;
+
+	_zoomFactor = value;
+	_renderer->setStretchXY(value, value);
+	setOffsetParams();
+}
+
+void ImageViewer::moveImageX(float val) {
+	float newVal = _centerX + val;
+
+	if (newVal - (_visibleWidth / 2) > PSP_SCREEN_WIDTH - 4 || newVal + (_visibleWidth / 2) < 4)
+		return;
+	_centerX = newVal;
+	setOffsetParams();
+}
+
+void ImageViewer::moveImageY(float val) {
+	float newVal = _centerY + val;
+
+	if (newVal - (_visibleHeight / 2) > PSP_SCREEN_HEIGHT - 4 || newVal + (_visibleHeight / 2) < 4)
+		return;
+	_centerY = newVal;
+	setOffsetParams();
+}
+
+//	Set the renderer with the proper offset on the screen
+//
+void ImageViewer::setOffsetParams() {
+	_visibleWidth = _zoomFactor * _buffer->getSourceWidth();
+	_visibleHeight = _zoomFactor * _buffer->getSourceHeight();
+
+	int offsetX = _centerX - (int)(_visibleWidth * 0.5f);
+	int offsetY = _centerY - (int)(_visibleHeight * 0.5f);
+
+	_renderer->setOffsetOnScreen(offsetX, offsetY);
+	setDirty();
+}
+
+//	Handler events coming in from the inputHandler
+//
+void ImageViewer::handleEvent(uint32 event) {
+	DEBUG_ENTER_FUNC();
+
+	switch (event) {
+	case EVENT_HIDE:
+		setVisible(false);
+		break;
+	case EVENT_SHOW:
+		setVisible(true);
+		break;
+	case EVENT_ZOOM_IN:
+		modifyZoom(true);
+		break;
+	case EVENT_ZOOM_OUT:
+		modifyZoom(false);
+		break;
+	case EVENT_MOVE_LEFT:
+	case EVENT_MOVE_UP:
+	case EVENT_MOVE_RIGHT:
+	case EVENT_MOVE_DOWN:
+	case EVENT_MOVE_STOP:
+		_movement = (Event)event;
+		break;
+	case EVENT_NEXT_IMAGE:
+		loadNextImage();
+		break;
+	case EVENT_LAST_IMAGE:
+		loadLastImage();
+		break;
+	default:
+		PSP_ERROR("Unknown event %d\n", event);
+		break;
+	}
+}