thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ALL: Remove Tizen port

Browse source
This commit is contained in:
Eugene Sandulenko 2020-08-01 14:42:45 +02:00
parent 4c60037235
commit 432383a667
28 changed files with 12 additions and 3366 deletions
Download patch file Download diff file Expand all files Collapse all files

5
Makefile
View file

@ -32,11 +32,8 @@ ifeq "$(HAVE_GCC)" "1"
# being helpful.
#CXXFLAGS+= -Wmissing-format-attribute
ifneq "$(BACKEND)" "tizen"
# Disable exceptions. This setting causes tizen apps to crash
# TODO: Does this still apply after enabling RTTI again?
# Disable exceptions.
CXXFLAGS+= -fno-exceptions
endif
ifneq "$(HAVE_CLANG)" "1"
# enable checking of pointers returned by "new", but only when we do not

9
README.md
View file

@ -2760,8 +2760,8 @@ Lands of Lore: The Throne of Chaos adds the following non-standard keywords:
Maniac Mansion NES adds the following non-standard keyword:
mm_nes_classic_palette bool If true, use a more natural palette that
closely resembles the Nintendo NES Classic
mm_nes_classic_palette bool If true, use a more natural palette that
closely resembles the Nintendo NES Classic
instead of the default NTSC palette
Space Quest IV CD adds the following non-standard keyword:
@ -2930,11 +2930,6 @@ debug messages (see
- Please refer to:
<https://wiki.scummvm.org/index.php/Compiling_ScummVM/Atari/FreeMiNT>
- Bada/Tizen:
- Please refer to:
<https://wiki.scummvm.org/index.php/Compiling_ScummVM/Bada/Tizen>
- BeOS/ZETA/Haiku:
- Please refer to:

13
backends/graphics/opengl/opengl-sys.h
View file

@ -58,18 +58,7 @@
#define USE_FORCED_GLES2 0
#endif
// On Tizen we include the toolchain's OpenGL file. This is something we
// actually want to avoid. However, since Tizen uses eglGetProcAddress which
// is not required to return valid function pointers to non OpenGL extension
// functions, we need the system's definitions to resolve all OpenGL
// functions.
// TODO: See if there is an alternative which allows us to avoid including
// Tizen's OpenGL header here.
#if defined(TIZEN)
#include <FGraphicsOpengl.h>
using namespace Tizen::Graphics::Opengl;
#define USE_BUILTIN_OPENGL
#elif defined(__ANDROID__)
#ifdef __ANDROID__
#include <GLES/gl.h>
#define USE_BUILTIN_OPENGL
#else

5
backends/module.mk
View file

@ -256,11 +256,6 @@ MODULE_OBJS += \
audiocd/linux/linux-audiocd.o
endif
ifeq ($(BACKEND),tizen)
MODULE_OBJS += \
timer/tizen/timer.o
endif
ifeq ($(BACKEND),3ds)
MODULE_OBJS += \
plugins/3ds/3ds-provider.o

108
backends/platform/tizen/README.TXT
View file

@ -1,108 +0,0 @@
Build instructions (using linux)
1. Install the Tizen SDK
http://www.tizen.org
To use an alternative Java SDK to run the Tizen IDE (eclipse), edit ~/.profile
export JAVA_HOME=/opt/jdk1.6.0_45
export PATH=${PATH}:${JAVA_HOME}/bin
2. Add the following to your ~/.bashrc file
export TIZEN_SDK=${HOME}/tizen-sdk
export TIZEN_ROOTSTRAP=${TIZEN_SDK}/platforms/tizen2.1/rootstraps/tizen-device-2.1.native
export TIZEN_BIN=${TIZEN_SDK}/tools/arm-linux-gnueabi-gcc-4.5/bin
export TIZEN_LIBS=${HOME}/tizen-lib
export PATH=${PATH}:${TIZEN_BIN}:~/bin
export CHOST=arm-linux-gnueabi
export LDFLAGS="--sysroot=${TIZEN_ROOTSTRAP} -L${TIZEN_LIBS}/lib"
export CPPFLAGS="--sysroot=${TIZEN_ROOTSTRAP} -fmessage-length=0 -fPIC\
-I${TIZEN_ROOTSTRAP}/usr/include -I${TIZEN_LIBS}/include"
export CFLAGS=${CPPFLAGS}
3. Build dependencies
See: "Building the libraries" under:
https://wiki.scummvm.org/index.php/Compiling_ScummVM/MinGW#Building_the_libraries
for instructions on how to obtain these modules
3.1 zlib
$ ./configure --static --prefix=${TIZEN_LIBS}
$ make && make install
3.2 freetype, libtheora, libogg, libvorbis, libmad, FLAC
$ ./configure --host=arm-linux-gnueabi --prefix=${TIZEN_LIBS} --disable-shared
$ make && make install
Note: you can ignore the ranlib errors when doing make install.
Modify the resulting ~/tizen-lib/bin/freetype-config file to include -lz when printing libs
3.3 Linker ordering: scummvm, freetype, theoradec, vorbis, vorbisfile, mad, FLAC, ogg, z
4. Build the ScummVM base library:
./configure --host=tizen --enable-release --with-freetype2-prefix=${TIZEN_LIBS}/bin
For development:
./configure --host=tizen --enable-verbose-build --enable-debug
5. Build the front end application using Tizen IDE
Copy the scummvm/dists/bada folder into a clean directory
outside of the scummvm package. Start the BADA IDE then
choose this folder as the eclipse workspace. Click
Project / Build.
Links:
A short turorial on implementing OpenGL ES 1.1 in BADA:
http://forums.badadev.com/viewtopic.php?f=7&t=208
HelvB14 font files:
http://www.cl.cam.ac.uk/~mgk25/ucs-fonts.html
http://www.cl.cam.ac.uk/~mgk25/download/ucs-fonts-75dpi100dpi.tar.gz
Then run the following command:
$ ./ucs2any.pl 100dpi/helvB14.bdf MAPPINGS/8859-1.TXT iso8859-1 \
MAPPINGS/8859-2.TXT iso8859-2 MAPPINGS/8859-3.TXT iso8859-3
=====================================================================
Archived build instruction for BADA/cygwin
1. Install BADA SDK (requires free registration):
http://developer.bada.com/apis/index.do
2. Install Cygwin:
http://www.cygwin.com/
Add the following to your cygwin .bash_profile:
alias mmake=/cygdrive/c/MinGW/bin/mingw32-make.exe
export BADA_SDK=/cygdrive/c/bada/1.2.1
export ARM_BIN=c:/bada/1.2.1/Tools/Toolchains/ARM/bin
export CPPFLAGS="-fpic -fshort-wchar -mcpu=cortex-a8 -mfpu=vfpv3 \
-mfloat-abi=hard -mlittle-endian -mthumb-interwork -Wno-psabi \
-fno-strict-aliasing -fno-short-enums"
export LDFLAGS="-nostdlib -lc-newlib -lm-newlib -LC:/bada/1.2.1/Model/Wave_LP1/Target"
#export PATH=${BADA_SDK}/Tools/Toolchains/Win32/bin:${PATH}
export PATH=${BADA_SDK}/Tools/Toolchains/ARM/bin:~/utils:${PATH}
alias gcc=${ARM_BIN}/arm-samsung-nucleuseabi-gcc.exe
alias ar=${ARM_BIN}/arm-samsung-nucleuseabi-ar.exe
The following were added to ~/utils for zlib:
ar:
#!/bin/sh
${ARM_BIN}/arm-samsung-nucleuseabi-ar.exe $*
gcc:
#!/bin/sh
${ARM_BIN}/arm-samsung-nucleuseabi-gcc.exe $*

144
backends/platform/tizen/application.cpp
View file

@ -1,144 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#include "engines/engine.h"
#include "backends/platform/tizen/form.h"
#include "backends/platform/tizen/system.h"
#include "backends/platform/tizen/application.h"
Application *TizenScummVM::createInstance() {
logEntered();
return new TizenScummVM();
}
TizenScummVM::TizenScummVM() : _appForm(NULL) {
logEntered();
}
TizenScummVM::~TizenScummVM() {
logEntered();
if (g_system) {
TizenSystem *system = (TizenSystem *)g_system;
system->destroyBackend();
delete system;
g_system = NULL;
}
}
bool TizenScummVM::OnAppInitialized(void) {
logEntered();
_appForm->SetOrientation(Tizen::Ui::ORIENTATION_LANDSCAPE);
return true;
}
bool TizenScummVM::OnAppWillTerminate(void) {
logEntered();
return true;
}
bool TizenScummVM::OnAppInitializing(AppRegistry &appRegistry) {
logEntered();
_appForm = systemStart(this);
return (_appForm != NULL);
}
bool TizenScummVM::OnAppTerminating(AppRegistry &appRegistry, bool forcedTermination) {
logEntered();
return true;
}
void TizenScummVM::OnUserEventReceivedN(RequestId requestId, IList *args) {
logEntered();
MessageBox messageBox;
int modalResult;
String *message;
switch (requestId) {
case USER_MESSAGE_EXIT:
// normal program termination
Terminate();
break;
case USER_MESSAGE_EXIT_ERR:
// assertion failure termination
if (args) {
message = (String *)args->GetAt(0);
}
if (!message) {
message = new String("Unknown error");
}
messageBox.Construct(L"Oops...", *message, MSGBOX_STYLE_OK);
messageBox.ShowAndWait(modalResult);
Terminate();
break;
case USER_MESSAGE_EXIT_ERR_CONFIG:
// the config file was corrupted
messageBox.Construct(L"Config file corrupted",
L"Settings have been reverted, please restart.", MSGBOX_STYLE_OK);
messageBox.ShowAndWait(modalResult);
Terminate();
break;
}
}
void TizenScummVM::OnForeground(void) {
logEntered();
pauseGame(false);
}
void TizenScummVM::OnBackground(void) {
logEntered();
pauseGame(true);
}
void TizenScummVM::OnBatteryLevelChanged(BatteryLevel batteryLevel) {
logEntered();
}
void TizenScummVM::OnLowMemory(void) {
logEntered();
}
void TizenScummVM::OnScreenOn(void) {
logEntered();
}
void TizenScummVM::OnScreenOff(void) {
logEntered();
}
void TizenScummVM::OnScreenBrightnessChanged(int brightness) {
logEntered();
}
void TizenScummVM::pauseGame(bool pause) {
if (_appForm) {
if (pause && g_engine && !g_engine->isPaused()) {
_appForm->pushKey(Common::KEYCODE_SPACE);
}
if (g_system) {
((TizenSystem *)g_system)->setMute(pause);
}
}
}

69
backends/platform/tizen/application.h
View file

@ -1,69 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#ifndef TIZEN_APPLICATION_H
#define TIZEN_APPLICATION_H
#include <FBase.h>
#include <FApp.h>
#include <FGraphics.h>
#include <FUi.h>
#include <FSystem.h>
#include "backends/platform/tizen/system.h"
#include "backends/platform/tizen/form.h"
using namespace Tizen::App;
using namespace Tizen::System;
using namespace Tizen::Ui;
using namespace Tizen::Ui::Controls;
using namespace Tizen::Base::Collection;
class TizenScummVM :
public UiApp,
public IScreenEventListener {
public:
TizenScummVM();
virtual ~TizenScummVM();
static UiApp *createInstance(void);
virtual bool OnAppInitializing(AppRegistry &appRegistry);
virtual bool OnAppInitialized(void);
virtual bool OnAppWillTerminate(void);
virtual bool OnAppTerminating(AppRegistry &appRegistry, bool forcedTermination = false);
virtual void OnLowMemory(void);
virtual void OnBatteryLevelChanged(BatteryLevel batteryLevel);
virtual void OnUserEventReceivedN(RequestId requestId, IList *pArgs);
virtual void OnForeground(void);
virtual void OnBackground(void);
virtual void OnScreenOn(void);
virtual void OnScreenOff(void);
virtual void OnScreenBrightnessChanged(int brightness);
private:
void pauseGame(bool pause);
TizenAppForm *_appForm;
};
#endif

197
backends/platform/tizen/audio.cpp
View file

@ -1,197 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#include <FSysSettingInfo.h>
#include <FAppAppRegistry.h>
#include "backends/platform/tizen/audio.h"
#include "backends/platform/tizen/system.h"
#define TIMER_INTERVAL 10
#define VOLUME 96
#define MIN_TIMER_INTERVAL 5
AudioThread::AudioThread() :
_mixer(0),
_timer(0),
_audioOut(0),
_head(0),
_tail(0),
_ready(0),
_interval(TIMER_INTERVAL),
_playing(-1),
_size(0),
_muted(true) {
}
Audio::MixerImpl *AudioThread::Construct() {
logEntered();
if (IsFailed(EventDrivenThread::Construct(DEFAULT_STACK_SIZE, THREAD_PRIORITY_HIGH))) {
AppLog("Failed to create AudioThread");
return NULL;
}
_mixer = new Audio::MixerImpl(44100);
return _mixer;
}
AudioThread::~AudioThread() {
logEntered();
}
bool AudioThread::isSilentMode() {
bool silentMode;
String key(L"SilentMode");
Tizen::System::SettingInfo::GetValue(key, silentMode);
return silentMode;
}
void AudioThread::setMute(bool on) {
if (_audioOut && _timer) {
_muted = on;
if (on) {
_timer->Cancel();
} else {
_timer->Start(_interval);
}
}
}
bool AudioThread::OnStart(void) {
logEntered();
_audioOut = new Tizen::Media::AudioOut();
if (!_audioOut || IsFailed(_audioOut->Construct(*this))) {
AppLog("Failed to create AudioOut");
return false;
}
int sampleRate = _mixer->getOutputRate();
// ideally we would update _mixer with GetOptimizedSampleRate here
if (_audioOut->GetOptimizedSampleRate() != sampleRate) {
AppLog("Non optimal sample rate %d", _audioOut->GetOptimizedSampleRate());
}
if (IsFailed(_audioOut->Prepare(AUDIO_TYPE_PCM_S16_LE,
AUDIO_CHANNEL_TYPE_STEREO, sampleRate))) {
AppLog("Failed to prepare AudioOut %d", sampleRate);
return false;
}
int bufferSize = _audioOut->GetMinBufferSize();
for (int i = 0; i < NUM_AUDIO_BUFFERS; i++) {
if (IsFailed(_audioBuffer[i].Construct(bufferSize))) {
AppLog("Failed to create audio buffer");
return false;
}
}
_size = _audioBuffer[0].GetCapacity();
_timer = new Timer();
if (!_timer || IsFailed(_timer->Construct(*this))) {
AppLog("Failed to create audio timer");
return false;
}
if (IsFailed(_timer->Start(_interval))) {
AppLog("failed to start audio timer");
return false;
}
_muted = false;
_mixer->setReady(true);
_audioOut->SetVolume(isSilentMode() ? 0 : VOLUME);
_audioOut->Start();
return true;
}
void AudioThread::OnStop(void) {
logEntered();
_mixer->setReady(false);
if (_timer) {
if (!_muted) {
_timer->Cancel();
}
delete _timer;
}
if (_audioOut) {
_audioOut->Reset();
_audioOut->Unprepare();
delete _audioOut;
}
}
void AudioThread::OnAudioOutErrorOccurred(Tizen::Media::AudioOut &src, result r) {
logEntered();
}
void AudioThread::OnAudioOutInterrupted(Tizen::Media::AudioOut &src) {
logEntered();
}
void AudioThread::OnAudioOutReleased(Tizen::Media::AudioOut &src) {
logEntered();
_audioOut->Start();
}
void AudioThread::OnAudioOutBufferEndReached(Tizen::Media::AudioOut &src) {
if (_ready > 0) {
_playing = _tail;
_audioOut->WriteBuffer(_audioBuffer[_tail]);
_tail = (_tail + 1) % NUM_AUDIO_BUFFERS;
_ready--;
} else {
// audio buffer empty: decrease timer interval
_playing = -1;
_interval -= 1;
if (_interval < MIN_TIMER_INTERVAL) {
_interval = MIN_TIMER_INTERVAL;
}
}
}
void AudioThread::OnTimerExpired(Timer &timer) {
if (_ready < NUM_AUDIO_BUFFERS) {
if (_playing != _head) {
if (_mixer->mixCallback((byte *)_audioBuffer[_head].GetPointer(), _size)) {
_head = (_head + 1) % NUM_AUDIO_BUFFERS;
_ready++;
}
}
} else {
// audio buffer full: restore timer interval
_interval = TIMER_INTERVAL;
}
if (_ready && _playing == -1) {
OnAudioOutBufferEndReached(*_audioOut);
}
_timer->Start(_interval);
}

74
backends/platform/tizen/audio.h
View file

@ -1,74 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#ifndef TIZEN_AUDIO_H
#define TIZEN_AUDIO_H
#include <FBase.h>
#include <FMedia.h>
#include <FIo.h>
#include <FBaseByteBuffer.h>
#include "config.h"
#include "common/scummsys.h"
#include "common/system.h"
#include "audio/mixer_intern.h"
using namespace Tizen::Base;
using namespace Tizen::Base::Collection;
using namespace Tizen::Base::Runtime;
using namespace Tizen::Media;
using namespace Tizen::Io;
#define NUM_AUDIO_BUFFERS 2
class AudioThread:
public Tizen::Media::IAudioOutEventListener,
public Tizen::Base::Runtime::ITimerEventListener,
public Tizen::Base::Runtime::EventDrivenThread {
public:
AudioThread(void);
~AudioThread(void);
Audio::MixerImpl *Construct();
bool isSilentMode();
void setMute(bool on);
private:
bool OnStart(void);
void OnStop(void);
void OnAudioOutErrorOccurred(Tizen::Media::AudioOut &src, result r);
void OnAudioOutInterrupted(Tizen::Media::AudioOut &src);
void OnAudioOutReleased(Tizen::Media::AudioOut &src);
void OnAudioOutBufferEndReached(Tizen::Media::AudioOut &src);
void OnTimerExpired(Timer &timer);
Audio::MixerImpl *_mixer;
Tizen::Base::Runtime::Timer *_timer;
Tizen::Media::AudioOut *_audioOut;
Tizen::Base::ByteBuffer _audioBuffer[NUM_AUDIO_BUFFERS];
int _head, _tail, _ready, _interval, _playing, _size;
bool _muted;
};
#endif

438
backends/platform/tizen/form.cpp
View file

@ -1,438 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#include <FApp.h>
#include <FSysSystemTime.h>
#include "common/translation.h"
#include "base/main.h"
#include "backends/platform/tizen/form.h"
#include "backends/platform/tizen/system.h"
using namespace Tizen::Base::Collection;
using namespace Tizen::Base::Runtime;
using namespace Tizen::Ui::Controls;
// round down small Y touch values to 1 to allow the
// cursor to be positioned at the top of the screen
#define MIN_TOUCH_Y 20
// block for up to 2.5 seconds during shutdown to
// allow the game thread to exit gracefully.
#define EXIT_SLEEP_STEP 10
#define EXIT_SLEEP 250
//
// TizenAppForm
//
TizenAppForm::TizenAppForm() :
_gestureMode(false),
_osdMessage(NULL),
_gameThread(NULL),
_eventQueueLock(NULL),
_state(kInitState),
_buttonState(kLeftButton),
_shortcut(kEscapeKey) {
}
result TizenAppForm::Construct() {
TizenSystem *tizenSystem = NULL;
result r = Form::Construct(FORM_STYLE_NORMAL);
if (!IsFailed(r)) {
tizenSystem = new TizenSystem(this);
r = tizenSystem != NULL ? E_SUCCESS : E_OUT_OF_MEMORY;
}
if (!IsFailed(r)) {
r = tizenSystem->Construct();
}
if (!IsFailed(r)) {
_gameThread = new Thread();
r = _gameThread != NULL ? E_SUCCESS : E_OUT_OF_MEMORY;
}
if (!IsFailed(r)) {
r = _gameThread->Construct(*this);
}
if (!IsFailed(r)) {
_eventQueueLock = new Mutex();
r = _eventQueueLock != NULL ? E_SUCCESS : E_OUT_OF_MEMORY;
}
if (!IsFailed(r)) {
r = _eventQueueLock->Create();
}
if (!IsFailed(r)) {
g_system = tizenSystem;
} else {
AppLog("Form startup failed");
delete tizenSystem;
delete _gameThread;
_gameThread = NULL;
}
return r;
}
TizenAppForm::~TizenAppForm() {
logEntered();
if (_gameThread && _state != kErrorState) {
terminate();
_gameThread->Stop();
if (_state != kErrorState) {
_gameThread->Join();
}
delete _gameThread;
_gameThread = NULL;
}
delete _eventQueueLock;
_eventQueueLock = NULL;
logLeaving();
}
//
// abort the game thread
//
void TizenAppForm::terminate() {
if (_state == kActiveState) {
((TizenSystem *)g_system)->setMute(true);
_eventQueueLock->Acquire();
Common::Event e;
e.type = Common::EVENT_QUIT;
_eventQueue.push(e);
_state = kClosingState;
_eventQueueLock->Release();
// block while thread ends
AppLog("waiting for shutdown");
for (int i = 0; i < EXIT_SLEEP_STEP && _state == kClosingState; i++) {
Thread::Sleep(EXIT_SLEEP);
}
if (_state == kClosingState) {
// failed to terminate - Join() will freeze
_state = kErrorState;
}
}
}
void TizenAppForm::exitSystem() {
_state = kErrorState;
if (_gameThread) {
_gameThread->Stop();
delete _gameThread;
_gameThread = NULL;
}
}
result TizenAppForm::OnInitializing(void) {
logEntered();
AddOrientationEventListener(*this);
AddTouchEventListener(*this);
SetMultipointTouchEnabled(true);
SetFormBackEventListener(this);
SetFormMenuEventListener(this);
// set focus to enable receiving key events
SetEnabled(true);
SetFocusable(true);
SetFocus();
return E_SUCCESS;
}
result TizenAppForm::OnDraw(void) {
logEntered();
return E_SUCCESS;
}
void TizenAppForm::OnOrientationChanged(const Control &source, OrientationStatus orientationStatus) {
logEntered();
if (_state == kInitState) {
_state = kActiveState;
_gameThread->Start();
}
}
Tizen::Base::Object *TizenAppForm::Run() {
logEntered();
scummvm_main(0, 0);
if (_state == kActiveState) {
Tizen::App::Application::GetInstance()->SendUserEvent(USER_MESSAGE_EXIT, NULL);
}
_state = kDoneState;
return NULL;
}
bool TizenAppForm::pollEvent(Common::Event &event) {
bool result = false;
_eventQueueLock->Acquire();
if (!_eventQueue.empty()) {
event = _eventQueue.pop();
result = true;
}
if (_osdMessage) {
TizenSystem *system = (TizenSystem *)g_system;
TizenGraphicsManager *graphics = system->getGraphics();
if (graphics) {
graphics->displayMessageOnOSD(_osdMessage);
_osdMessage = NULL;
}
}
_eventQueueLock->Release();
return result;
}
void TizenAppForm::pushEvent(Common::EventType type, const Point &currentPosition) {
TizenSystem *system = (TizenSystem *)g_system;
TizenGraphicsManager *graphics = system->getGraphics();
if (graphics) {
// graphics could be NULL at startup or when
// displaying the system error screen
Common::Event e;
e.type = type;
e.mouse.x = currentPosition.x;
e.mouse.y = currentPosition.y > MIN_TOUCH_Y ? currentPosition.y : 1;
bool moved = graphics->moveMouse(e.mouse.x, e.mouse.y);
_eventQueueLock->Acquire();
if (moved && type != Common::EVENT_MOUSEMOVE) {
Common::Event moveEvent;
moveEvent.type = Common::EVENT_MOUSEMOVE;
moveEvent.mouse = e.mouse;
_eventQueue.push(moveEvent);
}
_eventQueue.push(e);
_eventQueueLock->Release();
}
}
void TizenAppForm::pushKey(Common::KeyCode keycode) {
if (_eventQueueLock) {
Common::Event e;
e.kbd.keycode = keycode;
e.kbd.ascii = keycode;
e.kbd.flags = 0;
_eventQueueLock->Acquire();
e.type = Common::EVENT_KEYDOWN;
_eventQueue.push(e);
e.type = Common::EVENT_KEYUP;
_eventQueue.push(e);
_eventQueueLock->Release();
}
}
void TizenAppForm::setButtonShortcut() {
switch (_buttonState) {
case kLeftButton:
setMessage(_s("Right Click Once"));
_buttonState = kRightButtonOnce;
break;
case kRightButtonOnce:
setMessage(_s("Right Click"));
_buttonState = kRightButton;
break;
case kRightButton:
setMessage(_s("Move Only"));
_buttonState = kMoveOnly;
break;
case kMoveOnly:
setMessage(_s("Left Click"));
_buttonState = kLeftButton;
break;
}
}
void TizenAppForm::setMessage(const char *message) {
if (_eventQueueLock) {
_eventQueueLock->Acquire();
_osdMessage = message;
_eventQueueLock->Release();
}
}
void TizenAppForm::setShortcut() {
logEntered();
// cycle to the next shortcut
switch (_shortcut) {
case kControlMouse:
setMessage(_s("Escape Key"));
_shortcut = kEscapeKey;
break;
case kEscapeKey:
setMessage(_s("Game Menu"));
_shortcut = kGameMenu;
break;
case kGameMenu:
setMessage(_s("Show Keypad"));
_shortcut = kShowKeypad;
break;
case kShowKeypad:
setMessage(_s("Control Mouse"));
_shortcut = kControlMouse;
break;
}
}
void TizenAppForm::invokeShortcut() {
logEntered();
switch (_shortcut) {
case kControlMouse:
setButtonShortcut();
break;
case kEscapeKey:
pushKey(Common::KEYCODE_ESCAPE);
break;
case kGameMenu:
_buttonState = kLeftButton;
pushKey(Common::KEYCODE_F5);
break;
case kShowKeypad:
showKeypad();
break;
}
}
void TizenAppForm::showKeypad() {
// display the soft keyboard
if (_state == kActiveState) {
_buttonState = kLeftButton;
Common::Event e;
e.type = Common::EVENT_VIRTUAL_KEYBOARD;
if (_eventQueueLock) {
_eventQueueLock->Acquire();
_eventQueue.push(e);
_eventQueueLock->Release();
}
}
}
int TizenAppForm::getTouchCount() {
Tizen::Ui::TouchEventManager *touch = Tizen::Ui::TouchEventManager::GetInstance();
IListT<TouchEventInfo *> *touchList = touch->GetTouchInfoListN();
int touchCount = touchList->GetCount();
touchList->RemoveAll();
delete touchList;
return touchCount;
}
void TizenAppForm::OnTouchDoublePressed(const Control &source,
const Point &currentPosition, const TouchEventInfo &touchInfo) {
if (_buttonState != kMoveOnly) {
pushEvent(_buttonState == kLeftButton ? Common::EVENT_LBUTTONDOWN : Common::EVENT_RBUTTONDOWN,
currentPosition);
}
}
void TizenAppForm::OnTouchFocusIn(const Control &source,
const Point &currentPosition, const TouchEventInfo &touchInfo) {
}
void TizenAppForm::OnTouchFocusOut(const Control &source,
const Point &currentPosition, const TouchEventInfo &touchInfo) {
}
void TizenAppForm::OnTouchLongPressed(const Control &source,
const Point &currentPosition, const TouchEventInfo &touchInfo) {
logEntered();
if (_buttonState != kLeftButton) {
pushKey(Common::KEYCODE_RETURN);
}
}
void TizenAppForm::OnTouchMoved(const Control &source,
const Point &currentPosition, const TouchEventInfo &touchInfo) {
if (!_gestureMode) {
pushEvent(Common::EVENT_MOUSEMOVE, currentPosition);
}
}
void TizenAppForm::OnTouchPressed(const Control &source,
const Point &currentPosition, const TouchEventInfo &touchInfo) {
if (getTouchCount() > 1) {
_gestureMode = true;
} else if (_buttonState != kMoveOnly) {
pushEvent(_buttonState == kLeftButton ? Common::EVENT_LBUTTONDOWN : Common::EVENT_RBUTTONDOWN,
currentPosition);
}
}
void TizenAppForm::OnTouchReleased(const Control &source,
const Point &currentPosition, const TouchEventInfo &touchInfo) {
if (_gestureMode) {
int touchCount = getTouchCount();
if (touchCount == 1) {
setShortcut();
} else {
if (touchCount == 2) {
invokeShortcut();
}
_gestureMode = false;
}
} else if (_buttonState != kMoveOnly) {
pushEvent(_buttonState == kLeftButton ? Common::EVENT_LBUTTONUP : Common::EVENT_RBUTTONUP,
currentPosition);
if (_buttonState == kRightButtonOnce) {
_buttonState = kLeftButton;
}
// flick to skip dialog
if (touchInfo.IsFlicked()) {
pushKey(Common::KEYCODE_PERIOD);
}
}
}
void TizenAppForm::OnFormBackRequested(Form &source) {
logEntered();
if (_state == kActiveState) {
invokeShortcut();
}
}
void TizenAppForm::OnFormMenuRequested(Form &source) {
logEntered();
if (_state == kActiveState) {
setShortcut();
}
}

120
backends/platform/tizen/form.h
View file

@ -1,120 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#ifndef TIZEN_FORM_H
#define TIZEN_FORM_H
#include <FApp.h>
#include <FUi.h>
#include <FSystem.h>
#include <FBase.h>
#include <FUiITouchEventListener.h>
#include <FUiITextEventListener.h>
#include <FUiCtrlIFormBackEventListener.h>
#include <FUiCtrlIFormMenuEventListener.h>
#include "config.h"
#include "common/scummsys.h"
#include "common/events.h"
#include "common/queue.h"
#include "common/mutex.h"
#include "engines/engine.h"
using namespace Tizen::Ui;
using namespace Tizen::Graphics;
using namespace Tizen::Base::Runtime;
using namespace Tizen::Ui::Controls;
//
// TizenAppForm
//
class TizenAppForm :
public Controls::Form,
public IRunnable,
public IOrientationEventListener,
public ITouchEventListener,
public IFormBackEventListener,
public IFormMenuEventListener {
public:
TizenAppForm();
virtual ~TizenAppForm();
result Construct();
bool pollEvent(Common::Event &event);
bool isClosing() { return _state == kClosingState; }
bool isStarting() { return _state == kInitState; }
void pushKey(Common::KeyCode keycode);
void exitSystem();
void showKeypad();
private:
Tizen::Base::Object *Run();
result OnInitializing(void);
result OnDraw(void);
void OnOrientationChanged(const Control &source,
OrientationStatus orientationStatus);
void OnTouchDoublePressed(const Control &source,
const Point &currentPosition,
const TouchEventInfo &touchInfo);
void OnTouchFocusIn(const Control &source,
const Point &currentPosition,
const TouchEventInfo &touchInfo);
void OnTouchFocusOut(const Control &source,
const Point &currentPosition,
const TouchEventInfo &touchInfo);
void OnTouchLongPressed(const Control &source,
const Point &currentPosition,
const TouchEventInfo &touchInfo);
void OnTouchMoved(const Control &source,
const Point &currentPosition,
const TouchEventInfo &touchInfo);
void OnTouchPressed(const Control &source,
const Point &currentPosition,
const TouchEventInfo &touchInfo);
void OnTouchReleased(const Control &source,
const Point &currentPosition,
const TouchEventInfo &touchInfo);
void OnFormBackRequested(Form &source);
void OnFormMenuRequested(Form &source);
void pushEvent(Common::EventType type, const Point &currentPosition);
void terminate();
void setButtonShortcut();
void setMessage(const char *message);
void setShortcut();
void invokeShortcut();
int getTouchCount();
bool gameActive() { return _state == kActiveState && g_engine != NULL && !g_engine->isPaused(); }
// event handling
bool _gestureMode;
const char *_osdMessage;
Tizen::Base::Runtime::Thread *_gameThread;
Tizen::Base::Runtime::Mutex *_eventQueueLock;
Common::Queue<Common::Event> _eventQueue;
enum { kInitState, kActiveState, kClosingState, kDoneState, kErrorState } _state;
enum { kLeftButton, kRightButtonOnce, kRightButton, kMoveOnly } _buttonState;
enum { kControlMouse, kEscapeKey, kGameMenu, kShowKeypad } _shortcut;
};
#endif

446
backends/platform/tizen/fs.cpp
View file

@ -1,446 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#include "config.h"
#include "common/translation.h"
#include "backends/platform/tizen/system.h"
#include "backends/platform/tizen/fs.h"
#include <FAppApp.h>
#define BUFFER_SIZE 1024
using namespace Tizen::App;
//
// converts a Tizen (wchar) String into a scummVM (char) string
//
Common::String fromString(const Tizen::Base::String &in) {
ByteBuffer *buf = StringUtil::StringToUtf8N(in);
Common::String result((const char*)buf->GetPointer());
delete buf;
return result;
}
//
// TizenFileStream
//
class TizenFileStream :
public Common::SeekableReadStream,
public Common::WriteStream,
public Common::NonCopyable {
public:
static TizenFileStream *makeFromPath(const String &path, bool writeMode);
TizenFileStream(File *file, bool writeMode);
~TizenFileStream();
bool err() const;
void clearErr();
bool eos() const;
uint32 write(const void *dataPtr, uint32 dataSize);
bool flush();
int32 pos() const;
int32 size() const;
bool seek(int32 offs, int whence = SEEK_SET);
uint32 read(void *dataPtr, uint32 dataSize);
private:
byte _buffer[BUFFER_SIZE];
uint32 _bufferIndex;
uint32 _bufferLength;
bool _writeMode;
File *_file;
};
TizenFileStream::TizenFileStream(File *ioFile, bool writeMode) :
_bufferIndex(0),
_bufferLength(0),
_writeMode(writeMode),
_file(ioFile) {
AppAssert(ioFile != 0);
}
TizenFileStream::~TizenFileStream() {
if (_file) {
if (_writeMode) {
flush();
}
delete _file;
}
}
bool TizenFileStream::err() const {
result r = GetLastResult();
return (r != E_SUCCESS && r != E_END_OF_FILE);
}
void TizenFileStream::clearErr() {
SetLastResult(E_SUCCESS);
}
bool TizenFileStream::eos() const {
return (_bufferLength - _bufferIndex == 0) && (GetLastResult() == E_END_OF_FILE);
}
int32 TizenFileStream::pos() const {
return _file->Tell() - (_bufferLength - _bufferIndex);
}
int32 TizenFileStream::size() const {
int32 oldPos = _file->Tell();
_file->Seek(FILESEEKPOSITION_END, 0);
int32 length = _file->Tell();
SetLastResult(_file->Seek(FILESEEKPOSITION_BEGIN, oldPos));
return length;
}
bool TizenFileStream::seek(int32 offs, int whence) {
bool result = false;
switch (whence) {
case SEEK_SET:
// set from start of file
SetLastResult(_file->Seek(FILESEEKPOSITION_BEGIN, offs));
result = (E_SUCCESS == GetLastResult());
break;
case SEEK_CUR:
// set relative to offs
if (_bufferIndex < _bufferLength && _bufferIndex > (uint32)-offs) {
// re-position within the buffer
SetLastResult(E_SUCCESS);
_bufferIndex += offs;
return true;
} else {
offs -= (_bufferLength - _bufferIndex);
if (offs < 0 && _file->Tell() + offs < 0) {
// avoid negative positioning
offs = 0;
}
if (offs != 0) {
SetLastResult(_file->Seek(FILESEEKPOSITION_CURRENT, offs));
result = (E_SUCCESS == GetLastResult());
} else {
result = true;
}
}
break;
case SEEK_END:
// set relative to end - positive will increase the file size
SetLastResult(_file->Seek(FILESEEKPOSITION_END, offs));
result = (E_SUCCESS == GetLastResult());
break;
default:
AppLog("Invalid whence %d", whence);
return false;
}
if (!result) {
AppLog("seek failed");
}
_bufferIndex = _bufferLength = 0;
return result;
}
uint32 TizenFileStream::read(void *ptr, uint32 len) {
uint32 result = 0;
if (!eos()) {
if (_bufferIndex < _bufferLength) {
// use existing buffer
uint32 available = _bufferLength - _bufferIndex;
if (len <= available) {
// use allocation
memcpy((byte *)ptr, &_buffer[_bufferIndex], len);
_bufferIndex += len;
result = len;
} else {
// use remaining allocation
memcpy((byte *)ptr, &_buffer[_bufferIndex], available);
uint32 remaining = len - available;
result = available;
if (remaining) {
result += _file->Read(((byte *)ptr) + available, remaining);
}
_bufferIndex = _bufferLength = 0;
}
} else if (len < BUFFER_SIZE) {
// allocate and use buffer
_bufferIndex = 0;
_bufferLength = _file->Read(_buffer, BUFFER_SIZE);
if (_bufferLength) {
if (_bufferLength < len) {
len = _bufferLength;
}
memcpy((byte *)ptr, _buffer, len);
result = _bufferIndex = len;
}
} else {
result = _file->Read((byte *)ptr, len);
_bufferIndex = _bufferLength = 0;
}
} else {
AppLog("Attempted to read past EOS");
}
return result;
}
uint32 TizenFileStream::write(const void *ptr, uint32 len) {
result r = _file->Write(ptr, len);
SetLastResult(r);
return (r == E_SUCCESS ? len : 0);
}
bool TizenFileStream::flush() {
logEntered();
SetLastResult(_file->Flush());
return (E_SUCCESS == GetLastResult());
}
TizenFileStream *TizenFileStream::makeFromPath(const String &path, bool writeMode) {
File *ioFile = new File();
String filePath = path;
if (writeMode && (path[0] != '.' && path[0] != '/')) {
filePath.Insert(App::GetInstance()->GetAppDataPath() + L"/", 0);
}
AppLog("Open file %S", filePath.GetPointer());
TizenFileStream *stream;
result r = ioFile->Construct(filePath, writeMode ? L"w" : L"r", writeMode);
if (r == E_SUCCESS) {
stream = new TizenFileStream(ioFile, writeMode);
} else {
AppLog("Failed to open file");
delete ioFile;
stream = NULL;
}
return stream;
}
//
// TizenFilesystemNode
//
TizenFilesystemNode::TizenFilesystemNode(const Common::String &nodePath) {
AppAssert(nodePath.size() > 0);
init(nodePath);
}
TizenFilesystemNode::TizenFilesystemNode(SystemPath systemPath) {
switch (systemPath) {
case kData:
_unicodePath = App::GetInstance()->GetAppDataPath();
_displayName = _s("[ Data ]");
break;
case kResource:
_unicodePath = App::GetInstance()->GetAppResourcePath();
_displayName = _s("[ Resources ]");
break;
case kSdCard:
_unicodePath = Tizen::System::Environment::GetExternalStoragePath();
_displayName = _s("[ SDCard ]");
break;
case kMedia:
_unicodePath = Tizen::System::Environment::GetMediaPath();
_displayName = _s("[ Media ]");
break;
case kShared:
_unicodePath = App::GetInstance()->GetAppSharedPath();
_displayName = _s("[ Shared ]");
break;
}
_path = ::fromString(_unicodePath);
_isValid = _isVirtualDir = !IsFailed(File::GetAttributes(_unicodePath, _attr));
}
TizenFilesystemNode::TizenFilesystemNode(const Common::String &root, const Common::String &nodePath) {
AppLog("TizenFilesystemNode '%s' '%s'", root.c_str(), nodePath.c_str());
// Make sure the string contains no slashes
AppAssert(!nodePath.contains('/'));
// We assume here that path is already normalized (hence don't bother to
// call Common::normalizePath on the final path).
Common::String newPath(root);
if (root.lastChar() != '/') {
newPath += '/';
}
newPath += nodePath;
init(newPath);
}
void TizenFilesystemNode::init(const Common::String &nodePath) {
// Normalize the path (that is, remove unneeded slashes etc.)
_path = Common::normalizePath(nodePath, '/');
_displayName = Common::lastPathComponent(_path, '/');
StringUtil::Utf8ToString(_path.c_str(), _unicodePath);
_isVirtualDir = (_path == "/");
_isValid = _isVirtualDir || !IsFailed(File::GetAttributes(_unicodePath, _attr));
}
bool TizenFilesystemNode::exists() const {
return _isValid;
}
bool TizenFilesystemNode::isReadable() const {
return _isVirtualDir || _isValid;
}
bool TizenFilesystemNode::isDirectory() const {
return _isVirtualDir || (_isValid && _attr.IsDirectory());
}
bool TizenFilesystemNode::isWritable() const {
bool result = (_isValid && !_attr.IsReadOnly());
if (_unicodePath == App::GetInstance()->GetAppResourcePath()) {
result = false;
}
return result;
}
AbstractFSNode *TizenFilesystemNode::getChild(const Common::String &n) const {
AppAssert(!_path.empty());
AppAssert(isDirectory());
return new TizenFilesystemNode(_path, n);
}
bool TizenFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool hidden) const {
AppAssert(isDirectory());
bool result = false;
if (_isVirtualDir && mode != Common::FSNode::kListFilesOnly && _path == "/") {
// present well known TIZEN file system areas
myList.push_back(new TizenFilesystemNode(kData));
myList.push_back(new TizenFilesystemNode(kSdCard));
myList.push_back(new TizenFilesystemNode(kMedia));
myList.push_back(new TizenFilesystemNode(kShared));
}
if (!result) {
DirEnumerator *pDirEnum = 0;
Directory *pDir = new Directory();
// open directory
if (IsFailed(pDir->Construct(_unicodePath))) {
AppLog("Failed to open directory: %S", _unicodePath.GetPointer());
} else {
// read all directory entries
pDirEnum = pDir->ReadN();
if (pDirEnum) {
result = true;
}
// loop through all directory entries
while (pDirEnum && pDirEnum->MoveNext() == E_SUCCESS) {
DirEntry dirEntry = pDirEnum->GetCurrentDirEntry();
// skip 'invisible' files if necessary
Tizen::Base::String fileName = dirEntry.GetName();
if (fileName[0] == '.' && !hidden) {
continue;
}
// skip '.' and '..' to avoid cycles
if (fileName == L"." || fileName == L"..") {
continue;
}
// Honor the chosen mode
if ((mode == Common::FSNode::kListFilesOnly && dirEntry.IsDirectory()) ||
(mode == Common::FSNode::kListDirectoriesOnly && !dirEntry.IsDirectory())) {
continue;
}
myList.push_back(new TizenFilesystemNode(_path, ::fromString(fileName)));
}
}
// cleanup
if (pDirEnum) {
delete pDirEnum;
}
// close the opened directory
if (pDir) {
delete pDir;
}
}
return result;
}
AbstractFSNode *TizenFilesystemNode::getParent() const {
logEntered();
if (_path == "/") {
return 0; // The filesystem root has no parent
}
const char *start = _path.c_str();
const char *end = start + _path.size();
// Strip of the last component. We make use of the fact that at this
// point, path is guaranteed to be normalized
while (end > start && *(end-1) != '/') {
end--;
}
if (end == start) {
// This only happens if we were called with a relative path, for which
// there simply is no parent.
// TODO: We could also resolve this by assuming that the parent is the
// current working directory, and returning a node referring to that.
return NULL;
}
return new TizenFilesystemNode(Common::String(start, end));
}
Common::SeekableReadStream *TizenFilesystemNode::createReadStream() {
Common::SeekableReadStream *result = TizenFileStream::makeFromPath(_unicodePath, false);
if (result != NULL) {
_isValid = !IsFailed(File::GetAttributes(_unicodePath, _attr));
}
return result;
}
Common::WriteStream *TizenFilesystemNode::createWriteStream() {
Common::WriteStream *result = TizenFileStream::makeFromPath(_unicodePath, true);
if (result != NULL) {
_isValid = !IsFailed(File::GetAttributes(_unicodePath, _attr));
}
return result;
}
bool TizenFilesystemNode::createDirectory() {
warning("TizenFilesystemNode::createDirectory(): Not supported");
return _isValid && isDirectory();
}

100
backends/platform/tizen/fs.h
View file

@ -1,100 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#ifndef TIZEN_FILESYSTEM_H
#define TIZEN_FILESYSTEM_H
#include <FBaseString.h>
#include <FBaseUtilStringUtil.h>
#include <FIoDirectory.h>
#include <FIoFile.h>
#include "config.h"
#include "common/scummsys.h"
#include "common/stream.h"
#include "backends/fs/abstract-fs.h"
using namespace Tizen::Io;
using namespace Tizen::Base;
using namespace Tizen::Base::Utility;
//
// converts a Tizen (wchar) String into a scummVM (char) string
//
Common::String fromString(const Tizen::Base::String &in);
//
// Enumerates the possible system paths
//
enum SystemPath { kData, kResource, kSdCard, kMedia, kShared };
/**
* Implementation of the ScummVM file system API based on TIZEN.
*
* Parts of this class are documented in the base interface class, AbstractFSNode.
*/
class TizenFilesystemNode : public AbstractFSNode {
public:
/**
* Creates a TizenFilesystemNode for a given path.
*
* @param path the path the new node should point to.
*/
TizenFilesystemNode(const Common::String &path);
/**
* Creates a TizenFilesystemNode from the given Tizen internal path
*
* @param path the path the new node should point to.
*/
TizenFilesystemNode(SystemPath systemPath);
Common::String getDisplayName() const { return _displayName; }
Common::String getName() const { return _displayName; }
Common::String getPath() const { return _path; }
bool exists() const;
bool isDirectory() const;
bool isReadable() const;
bool isWritable() const;
AbstractFSNode *getChild(const Common::String &n) const;
bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
AbstractFSNode *getParent() const;
Common::SeekableReadStream *createReadStream();
Common::WriteStream *createWriteStream();
bool createDirectory();
protected:
TizenFilesystemNode(const Common::String &root, const Common::String &p);
void init(const Common::String &nodePath);
Common::String _displayName;
Common::String _path;
String _unicodePath;
bool _isValid;
bool _isVirtualDir;
FileAttributes _attr;
};
#endif

213
backends/platform/tizen/graphics.cpp
View file

@ -1,213 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#include "graphics/fontman.h"
#include "backends/platform/tizen/form.h"
#include "backends/platform/tizen/system.h"
#include "backends/platform/tizen/graphics.h"
//
// TizenGraphicsManager
//
TizenGraphicsManager::TizenGraphicsManager(TizenAppForm *appForm) :
_appForm(appForm),
_eglDisplay(EGL_DEFAULT_DISPLAY),
_eglSurface(EGL_NO_SURFACE),
_eglConfig(NULL),
_eglContext(EGL_NO_CONTEXT),
_initState(true) {
assert(appForm != NULL);
}
TizenGraphicsManager::~TizenGraphicsManager() {
logEntered();
if (_eglDisplay != EGL_NO_DISPLAY) {
notifyContextDestroy();
eglMakeCurrent(_eglDisplay, NULL, NULL, NULL);
if (_eglContext != EGL_NO_CONTEXT) {
eglDestroyContext(_eglDisplay, _eglContext);
}
}
}
result TizenGraphicsManager::Construct() {
// Initialize our OpenGL ES context.
loadEgl();
// Notify the OpenGL code about our context.
setContextType(OpenGL::kContextGLES);
// We default to RGB565 and RGBA5551 which is closest to the actual output
// mode we setup.
notifyContextCreate(Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0), Graphics::PixelFormat(2, 5, 5, 5, 1, 11, 6, 1, 0));
// Tell our size.
int x, y, width, height;
_appForm->GetBounds(x, y, width, height);
AppLog("screen size: %dx%d", width, height);
setActualScreenSize(width, height);
return E_SUCCESS;
}
const Graphics::Font *TizenGraphicsManager::getFontOSD() {
return FontMan.getFontByUsage(Graphics::FontManager::kBigGUIFont);
}
bool TizenGraphicsManager::moveMouse(int16 &x, int16 &y) {
int16 currentX, currentY;
getMousePosition(currentX, currentY);
// save the current hardware coordinates
setMousePosition(x, y);
// return x/y as game coordinates
adjustMousePosition(x, y);
// convert current x/y to game coordinates
adjustMousePosition(currentX, currentY);
// return whether game coordinates have changed
return (currentX != x || currentY != y);
}
Common::List<Graphics::PixelFormat> TizenGraphicsManager::getSupportedFormats() const {
logEntered();
Common::List<Graphics::PixelFormat> res;
res.push_back(Graphics::PixelFormat(2, 4, 4, 4, 4, 12, 8, 4, 0));
res.push_back(Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0));
res.push_back(Graphics::PixelFormat(2, 5, 5, 5, 1, 11, 6, 1, 0));
res.push_back(Graphics::PixelFormat::createFormatCLUT8());
return res;
}
bool TizenGraphicsManager::hasFeature(OSystem::Feature f) {
bool result =
(f == OSystem::kFeatureVirtualKeyboard ||
OpenGLGraphicsManager::hasFeature(f));
return result;
}
void TizenGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
if (f == OSystem::kFeatureVirtualKeyboard) {
if (enable) {
_appForm->showKeypad();
}
} else {
OpenGLGraphicsManager::setFeatureState(f, enable);
}
}
void TizenGraphicsManager::setReady() {
logEntered();
_appForm->GetVisualElement()->SetShowState(true);
_initState = false;
}
void TizenGraphicsManager::updateScreen() {
if (!_initState) {
OpenGLGraphicsManager::updateScreen();
}
}
bool TizenGraphicsManager::loadEgl() {
logEntered();
EGLint numConfigs = 1;
EGLint eglConfigList[] = {
EGL_RED_SIZE, 5,
EGL_GREEN_SIZE, 6,
EGL_BLUE_SIZE, 5,
EGL_ALPHA_SIZE, 0,
EGL_DEPTH_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
EGL_NONE
};
EGLint eglContextList[] = {
EGL_CONTEXT_CLIENT_VERSION, 1,
EGL_NONE
};
eglBindAPI(EGL_OPENGL_ES_API);
_eglDisplay = eglGetDisplay((EGLNativeDisplayType) EGL_DEFAULT_DISPLAY);
if (EGL_NO_DISPLAY == _eglDisplay) {
systemError("eglGetDisplay() failed");
return false;
}
if (EGL_FALSE == eglInitialize(_eglDisplay, NULL, NULL) ||
EGL_SUCCESS != eglGetError()) {
systemError("eglInitialize() failed");
return false;
}
if (EGL_FALSE == eglChooseConfig(_eglDisplay, eglConfigList, &_eglConfig, 1, &numConfigs) ||
EGL_SUCCESS != eglGetError()) {
systemError("eglChooseConfig() failed");
return false;
}
if (!numConfigs) {
systemError("eglChooseConfig() failed. Matching config does not exist \n");
return false;
}
_eglSurface = eglCreateWindowSurface(_eglDisplay, _eglConfig, (EGLNativeWindowType)_appForm, NULL);
if (EGL_NO_SURFACE == _eglSurface || EGL_SUCCESS != eglGetError()) {
systemError("eglCreateWindowSurface() failed. EGL_NO_SURFACE");
return false;
}
_eglContext = eglCreateContext(_eglDisplay, _eglConfig, EGL_NO_CONTEXT, eglContextList);
if (EGL_NO_CONTEXT == _eglContext ||
EGL_SUCCESS != eglGetError()) {
systemError("eglCreateContext() failed");
return false;
}
if (false == eglMakeCurrent(_eglDisplay, _eglSurface, _eglSurface, _eglContext) ||
EGL_SUCCESS != eglGetError()) {
systemError("eglMakeCurrent() failed");
return false;
}
logLeaving();
return true;
}
bool TizenGraphicsManager::loadVideoMode(uint requestedWidth, uint requestedHeight, const Graphics::PixelFormat &format) {
// We get this whenever a new resolution is requested. Since Tizen is
// using a fixed output size we do nothing like that here.
return true;
}
void TizenGraphicsManager::refreshScreen() {
eglSwapBuffers(_eglDisplay, _eglSurface);
}
void *TizenGraphicsManager::getProcAddress(const char *name) const {
return eglGetProcAddress(name);
}

80
backends/platform/tizen/graphics.h
View file

@ -1,80 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#ifndef TIZEN_GRAPHICS_H
#define TIZEN_GRAPHICS_H
#include <FBase.h>
#include <FGraphics.h>
#include <FApp.h>
#include <FGraphicsOpengl.h>
#include <FSystem.h>
#include <FUi.h>
#include "config.h"
#include "backends/graphics/opengl/opengl-graphics.h"
#include "graphics/font.h"
#include "backends/platform/tizen/form.h"
using namespace Tizen::Graphics;
using namespace Tizen::Graphics::Opengl;
using namespace Tizen::App;
class TizenGraphicsManager : public OpenGL::OpenGLGraphicsManager {
public:
TizenGraphicsManager(TizenAppForm *appForm);
virtual ~TizenGraphicsManager();
result Construct();
Common::List<Graphics::PixelFormat> getSupportedFormats() const;
bool hasFeature(OSystem::Feature f);
void setFeatureState(OSystem::Feature f, bool enable);
void updateScreen();
void setReady();
bool isReady() { return !_initState; }
bool moveMouse(int16 &x, int16 &y);
protected:
void setInternalMousePosition(int x, int y) {}
bool loadVideoMode(uint requestedWidth, uint requestedHeight, const Graphics::PixelFormat &format);
void refreshScreen();
void *getProcAddress(const char *name) const;
const Graphics::Font *getFontOSD();
private:
bool loadEgl();
TizenAppForm *_appForm;
EGLDisplay _eglDisplay;
EGLSurface _eglSurface;
EGLConfig _eglConfig;
EGLContext _eglContext;
bool _initState;
};
#endif

51
backends/platform/tizen/main.cpp
View file

@ -1,51 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#include <FBase.h>
#include <FApp.h>
#include <FSystem.h>
#include "backends/platform/tizen/application.h"
using namespace Tizen::Base;
using namespace Tizen::Base::Collection;
/**
* The entry function of tizen application called by the operating system.
*/
extern "C" _EXPORT_ int OspMain(int argc, char *pArgv[]) {
result r = E_SUCCESS;
AppLog("Application started.");
ArrayList args(SingleObjectDeleter);
args.Construct();
for (int i = 0; i < argc; i++) {
args.Add(new (std::nothrow) String(pArgv[i]));
}
r = Tizen::App::UiApp::Execute(TizenScummVM::createInstance, &args);
TryLog(r == E_SUCCESS, "[%s] Application execution failed", GetErrorMessage(r));
AppLog("Application finished.");
return static_cast<int>(r);
}

82
backends/platform/tizen/missing.cpp
View file

@ -1,82 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#include <FApp.h>
#include <FGraphics.h>
#include <FUi.h>
#include <FSystem.h>
#include <FBase.h>
#include "backends/platform/tizen/portdefs.h"
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h>
#define BUF_SIZE 255
void systemError(const char *message);
C_LINKAGE_BEGIN
int __errno; // for overridden method in saves/default/default-saves.cpp
void __assert_func(const char *file, int line,
const char *func, const char *err) {
char buffer[BUF_SIZE];
snprintf(buffer, sizeof(buffer), "%s %d %s %s", file, line, func, err);
systemError(buffer);
}
void stderr_fprintf(void *, const char *format, ...) {
va_list ap;
char buffer[BUF_SIZE];
va_start(ap, format);
vsnprintf(buffer, sizeof(buffer), format, ap);
va_end(ap);
AppLog(buffer);
}
void stderr_vfprintf(void *, const char *format, va_list ap) {
char buffer[BUF_SIZE];
vsnprintf(buffer, sizeof(buffer), format, ap);
AppLog(buffer);
}
int printf(const char *format, ...) {
int result = 0;
va_list ap;
char buffer[BUF_SIZE];
va_start(ap, format);
result = vsnprintf(buffer, sizeof(buffer), format, ap);
va_end(ap);
AppLog(buffer);
return result;
}
C_LINKAGE_END

85
backends/platform/tizen/portdefs.h
View file

@ -1,85 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#ifndef PORT_DEFS_H
#define PORT_DEFS_H
#include <assert.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <math.h>
#include <new>
#define M_PI 3.14159265358979323846
#ifdef __cplusplus
#include <ctype.h> // causes a link error when building c programs
#define C_LINKAGE_BEGIN extern "C" {
#define C_LINKAGE_END }
#else
#define C_LINKAGE_BEGIN
#define C_LINKAGE_END
#endif
// value missing from osp gl headers
#define GL_UNSIGNED_INT_8_8_8_8 0x8035
C_LINKAGE_BEGIN
// for libFLAC
#undef fseeko
#undef ftello
#define fseeko fseek
#define ftello ftell
// overcome use of fprintf since newlib (1.2) does not
// support stderr/stdout (undefined reference to `_impure_ptr').
void stderr_fprintf(void *, const char *format, ...);
void stderr_vfprintf(void *, const char *format, va_list ap);
#undef fprintf
#undef vfprintf
#undef stderr
#undef stdout
#undef stdin
#undef fputs
#undef fflush
#define stderr (void *)0
#define stdout (void *)1
#define stdin (void *)2
#define fputs(str, file)
#define fflush(file)
#define sscanf simple_sscanf
#define fprintf stderr_fprintf
#define vfprintf stderr_vfprintf
int printf(const char *format, ...);
int simple_sscanf(const char *buffer, const char *format, ...);
C_LINKAGE_END
#endif

213
backends/platform/tizen/sscanf.cpp
View file

@ -1,213 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
//
// simple sscanf replacement to match scummvm usage patterns
//
bool scanInt(const char **in, va_list *ap, int max) {
// skip leading space characters
while (**in && **in == ' ') {
(*in)++;
}
// number optionally preceeded with a + or - sign.
bool negate = false;
if (**in == '-') {
(*in)++;
negate = true;
}
if (**in == '+') {
(*in)++;
}
int *arg = va_arg(*ap, int*);
char *end;
long n = strtol(*in, &end, 10);
if (negate) {
n = -n;
}
bool err = false;
if (end == *in || (max > 0 && (end - *in) > max)) {
err = true;
} else {
*arg = (int)n;
*in = end;
}
return err;
}
bool scanHex(const char **in, va_list *ap) {
unsigned *arg = va_arg(*ap, unsigned*);
char *end;
long n = strtol(*in, &end, 16);
if (end == *in) {
return true;
}
*in = end;
*arg = (unsigned) n;
return false;
}
bool scanString(const char **in, va_list *ap) {
char *arg = va_arg(*ap, char*);
while (**in && **in != ' ' && **in != '\n' && **in != '\t') {
*arg = **in;
arg++;
(*in)++;
}
*arg = '\0';
(*in)++;
return false;
}
bool scanStringUntil(const char **in, va_list *ap, char c_end) {
char *arg = va_arg(*ap, char*);
while (**in && **in != c_end) {
*arg = **in;
arg++;
(*in)++;
}
*arg = 0;
(*in)++;
return false;
}
bool scanChar(const char **in, va_list *ap) {
char *arg = va_arg(*ap, char*);
if (**in) {
*arg = **in;
(*in)++;
}
return false;
}
extern "C" int simple_sscanf(const char *input, const char *format, ...) {
va_list ap;
int result = 0;
const char *next = input;
va_start(ap, format);
while (*format) {
if (*format == '%') {
format++;
int max = 0;
while (isdigit(*format)) {
max = (max * 10) + (*format - '0');
format++;
}
bool err = false;
switch (*format++) {
case 'c':
err = scanChar(&next, &ap);
break;
case 'd':
case 'u':
err = scanInt(&next, &ap, max);
break;
case 'x':
err = scanHex(&next, &ap);
break;
case 's':
err = scanString(&next, &ap);
break;
case '[':
// assume %[^c]
if ('^' != *format) {
err = true;
} else {
format++;
if (*format && *(format+1) == ']') {
err = scanStringUntil(&next, &ap, *format);
format += 2;
} else {
err = true;
}
}
break;
default:
err = true;
break;
}
if (err) {
break;
} else {
result++;
}
} else if (*format++ != *next++) {
// match input
break;
}
}
va_end(ap);
return result;
}
#if defined(TEST)
int main(int argc, char *pArgv[]) {
int x,y,xx,yy,h;
char buffer[100];
unsigned u;
char c;
strcpy(buffer, "hello");
char *b = buffer;
if (simple_sscanf("BBX 00009 -1 +10 000",
"BBX %d %d %d %d",
&x, &y, &xx, &yy) != 4) {
printf("Failed\n");
} else {
printf("Success %d %d %d %d\n", x, y, xx, yy);
}
if (simple_sscanf("CAT 123x-10 0x100h 123456.AUD $ ",
"CAT %dx%d %xh %06u.AUD %c",
&x, &y, &h, &u, &c) != 5) {
printf("Failed\n");
} else {
printf("Success %d %d %d %d '%c' \n", x, y, h, u, c);
}
if (simple_sscanf("COPYRIGHT \"Copyright (c) 1984, 1987 Foo Systems Incorporated",
"COPYRIGHT \"%[^\"]",
b) != 1) {
printf("Failed\n");
} else {
printf("Success %s\n", buffer);
}
return 0;
}
#endif

560
backends/platform/tizen/system.cpp
View file

@ -1,560 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#define FORBIDDEN_SYMBOL_EXCEPTION_exit
#include <FUiCtrlMessageBox.h>
#include <FLocales.h>
#include "common/config-manager.h"
#include "common/file.h"
#include "engines/engine.h"
#include "graphics/font.h"
#include "graphics/fontman.h"
#include "graphics/fonts/bdf.h"
#include "backends/saves/default/default-saves.h"
#include "backends/events/default/default-events.h"
#include "backends/audiocd/default/default-audiocd.h"
#include "backends/mutex/mutex.h"
#include "backends/fs/fs-factory.h"
#include "backends/timer/tizen/timer.h"
#include "backends/platform/tizen/form.h"
#include "backends/platform/tizen/system.h"
#include "backends/platform/tizen/graphics.h"
#include "backends/platform/tizen/audio.h"
using namespace Tizen::Base;
using namespace Tizen::Base::Runtime;
using namespace Tizen::Locales;
using namespace Tizen::Ui;
using namespace Tizen::Ui::Controls;
using namespace Tizen::System;
#define DEFAULT_CONFIG_FILE "scummvm.ini"
#define MUTEX_BUFFER_SIZE 5
//
// TizenFilesystemFactory
//
class TizenFilesystemFactory : public FilesystemFactory {
AbstractFSNode *makeRootFileNode() const;
AbstractFSNode *makeCurrentDirectoryFileNode() const;
AbstractFSNode *makeFileNodePath(const Common::String &path) const;
};
AbstractFSNode *TizenFilesystemFactory::makeRootFileNode() const {
return new TizenFilesystemNode("/");
}
AbstractFSNode *TizenFilesystemFactory::makeCurrentDirectoryFileNode() const {
return new TizenFilesystemNode("/");
}
AbstractFSNode *TizenFilesystemFactory::makeFileNodePath(const Common::String &path) const {
AppAssert(!path.empty());
return new TizenFilesystemNode(path);
}
//
// TizenSaveFileManager
//
struct TizenSaveFileManager : public DefaultSaveFileManager {
bool removeSavefile(const Common::String &filename);
};
bool TizenSaveFileManager::removeSavefile(const Common::String &filename) {
// Assure the savefile name cache is up-to-date.
assureCached(getSavePath());
if (getError().getCode() != Common::kNoError)
return false;
// Obtain node if exists.
SaveFileCache::const_iterator file = _saveFileCache.find(filename);
if (file == _saveFileCache.end()) {
return false;
} else {
const Common::FSNode fileNode = file->_value;
// Remove from cache, this invalidates the 'file' iterator.
_saveFileCache.erase(file);
file = _saveFileCache.end();
String unicodeFileName;
StringUtil::Utf8ToString(fileNode.getPath().c_str(), unicodeFileName);
switch (Tizen::Io::File::Remove(unicodeFileName)) {
case E_SUCCESS:
return true;
case E_ILLEGAL_ACCESS:
setError(Common::kWritePermissionDenied, "Search or write permission denied: " +
file.getName());
break;
default:
setError(Common::kPathDoesNotExist, "removeSavefile: '" + file.getName() +
"' does not exist or path is invalid");
break;
}
return false;
}
}
//
// TizenMutexManager
//
struct TizenMutexManager : public MutexManager {
TizenMutexManager();
~TizenMutexManager();
OSystem::MutexRef createMutex();
void lockMutex(OSystem::MutexRef mutex);
void unlockMutex(OSystem::MutexRef mutex);
void deleteMutex(OSystem::MutexRef mutex);
private:
Mutex *_buffer[MUTEX_BUFFER_SIZE];
};
TizenMutexManager::TizenMutexManager() {
for (int i = 0; i < MUTEX_BUFFER_SIZE; i++) {
_buffer[i] = NULL;
}
}
TizenMutexManager::~TizenMutexManager() {
for (int i = 0; i < MUTEX_BUFFER_SIZE; i++) {
if (_buffer[i] != NULL) {
delete _buffer[i];
}
}
}
OSystem::MutexRef TizenMutexManager::createMutex() {
Mutex *mutex = new Mutex();
mutex->Create();
for (int i = 0; i < MUTEX_BUFFER_SIZE; i++) {
if (_buffer[i] == NULL) {
_buffer[i] = mutex;
break;
}
}
return (OSystem::MutexRef) mutex;
}
void TizenMutexManager::lockMutex(OSystem::MutexRef mutex) {
Mutex *m = (Mutex *)mutex;
m->Acquire();
}
void TizenMutexManager::unlockMutex(OSystem::MutexRef mutex) {
Mutex *m = (Mutex *)mutex;
m->Release();
}
void TizenMutexManager::deleteMutex(OSystem::MutexRef mutex) {
Mutex *m = (Mutex *)mutex;
for (int i = 0; i < MUTEX_BUFFER_SIZE; i++) {
if (_buffer[i] == m) {
_buffer[i] = NULL;
}
}
delete m;
}
//
// TizenEventManager
//
struct TizenEventManager : public DefaultEventManager {
TizenEventManager(Common::EventSource *boss);
void init();
int shouldQuit() const;
};
TizenEventManager::TizenEventManager(Common::EventSource *boss) :
DefaultEventManager(boss) {
}
void TizenEventManager::init() {
DefaultEventManager::init();
// theme and vkbd should have now loaded - clear the splash screen
TizenSystem *system = (TizenSystem *)g_system;
TizenGraphicsManager *graphics = system->getGraphics();
if (graphics) {
graphics->setReady();
}
}
int TizenEventManager::shouldQuit() const {
TizenSystem *system = (TizenSystem *)g_system;
return DefaultEventManager::shouldQuit() || system->isClosing();
}
//
// TizenAppFrame - avoid drawing the misplaced UiTheme at startup
//
struct TizenAppFrame : Frame {
result OnDraw(void) {
logEntered();
TizenAppForm *form = (TizenAppForm *)GetCurrentForm();
if (form->isStarting()) {
Canvas *canvas = GetCanvasN();
canvas->SetBackgroundColor(Color::GetColor(COLOR_ID_BLACK));
canvas->Clear();
delete canvas;
}
return E_SUCCESS;
}
};
//
// TizenSystem
//
TizenSystem::TizenSystem(TizenAppForm *appForm) :
_appForm(appForm),
_audioThread(0),
_epoch(0) {
}
result TizenSystem::Construct(void) {
logEntered();
_fsFactory = new TizenFilesystemFactory();
if (!_fsFactory) {
return E_OUT_OF_MEMORY;
}
_resourcePath = fromString(App::GetInstance()->GetAppResourcePath());
return E_SUCCESS;
}
TizenSystem::~TizenSystem() {
logEntered();
}
result TizenSystem::initModules() {
logEntered();
_mutexManager = new TizenMutexManager();
if (!_mutexManager) {
return E_OUT_OF_MEMORY;
}
_timerManager = new TizenTimerManager();
if (!_timerManager) {
return E_OUT_OF_MEMORY;
}
_savefileManager = new TizenSaveFileManager();
if (!_savefileManager) {
return E_OUT_OF_MEMORY;
}
_graphicsManager = new TizenGraphicsManager(_appForm);
if (!_graphicsManager || getGraphics()->Construct() != E_SUCCESS) {
return E_OUT_OF_MEMORY;
}
// depends on _graphicsManager when ENABLE_VKEYBD enabled
_eventManager = new TizenEventManager(this);
if (!_eventManager) {
return E_OUT_OF_MEMORY;
}
_audioThread = new AudioThread();
if (!_audioThread) {
return E_OUT_OF_MEMORY;
}
_mixer = _audioThread->Construct();
if (!_mixer) {
return E_OUT_OF_MEMORY;
}
_audiocdManager = (AudioCDManager *)new DefaultAudioCDManager();
if (!_audiocdManager) {
return E_OUT_OF_MEMORY;
}
if (IsFailed(_audioThread->Start())) {
AppLog("Failed to start audio thread");
return E_OUT_OF_MEMORY;
}
logLeaving();
return E_SUCCESS;
}
void TizenSystem::initBackend() {
logEntered();
Common::String dataPath = fromString(App::GetInstance()->GetAppDataPath());
// use the mobile device theme
ConfMan.set("gui_theme", _resourcePath + "scummremastered");
// allow tizen virtual keypad pack to be found
ConfMan.set("vkeybdpath", _resourcePath + "vkeybd_bada");
ConfMan.set("vkeybd_pack_name", "vkeybd_bada");
// set default save path to writable area
if (!ConfMan.hasKey("savepath")) {
ConfMan.set("savepath", dataPath);
}
// default to no auto-save
if (!ConfMan.hasKey("autosave_period")) {
ConfMan.setInt("autosave_period", 0);
}
ConfMan.registerDefault("fullscreen", true);
ConfMan.registerDefault("aspect_ratio", false);
ConfMan.setBool("confirm_exit", false);
SystemTime::GetTicks(_epoch);
if (E_SUCCESS != initModules()) {
AppLog("initModules failed");
} else {
OSystem::initBackend();
// replace kBigGUIFont for the vkbd and on-screen messages
Common::String fontCacheFile = dataPath + "helvR24.fcc";
TizenFilesystemNode file(fontCacheFile);
if (!file.exists()) {
Common::String bdfFile = _resourcePath + "fonts/helvR24.bdf";
TizenFilesystemNode file(bdfFile);
if (file.exists()) {
Common::SeekableReadStream *stream = file.createReadStream();
Common::File fontFile;
if (stream && fontFile.open(stream, bdfFile)) {
Graphics::BdfFont *font = Graphics::BdfFont::loadFont(fontFile);
Graphics::BdfFont::cacheFontData(*font, fontCacheFile);
FontMan.setFont(Graphics::FontManager::kBigGUIFont, font);
}
}
} else {
Common::SeekableReadStream *stream = file.createReadStream();
Common::File fontFile;
if (stream && fontFile.open(stream, fontCacheFile)) {
Graphics::BdfFont *font = Graphics::BdfFont::loadFromCache(fontFile);
if (font) {
FontMan.setFont(Graphics::FontManager::kBigGUIFont, font);
}
}
}
}
logLeaving();
}
void TizenSystem::addSysArchivesToSearchSet(Common::SearchSet &s, int priority) {
// allow translations.dat and game .DAT files to be found
s.addDirectory(_resourcePath, _resourcePath, priority);
}
void TizenSystem::destroyBackend() {
closeAudio();
delete _graphicsManager;
_graphicsManager = NULL;
delete _savefileManager;
_savefileManager = NULL;
delete _fsFactory;
_fsFactory = NULL;
delete _mixer;
_mixer = NULL;
delete _audiocdManager;
_audiocdManager = NULL;
delete _timerManager;
_timerManager = NULL;
delete _eventManager;
_eventManager = NULL;
delete _mutexManager;
_mutexManager = NULL;
}
bool TizenSystem::pollEvent(Common::Event &event) {
return _appForm->pollEvent(event);
}
uint32 TizenSystem::getMillis(bool skipRecord) {
long long result, ticks = 0;
SystemTime::GetTicks(ticks);
result = ticks - _epoch;
return result;
}
void TizenSystem::delayMillis(uint msecs) {
if (!_appForm->isClosing()) {
Thread::Sleep(msecs);
}
}
void TizenSystem::updateScreen() {
if (_graphicsManager != NULL) {
_graphicsManager->updateScreen();
}
}
void TizenSystem::getTimeAndDate(TimeDate &td) const {
DateTime currentTime;
if (E_SUCCESS == SystemTime::GetCurrentTime(WALL_TIME, currentTime)) {
td.tm_sec = currentTime.GetSecond();
td.tm_min = currentTime.GetMinute();
td.tm_hour = currentTime.GetHour();
td.tm_mday = currentTime.GetDay();
td.tm_mon = currentTime.GetMonth();
td.tm_year = currentTime.GetYear();
Calendar *calendar = Calendar::CreateInstanceN(CALENDAR_GREGORIAN);
calendar->SetTime(currentTime);
td.tm_wday = calendar->GetTimeField(TIME_FIELD_DAY_OF_WEEK) - 1;
delete calendar;
}
}
void TizenSystem::fatalError() {
systemError("ScummVM: Fatal internal error.");
}
void TizenSystem::exitSystem() {
if (_appForm) {
closeAudio();
closeGraphics();
_appForm->exitSystem();
}
}
void TizenSystem::quit() {
exit(0);
}
void TizenSystem::logMessage(LogMessageType::Type type, const char *message) {
if (type == LogMessageType::kError) {
systemError(message);
} else {
AppLog(message);
}
}
Common::SeekableReadStream *TizenSystem::createConfigReadStream() {
TizenFilesystemNode file(fromString(App::GetInstance()->GetAppDataPath()) + DEFAULT_CONFIG_FILE);
return file.createReadStream();
}
Common::WriteStream *TizenSystem::createConfigWriteStream() {
TizenFilesystemNode file(fromString(App::GetInstance()->GetAppDataPath()) + DEFAULT_CONFIG_FILE);
return file.createWriteStream();
}
void TizenSystem::closeAudio() {
if (_audioThread) {
_audioThread->Quit();
_audioThread->Join();
delete _audioThread;
_audioThread = NULL;
}
}
void TizenSystem::closeGraphics() {
if (_graphicsManager) {
delete _graphicsManager;
_graphicsManager = NULL;
}
}
void TizenSystem::setMute(bool on) {
// only change mute after eventManager init() has completed
if (_audioThread) {
TizenGraphicsManager *graphics = getGraphics();
if (graphics && graphics->isReady()) {
_audioThread->setMute(on);
}
}
}
//
// create the ScummVM system
//
TizenAppForm *systemStart(Tizen::App::Application *app) {
logEntered();
Frame *appFrame = new (std::nothrow) TizenAppFrame();
if (!appFrame || appFrame->Construct() == E_FAILURE) {
AppLog("Failed to create appFrame");
return NULL;
}
app->AddFrame(*appFrame);
TizenAppForm *appForm = new TizenAppForm();
if (!appForm) {
AppLog("Failed to create appForm");
return NULL;
}
if (E_SUCCESS != appForm->Construct() ||
E_SUCCESS != appFrame->AddControl(appForm)) {
delete appForm;
AppLog("Failed to construct appForm");
return NULL;
}
appFrame->SetCurrentForm(appForm);
appForm->GetVisualElement()->SetShowState(false);
logLeaving();
return appForm;
}
//
// display a fatal error notification
//
void systemError(const char *message) {
AppLog("Fatal system error: %s", message);
if (strspn(message, "Config file buggy:") > 0) {
Tizen::Io::File::Remove(App::GetInstance()->GetAppDataPath() + DEFAULT_CONFIG_FILE);
Application::GetInstance()->SendUserEvent(USER_MESSAGE_EXIT_ERR_CONFIG, NULL);
} else {
ArrayList *args = new ArrayList();
args->Construct();
args->Add(*(new String(message)));
Application::GetInstance()->SendUserEvent(USER_MESSAGE_EXIT_ERR, args);
}
if (g_system) {
TizenSystem *system = (TizenSystem *)g_system;
system->exitSystem();
}
}

103
backends/platform/tizen/system.h
View file

@ -1,103 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#ifndef TIZEN_SYSTEM_H
#define TIZEN_SYSTEM_H
#include <FApp.h>
#include <FGraphics.h>
#include <FUi.h>
#include <FSystem.h>
#include <FBase.h>
#include <FIoFile.h>
#include "config.h"
#include "common/scummsys.h"
#include "backends/modular-backend.h"
#include "backends/platform/tizen/fs.h"
#include "backends/platform/tizen/form.h"
#include "backends/platform/tizen/audio.h"
#include "backends/platform/tizen/graphics.h"
#if defined(_DEBUG)
#define logEntered() AppLog("%s entered (%s %d)", __FUNCTION__, __FILE__, __LINE__);
#define logLeaving() AppLog("%s leaving (%s %d)", __FUNCTION__, __FILE__, __LINE__);
#else
#define logEntered()
#define logLeaving()
#endif
TizenAppForm *systemStart(Tizen::App::Application *app);
void systemError(const char *message);
#define USER_MESSAGE_EXIT 1000
#define USER_MESSAGE_EXIT_ERR 1001
#define USER_MESSAGE_EXIT_ERR_CONFIG 1002
//
// TizenSystem
//
class TizenSystem :
public ModularBackend,
Common::EventSource {
public:
TizenSystem(TizenAppForm *appForm);
~TizenSystem();
result Construct();
void closeAudio();
void closeGraphics();
void destroyBackend();
void setMute(bool on);
void exitSystem();
bool isClosing() { return _appForm->isClosing(); }
TizenGraphicsManager *getGraphics() {
return dynamic_cast<TizenGraphicsManager *>(_graphicsManager);
}
private:
void initBackend();
result initModules();
void updateScreen();
bool pollEvent(Common::Event &event);
uint32 getMillis(bool skipRecord = false);
void delayMillis(uint msecs);
void getTimeAndDate(TimeDate &t) const;
void fatalError();
void quit();
void logMessage(LogMessageType::Type type, const char *message);
void addSysArchivesToSearchSet(Common::SearchSet &s, int priority);
Common::EventSource *getDefaultEventSource() { return this; }
Common::SeekableReadStream *createConfigReadStream();
Common::WriteStream *createConfigWriteStream();
TizenAppForm *_appForm;
AudioThread *_audioThread;
long long _epoch;
Common::String _resourcePath;
};
#endif

7
backends/platform/tizen/tizen.mk
View file

@ -1,7 +0,0 @@
# port files built under eclipse
MODULE := backends/platform/tizen
$(EXECUTABLE): $(OBJS)
rm -f $@
arm-linux-gnueabi-ar Tru $@ $(OBJS)

117
backends/timer/tizen/timer.cpp
View file

@ -1,117 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#if defined(TIZEN)
#include "backends/timer/tizen/timer.h"
//
// TimerSlot - an event driven thread
//
TimerSlot::TimerSlot(Common::TimerManager::TimerProc callback, uint32 interval, void *refCon) :
_timer(0),
_callback(callback),
_interval(interval),
_refCon(refCon) {
}
TimerSlot::~TimerSlot() {
delete _timer;
}
bool TimerSlot::OnStart() {
_timer = new Tizen::Base::Runtime::Timer();
if (!_timer || IsFailed(_timer->Construct(*this))) {
AppLog("Failed to create timer");
return false;
}
if (IsFailed(_timer->StartAsRepeatable(_interval))) {
AppLog("failed to start timer");
return false;
}
AppLog("started timer %d", _interval);
return true;
}
void TimerSlot::OnStop() {
AppLog("timer stopped");
if (_timer) {
_timer->Cancel();
delete _timer;
_timer = NULL;
}
}
void TimerSlot::OnTimerExpired(Timer &timer) {
_callback(_refCon);
}
//
// TizenTimerManager
//
TizenTimerManager::TizenTimerManager() {
}
TizenTimerManager::~TizenTimerManager() {
for (Common::List<TimerSlot *>::iterator it = _timers.begin(); it != _timers.end(); ) {
TimerSlot *slot = (*it);
slot->Quit();
slot->Join();
delete slot;
it = _timers.erase(it);
}
}
bool TizenTimerManager::installTimerProc(TimerProc proc, int32 interval, void *refCon, const Common::String &id) {
TimerSlot *slot = new TimerSlot(proc, interval / 1000, refCon);
if (IsFailed(slot->Construct())) {
AppLog("Failed to create timer thread");
delete slot;
return false;
}
if (IsFailed(slot->Start())) {
delete slot;
AppLog("Failed to start timer thread");
return false;
}
_timers.push_back(slot);
return true;
}
void TizenTimerManager::removeTimerProc(TimerProc proc) {
for (Common::List<TimerSlot *>::iterator it = _timers.begin(); it != _timers.end(); ++it) {
TimerSlot *slot = (*it);
if (slot->_callback == proc) {
slot->Quit();
slot->Join();
delete slot;
it = _timers.erase(it);
}
}
}
#endif

59
backends/timer/tizen/timer.h
View file

@ -1,59 +0,0 @@
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#ifndef TIZEN_TIMER_H
#define TIZEN_TIMER_H
#include <FBase.h>
#include "common/timer.h"
#include "common/list.h"
using namespace Tizen::Base::Runtime;
struct TimerSlot: public EventDrivenThread, public ITimerEventListener {
TimerSlot(Common::TimerManager::TimerProc callback, uint32 interval, void *refCon);
~TimerSlot();
bool OnStart(void);
void OnStop(void);
void OnTimerExpired(Timer &timer);
Timer *_timer;
Common::TimerManager::TimerProc _callback;
uint32 _interval; // in microseconds
void *_refCon;
};
class TizenTimerManager : public Common::TimerManager {
public:
TizenTimerManager();
~TizenTimerManager();
bool installTimerProc(TimerProc proc, int32 interval, void *refCon, const Common::String &id);
void removeTimerProc(TimerProc proc);
private:
Common::List<TimerSlot *> _timers;
};
#endif

70
configure vendored
View file

@ -946,7 +946,7 @@ Configuration:
-h, --help display this help and exit
--backend=BACKEND backend to build (3ds, android, dc, dingux, ds, gcw0,
gph, iphone, ios7, maemo, n64, null, openpandora,
ps2, psp, psp2, samsungtv, sdl, switch, tizen, webos, wii) [sdl]
ps2, psp, psp2, samsungtv, sdl, switch, webos, wii) [sdl]
Installation directories:
--prefix=PREFIX install architecture-independent files in PREFIX
@ -999,7 +999,6 @@ Special configuration feature:
psp for PlayStation Portable
samsungtv for Samsung TV
switch for Nintendo Switch
tizen for Samsung Tizen
webos for HP Palm WebOS
wii for Nintendo Wii
@ -1789,11 +1788,6 @@ switch)
# Switch SDK has C++11 constructs so we must enable it
_use_cxx11=yes
;;
tizen)
_host_os=tizen
_host_cpu=arm
_host_alias=arm-linux-gnueabi
;;
webos)
_host_os=webos
_host_cpu=arm
@ -1962,12 +1956,6 @@ riscos)
add_line_to_config_mk "BINDHELP := bindhelp"
fi
;;
tizen)
if test -z "$TIZEN_ROOTSTRAP"; then
echo "Please set TIZEN_ROOTSTRAP in your environment. export TIZEN_ROOTSTRAP=<path to Tizen SDK device profile>"
exit 1
fi
;;
webos)
if test -z "$WEBOS_SDK"; then
echo "Please set WEBOS_SDK in your environment. export WEBOS_SDK=<path to WebOS SDK>"
@ -1985,7 +1973,7 @@ esac
# Toolchain for Android is in NDK and is using different naming convention
if test "$_host_os" = android; then
# Check that we have the correct NDK version
echo_n "Checking NDK version... "
_ndk_gradle=$(grep "^[[:space:]]*ndkVersion" $_srcdir/dists/android/build.gradle | sed 's/[^0-9\.]//g')
@ -1998,8 +1986,8 @@ if test "$_host_os" = android; then
fi
# Try to use a known to work toolchain
android_toolchains="windows-x86_64 darwin-x86_64 linux-x86_64"
for toolchain in $android_toolchains; do
android_toolchains="windows-x86_64 darwin-x86_64 linux-x86_64"
for toolchain in $android_toolchains; do
_android_toolchain="$ANDROID_NDK_ROOT/toolchains/llvm/prebuilt/$toolchain"
if test -d "$_android_toolchain"; then
@ -2279,7 +2267,7 @@ if test "$have_gcc" = yes ; then
case $_host_os in
# newlib-based system include files suppress non-C89 function
# declarations under __STRICT_ANSI__, undefine it
3ds | amigaos* | android | androidsdl | dreamcast | ds | gamecube | mingw* | mint* | n64 | psp | ps2 | ps3 | psp2 | switch | tizen | wii )
3ds | amigaos* | android | androidsdl | dreamcast | ds | gamecube | mingw* | mint* | n64 | psp | ps2 | ps3 | psp2 | switch | wii )
append_var CXXFLAGS "-U__STRICT_ANSI__"
;;
*)
@ -2353,7 +2341,7 @@ fi
# However, some platforms use GNU extensions in system header files, so
# for these we must not use -pedantic.
case $_host_os in
3ds | android | androidsdl | gamecube | ps2 | psp | switch | tizen | wii | webos)
3ds | android | androidsdl | gamecube | ps2 | psp | switch | wii | webos)
;;
*)
# ICC does not support pedantic, while GCC and clang do.
@ -2593,7 +2581,7 @@ case $_host_cpu in
openpandora)
define_in_config_if_yes yes 'USE_ARM_NEON_ASPECT_CORRECTOR'
;;
androidsdl-armeabi | arm-*riscos | caanoo | ds | gp2x | gp2xwiz | maemo | tizen)
androidsdl-armeabi | arm-*riscos | caanoo | ds | gp2x | gp2xwiz | maemo )
define_in_config_if_yes yes 'USE_ARM_SCALER_ASM'
# FIXME: The following feature exhibits a bug. It produces distorted
# sound since 9003ce517ff9906b0288f9f7c02197fd091d4554. The ARM
@ -3142,12 +3130,6 @@ EOF
_optimization_level=-O3
fi
;;
tizen)
add_line_to_config_mk "TIZEN_ROOTSTRAP = $TIZEN_ROOTSTRAP"
append_var LDFLAGS "--sysroot=${TIZEN_ROOTSTRAP}"
append_var LDFLAGS "-L${TIZEN_LIBS}/lib"
append_var CXXFLAGS "-I${TIZEN_LIBS}/include"
;;
webos)
append_var CXXFLAGS "--sysroot=$WEBOS_PDK/arm-gcc/sysroot"
append_var CXXFLAGS "-I$WEBOS_PDK/include"
@ -3601,18 +3583,6 @@ if test -n "$_host"; then
_vkeybd=yes
_port_mk="backends/platform/sdl/switch/switch.mk"
;;
tizen)
_unix=yes
_backend="tizen"
_port_mk="backends/platform/tizen/tizen.mk"
_build_scalers=no
_seq_midi=no
_mt32emu=no
_timidity=no
_vkeybd=yes
# Tizen relies on the OpenGL ES output thus we always enable it.
_opengl_mode=gles
;;
webos)
_backend="webos"
_port_mk="backends/platform/webos/webos.mk"
@ -3799,25 +3769,6 @@ case $_backend in
_sdl=auto
append_var MODULES "backends/platform/sdl"
;;
tizen)
# dirent.h not available. NONSTANDARD_PORT==ensure portdefs.h is included
append_var DEFINES "-DTIZEN -DDISABLE_STDIO_FILESTREAM -DNONSTANDARD_PORT"
append_var DEFINES "-DNO_STDERR_STDOUT"
append_var DEFINES "-DDISABLE_COMMAND_LINE"
append_var INCLUDES '-I$(srcdir)/backends/platform/tizen'
append_var INCLUDES '-I$(TIZEN_ROOTSTRAP)/usr/include'
append_var INCLUDES '-I$(TIZEN_ROOTSTRAP)/usr/include/osp'
if test "$_debug_build" = yes; then
append_var CXXFLAGS "-D_DEBUG -DBUILD_DLL -O0 -g3"
fi
# created a shared library for inclusion via the eclipse build
append_var CXXFLAGS "-Wno-psabi"
append_var CXXFLAGS "--sysroot=${TIZEN_ROOTSTRAP}"
append_var CXXFLAGS "-fmessage-length=0"
append_var CXXFLAGS "-fPIC"
HOSTEXEPRE=lib
HOSTEXEEXT=.a
;;
webos)
# There is no sdl-config in the WebOS PDK so we don't use find_sdlconfig here.
# The PDL library acts as the WebOS device toolchain, and is required to control the virtual keyboard among other OS-level events.
@ -3970,7 +3921,7 @@ fi
# Enable 16bit support only for backends which support it
#
case $_backend in
3ds | android | androidsdl | dingux | dc | gph | iphone | ios7 | maemo | null | openpandora | psp | psp2 | samsungtv | sdl | switch | tizen | webos | wii)
3ds | android | androidsdl | dingux | dc | gph | iphone | ios7 | maemo | null | openpandora | psp | psp2 | samsungtv | sdl | switch | webos | wii)
if test "$_16bit" = auto ; then
_16bit=yes
else
@ -5341,11 +5292,6 @@ if test "$_opengl_mode" = auto ; then
esac
;;
tizen)
# Tizen always runs in GLES mode
_opengl_mode=gles
;;
*)
_opengl_mode=none
;;

4
doc/cz/PrectiMe
View file

@ -2052,10 +2052,6 @@ Na Windows můžete určit USE_WINDBG a připojit WinDbg pro procházení ladíc
Přečtěte si prosím:
<https://wiki.scummvm.org/index.php/Compiling_ScummVM/Atari/FreeMiNT>
Bada/Tizen:
Přečtěte si prosím:
<https://wiki.scummvm.org/index.php/Compiling_ScummVM/Bada/Tizen>
BeOS/ZETA/Haiku:
Přečtěte si prosím:
<https://wiki.scummvm.org/index.php/Compiling_ScummVM/BeOS/ZETA/Haiku>

4
doc/de/LIESMICH
View file

@ -3111,10 +3111,6 @@ Debug-Nachrichten zu durchsuchen
Weiterführende Informationen finden Sie unter:
https://wiki.scummvm.org/index.php/Compiling_ScummVM/Atari/FreeMiNT
Bada/Tizen:
Weiterführende Informationen finden Sie unter:
https://wiki.scummvm.org/index.php/Compiling_ScummVM/Bada/Tizen
BeOS/ZETA/Haiku:
Weiterführende Informationen finden Sie unter:
https://wiki.scummvm.org/index.php/Compiling_ScummVM/BeOS/ZETA/Haiku

2
po/POTFILES
View file

@ -86,7 +86,5 @@ backends/platform/maemo/maemo.cpp
backends/platform/sdl/macosx/appmenu_osx.mm
backends/platform/sdl/ps3/ps3.cpp
backends/platform/symbian/src/SymbianActions.cpp
backends/platform/tizen/form.cpp
backends/platform/tizen/fs.cpp
backends/platform/wii/options.cpp
backends/updates/macosx/macosx-updates.mm