libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2025-02-18 18:30:59 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #350 from chrisws/tizen_port_1_6_0a

Browse Source 
TIZEN: bada port updated to tizen

Conflicts:
	backends/platform/tizen/system.cpp
This commit is contained in:
Johannes Schickel 2013-07-04 23:30:22 +02:00
commit be61cb669a
32 changed files with 1282 additions and 1368 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
AUTHORS
View File

@ -238,9 +238,6 @@ ScummVM Team
Andre Heider
Angus Lees
BADA:
Chris Warren-Smith
Dreamcast:
Marcus Comstedt
@ -288,6 +285,9 @@ ScummVM Team
Jurgen Braam
Lars Persson
Tizen / BADA:
Chris Warren-Smith
WebOS:
Klaus Reimer

4
Makefile
View File

@ -32,8 +32,10 @@ ifeq "$(HAVE_GCC)" "1"
# being helpful.
#CXXFLAGS+= -Wmissing-format-attribute
# Disable RTTI and exceptions
ifneq "$(BACKEND)" "tizen"
# Disable RTTI and exceptions. These settings cause tizen apps to crash
CXXFLAGS+= -fno-rtti -fno-exceptions
endif
ifneq "$(HAVE_CLANG)" "1"
# enable checking of pointers returned by "new", but only when we do not

4
backends/graphics/opengl/gltexture.h
View File

@ -44,9 +44,9 @@
#define ARRAYSIZE(x) ((int)(sizeof(x) / sizeof(x[0])))
#endif
#if defined(BADA)
#if defined(TIZEN)
#include <FGraphicsOpengl.h>
using namespace Osp::Graphics::Opengl;
using namespace Tizen::Graphics::Opengl;
#elif defined(USE_GLES)
#include <GLES/gl.h>
#elif defined(SDL_BACKEND)

2
backends/modular-backend.cpp
View File

@ -53,7 +53,7 @@ bool ModularBackend::hasFeature(Feature f) {
}
void ModularBackend::setFeatureState(Feature f, bool enable) {
return _graphicsManager->setFeatureState(f, enable);
_graphicsManager->setFeatureState(f, enable);
}
bool ModularBackend::getFeatureState(Feature f) {

4
backends/module.mk
View File

@ -120,9 +120,9 @@ MODULE_OBJS += \
mixer/sdl13/sdl13-mixer.o
endif
ifeq ($(BACKEND),bada)
ifeq ($(BACKEND),tizen)
MODULE_OBJS += \
timer/bada/timer.o
timer/tizen/timer.o
endif
ifeq ($(BACKEND),ds)

5
backends/platform/bada/bada.mk
View File

@ -1,5 +0,0 @@
# Bada specific modules are built under eclipse
$(EXECUTABLE): $(OBJS)
rm -f $@
ar Tru $@ $(OBJS)

464
backends/platform/bada/form.cpp
View File

@ -1,464 +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 <FAppApplication.h>
#include "common/translation.h"
#include "base/main.h"
#include "backends/platform/bada/form.h"
#include "backends/platform/bada/system.h"
using namespace Osp::Base::Runtime;
using namespace Osp::Ui;
using namespace Osp::Ui::Controls;
// number of volume levels
#define LEVEL_RANGE 5
// 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 10
// 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
//
// BadaAppForm
//
BadaAppForm::BadaAppForm() :
_gameThread(0),
_state(kInitState),
_buttonState(kLeftButton),
_shortcut(kSetVolume) {
_eventQueueLock = new Mutex();
_eventQueueLock->Create();
}
result BadaAppForm::Construct() {
result r = Form::Construct(Controls::FORM_STYLE_NORMAL);
if (IsFailed(r)) {
return r;
}
BadaSystem *badaSystem = NULL;
_gameThread = NULL;
badaSystem = new BadaSystem(this);
r = badaSystem != NULL ? E_SUCCESS : E_OUT_OF_MEMORY;
if (!IsFailed(r)) {
r = badaSystem->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)) {
if (badaSystem != NULL) {
delete badaSystem;
}
if (_gameThread != NULL) {
delete _gameThread;
_gameThread = NULL;
}
} else {
g_system = badaSystem;
}
return r;
}
BadaAppForm::~BadaAppForm() {
logEntered();
if (_gameThread && _state != kErrorState) {
terminate();
_gameThread->Stop();
if (_state != kErrorState) {
_gameThread->Join();
}
delete _gameThread;
_gameThread = NULL;
}
if (_eventQueueLock) {
delete _eventQueueLock;
_eventQueueLock = NULL;
}
logLeaving();
}
//
// abort the game thread
//
void BadaAppForm::terminate() {
if (_state == kActiveState) {
((BadaSystem *)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 BadaAppForm::exitSystem() {
_state = kErrorState;
if (_gameThread) {
_gameThread->Stop();
delete _gameThread;
_gameThread = NULL;
}
}
result BadaAppForm::OnInitializing(void) {
logEntered();
SetOrientation(ORIENTATION_LANDSCAPE);
AddOrientationEventListener(*this);
AddTouchEventListener(*this);
AddKeyEventListener(*this);
// set focus to enable receiving key events
SetFocusable(true);
SetFocus();
return E_SUCCESS;
}
result BadaAppForm::OnDraw(void) {
logEntered();
if (g_system) {
BadaSystem *system = (BadaSystem *)g_system;
BadaGraphicsManager *graphics = system->getGraphics();
if (graphics && graphics->isReady()) {
g_system->updateScreen();
}
}
return E_SUCCESS;
}
bool BadaAppForm::pollEvent(Common::Event &event) {
bool result = false;
_eventQueueLock->Acquire();
if (!_eventQueue.empty()) {
event = _eventQueue.pop();
result = true;
}
_eventQueueLock->Release();
return result;
}
void BadaAppForm::pushEvent(Common::EventType type, const Point &currentPosition) {
BadaSystem *system = (BadaSystem *)g_system;
BadaGraphicsManager *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 BadaAppForm::pushKey(Common::KeyCode keycode) {
Common::Event e;
e.synthetic = false;
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 BadaAppForm::OnOrientationChanged(const Control &source,
OrientationStatus orientationStatus) {
logEntered();
if (_state == kInitState) {
_state = kActiveState;
_gameThread->Start();
}
}
Object *BadaAppForm::Run(void) {
scummvm_main(0, 0);
if (_state == kActiveState) {
Application::GetInstance()->SendUserEvent(USER_MESSAGE_EXIT, NULL);
}
_state = kDoneState;
return NULL;
}
void BadaAppForm::setButtonShortcut() {
switch (_buttonState) {
case kLeftButton:
g_system->displayMessageOnOSD(_("Right Click Once"));
_buttonState = kRightButtonOnce;
break;
case kRightButtonOnce:
g_system->displayMessageOnOSD(_("Right Click"));
_buttonState = kRightButton;
break;
case kRightButton:
g_system->displayMessageOnOSD(_("Move Only"));
_buttonState = kMoveOnly;
break;
case kMoveOnly:
g_system->displayMessageOnOSD(_("Left Click"));
_buttonState = kLeftButton;
break;
}
}
void BadaAppForm::setShortcut() {
// cycle to the next shortcut
switch (_shortcut) {
case kControlMouse:
g_system->displayMessageOnOSD(_("Escape Key"));
_shortcut = kEscapeKey;
break;
case kEscapeKey:
g_system->displayMessageOnOSD(_("Game Menu"));
_shortcut = kGameMenu;
break;
case kGameMenu:
g_system->displayMessageOnOSD(_("Show Keypad"));
_shortcut = kShowKeypad;
break;
case kSetVolume:
// fallthru
case kShowKeypad:
g_system->displayMessageOnOSD(_("Control Mouse"));
_shortcut = kControlMouse;
break;
}
}
void BadaAppForm::setVolume(bool up, bool minMax) {
int level = ((BadaSystem *)g_system)->setVolume(up, minMax);
if (level != -1) {
char message[32];
char ind[LEVEL_RANGE]; // 1..5 (0=off)
int j = LEVEL_RANGE - 1; // 0..4
for (int i = 1; i <= LEVEL_RANGE; i++) {
ind[j--] = level >= i ? '|' : ' ';
}
snprintf(message, sizeof(message), "Volume: [ %c%c%c%c%c ]",
ind[0], ind[1], ind[2], ind[3], ind[4]);
g_system->displayMessageOnOSD(message);
}
}
void BadaAppForm::showKeypad() {
// display the soft keyboard
_buttonState = kLeftButton;
pushKey(Common::KEYCODE_F7);
}
void BadaAppForm::OnTouchDoublePressed(const Control &source,
const Point &currentPosition,
const TouchEventInfo &touchInfo) {
if (_buttonState != kMoveOnly) {
pushEvent(_buttonState == kLeftButton ? Common::EVENT_LBUTTONDOWN : Common::EVENT_RBUTTONDOWN,
currentPosition);
pushEvent(_buttonState == kLeftButton ? Common::EVENT_LBUTTONDOWN : Common::EVENT_RBUTTONDOWN,
currentPosition);
}
}
void BadaAppForm::OnTouchFocusIn(const Control &source,
const Point &currentPosition,
const TouchEventInfo &touchInfo) {
}
void BadaAppForm::OnTouchFocusOut(const Control &source,
const Point &currentPosition,
const TouchEventInfo &touchInfo) {
}
void BadaAppForm::OnTouchLongPressed(const Control &source,
const Point &currentPosition,
const TouchEventInfo &touchInfo) {
if (_buttonState != kLeftButton) {
pushKey(Common::KEYCODE_RETURN);
}
}
void BadaAppForm::OnTouchMoved(const Control &source,
const Point &currentPosition,
const TouchEventInfo &touchInfo) {
pushEvent(Common::EVENT_MOUSEMOVE, currentPosition);
}
void BadaAppForm::OnTouchPressed(const Control &source,
const Point &currentPosition,
const TouchEventInfo &touchInfo) {
if (_buttonState != kMoveOnly) {
pushEvent(_buttonState == kLeftButton ? Common::EVENT_LBUTTONDOWN : Common::EVENT_RBUTTONDOWN,
currentPosition);
}
}
void BadaAppForm::OnTouchReleased(const Control &source,
const Point &currentPosition,
const TouchEventInfo &touchInfo) {
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 BadaAppForm::OnKeyLongPressed(const Control &source, KeyCode keyCode) {
logEntered();
switch (keyCode) {
case KEY_SIDE_UP:
_shortcut = kSetVolume;
setVolume(true, true);
return;
case KEY_SIDE_DOWN:
_shortcut = kSetVolume;
setVolume(false, true);
return;
case KEY_CAMERA:
_shortcut = kShowKeypad;
showKeypad();
return;
default:
break;
}
}
void BadaAppForm::OnKeyPressed(const Control &source, KeyCode keyCode) {
switch (keyCode) {
case KEY_SIDE_UP:
if (_shortcut != kSetVolume) {
_shortcut = kSetVolume;
} else {
setVolume(true, false);
}
return;
case KEY_SIDE_DOWN:
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;
default:
setVolume(false, false);
break;
}
break;
case KEY_CAMERA:
setShortcut();
break;
default:
break;
}
}
void BadaAppForm::OnKeyReleased(const Control &source, KeyCode keyCode) {
}

108
backends/platform/bada/form.h
View File

@ -1,108 +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 BADA_FORM_H
#define BADA_FORM_H
#include <FApp.h>
#include <FUi.h>
#include <FSystem.h>
#include <FBase.h>
#include <FUiITouchEventListener.h>
#include <FUiITextEventListener.h>
#include "config.h"
#include "common/scummsys.h"
#include "common/events.h"
#include "common/queue.h"
#include "common/mutex.h"
//
// BadaAppForm
//
class BadaAppForm : public Osp::Ui::Controls::Form,
public Osp::Ui::IOrientationEventListener,
public Osp::Ui::ITouchEventListener,
public Osp::Ui::IKeyEventListener,
public Osp::Base::Runtime::IRunnable {
public:
BadaAppForm();
~BadaAppForm();
result Construct();
bool pollEvent(Common::Event &event);
bool isClosing() { return _state == kClosingState; }
void pushKey(Common::KeyCode keycode);
void exitSystem();
private:
Object *Run();
result OnInitializing(void);
result OnDraw(void);
void OnOrientationChanged(const Osp::Ui::Control &source,
Osp::Ui::OrientationStatus orientationStatus);
void OnTouchDoublePressed(const Osp::Ui::Control &source,
const Osp::Graphics::Point &currentPosition,
const Osp::Ui::TouchEventInfo &touchInfo);
void OnTouchFocusIn(const Osp::Ui::Control &source,
const Osp::Graphics::Point &currentPosition,
const Osp::Ui::TouchEventInfo &touchInfo);
void OnTouchFocusOut(const Osp::Ui::Control &source,
const Osp::Graphics::Point &currentPosition,
const Osp::Ui::TouchEventInfo &touchInfo);
void OnTouchLongPressed(const Osp::Ui::Control &source,
const Osp::Graphics::Point &currentPosition,
const Osp::Ui::TouchEventInfo &touchInfo);
void OnTouchMoved(const Osp::Ui::Control &source,
const Osp::Graphics::Point &currentPosition,
const Osp::Ui::TouchEventInfo &touchInfo);
void OnTouchPressed(const Osp::Ui::Control &source,
const Osp::Graphics::Point &currentPosition,
const Osp::Ui::TouchEventInfo &touchInfo);
void OnTouchReleased(const Osp::Ui::Control &source,
const Osp::Graphics::Point &currentPosition,
const Osp::Ui::TouchEventInfo &touchInfo);
void OnKeyLongPressed(const Osp::Ui::Control &source,
Osp::Ui::KeyCode keyCode);
void OnKeyPressed(const Osp::Ui::Control &source,
Osp::Ui::KeyCode keyCode);
void OnKeyReleased(const Osp::Ui::Control &source,
Osp::Ui::KeyCode keyCode);
void pushEvent(Common::EventType type,
const Osp::Graphics::Point &currentPosition);
void terminate();
void setButtonShortcut();
void setShortcut();
void setVolume(bool up, bool minMax);
void showKeypad();
// event handling
Osp::Base::Runtime::Thread *_gameThread;
Osp::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, kSetVolume } _shortcut;
};
#endif

136
backends/platform/bada/README.TXT → backends/platform/tizen/README.TXT
View File

@ -1,4 +1,79 @@
Build instructions:
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:
http://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):
@ -31,62 +106,3 @@ Build instructions:
gcc:
#!/bin/sh
${ARM_BIN}/arm-samsung-nucleuseabi-gcc.exe $*
3. Build dependencies
zlib, libogg, libvorbis, libmad, FLAC
see: "Building the libraries" under:
http://wiki.scummvm.org/index.php/Compiling_ScummVM/MinGW#Building_the_libraries
for instructions on how to obtain these modules
3.1 For Target-Release configure ogg and mad with:
./configure --host=arm-samsung-nucleuseabi --disable-shared
when building vorbis and flac:
./configure --host=arm-samsung-nucleuseabi --disable-shared --with-ogg=c:/cygwin/usr/local
3.2 for each module, after a successful configure, add the following
to the generated config.h (gzguts.h for zlib)
#undef __MINGW32__
#undef _WIN32
#include "c:/src/scummvm/backends/platform/bada/portdefs.h"
3.3 Additional post configure edits:
- removed -fforce-mem from the libMAD Makefile
- in libvorbis/lib/Makefile comment lines with vorbis_selftests
- edit libFLAC/Makefile ... CFLAGS = $(OGG_CFLAGS)
Note: you can ignore the ranlib errors when doing make install.
4. Build the ScummVM base library:
./configure --host=bada --enable-release
To target the Win32 simulator:
./configure --host=bada --enable-debug
5. Build the front end application using BADA-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

83
backends/platform/bada/application.cpp → backends/platform/tizen/application.cpp
View File

@ -22,43 +22,55 @@
#include "engines/engine.h"
#include "backends/platform/bada/form.h"
#include "backends/platform/bada/system.h"
#include "backends/platform/bada/application.h"
#include "backends/platform/tizen/form.h"
#include "backends/platform/tizen/system.h"
#include "backends/platform/tizen/application.h"
using namespace Osp::System;
using namespace Osp::Ui::Controls;
Application *BadaScummVM::createInstance() {
return new BadaScummVM();
Application *TizenScummVM::createInstance() {
logEntered();
return new TizenScummVM();
}
BadaScummVM::BadaScummVM() : _appForm(0) {
TizenScummVM::TizenScummVM() : _appForm(0) {
logEntered();
}
BadaScummVM::~BadaScummVM() {
TizenScummVM::~TizenScummVM() {
logEntered();
if (g_system) {
BadaSystem *system = (BadaSystem *)g_system;
TizenSystem *system = (TizenSystem *)g_system;
system->destroyBackend();
delete system;
g_system = 0;
}
}
bool BadaScummVM::OnAppInitializing(AppRegistry &appRegistry) {
_appForm = systemStart(this);
return (_appForm != NULL);
bool TizenScummVM::OnAppInitialized(void) {
logEntered();
_appForm->SetOrientation(Tizen::Ui::ORIENTATION_LANDSCAPE);
return true;
}
bool BadaScummVM::OnAppTerminating(AppRegistry &appRegistry,
bool forcedTermination) {
bool TizenScummVM::OnAppWillTerminate(void) {
logEntered();
return true;
}
void BadaScummVM::OnUserEventReceivedN(RequestId requestId,
Osp::Base::Collection::IList *args) {
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) {
MessageBox messageBox;
int modalResult;
logEntered();
if (requestId == USER_MESSAGE_EXIT) {
@ -73,39 +85,56 @@ void BadaScummVM::OnUserEventReceivedN(RequestId requestId,
if (!message) {
message = new String("Unknown error");
}
MessageBox messageBox;
messageBox.Construct(L"Oops...", *message, MSGBOX_STYLE_OK);
int modalResult;
messageBox.ShowAndWait(modalResult);
Terminate();
} else if (requestId == 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();
}
}
void BadaScummVM::OnForeground(void) {
void TizenScummVM::OnForeground(void) {
logEntered();
pauseGame(false);
}
void BadaScummVM::OnBackground(void) {
void TizenScummVM::OnBackground(void) {
logEntered();
pauseGame(true);
}
void BadaScummVM::OnBatteryLevelChanged(BatteryLevel batteryLevel) {
void TizenScummVM::OnBatteryLevelChanged(BatteryLevel batteryLevel) {
logEntered();
}
void BadaScummVM::OnLowMemory(void) {
void TizenScummVM::OnLowMemory(void) {
logEntered();
}
void BadaScummVM::pauseGame(bool pause) {
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) {
((BadaSystem *)g_system)->setMute(pause);
((TizenSystem *)g_system)->setMute(pause);
}
}
}

45
backends/platform/bada/application.h → backends/platform/tizen/application.h
View File

@ -20,8 +20,8 @@
*
*/
#ifndef BADA_APPLICATION_H
#define BADA_APPLICATION_H
#ifndef TIZEN_APPLICATION_H
#define TIZEN_APPLICATION_H
#include <FBase.h>
#include <FApp.h>
@ -29,26 +29,41 @@
#include <FUi.h>
#include <FSystem.h>
#include "backends/platform/bada/system.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 {
class BadaScummVM : public Osp::App::Application {
public:
BadaScummVM();
~BadaScummVM();
TizenScummVM();
virtual ~TizenScummVM();
static Osp::App::Application *createInstance(void);
static UiApp *createInstance(void);
bool OnAppInitializing(Osp::App::AppRegistry &appRegistry);
bool OnAppTerminating(Osp::App::AppRegistry &appRegistry, bool forcedTermination = false);
void OnForeground(void);
void OnBackground(void);
void OnLowMemory(void);
void OnBatteryLevelChanged(Osp::System::BatteryLevel batteryLevel);
void OnUserEventReceivedN(RequestId requestId, Osp::Base::Collection::IList *pArgs);
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);
BadaAppForm *_appForm;
TizenAppForm *_appForm;
};
#endif

111
backends/platform/bada/audio.cpp → backends/platform/tizen/audio.cpp
View File

@ -23,18 +23,11 @@
#include <FSysSettingInfo.h>
#include <FAppAppRegistry.h>
#include "backends/platform/bada/audio.h"
#include "backends/platform/bada/system.h"
#include "backends/platform/tizen/audio.h"
#include "backends/platform/tizen/system.h"
#define TIMER_INCREMENT 10
#define TIMER_INTERVAL 40
#define MIN_TIMER_INTERVAL 10
#define MAX_TIMER_INTERVAL 160
#define INIT_LEVEL 3
#define CONFIG_KEY L"audiovol"
// sound level pre-sets
const int levels[] = {0, 1, 10, 45, 70, 99};
#define TIMER_INTERVAL 10
#define VOLUME 99
AudioThread::AudioThread() :
_mixer(0),
@ -51,9 +44,7 @@ AudioThread::AudioThread() :
Audio::MixerImpl *AudioThread::Construct(OSystem *system) {
logEntered();
if (IsFailed(Thread::Construct(THREAD_TYPE_EVENT_DRIVEN,
DEFAULT_STACK_SIZE,
THREAD_PRIORITY_HIGH))) {
if (IsFailed(EventDrivenThread::Construct(DEFAULT_STACK_SIZE, THREAD_PRIORITY_HIGH))) {
AppLog("Failed to create AudioThread");
return NULL;
}
@ -69,7 +60,7 @@ AudioThread::~AudioThread() {
bool AudioThread::isSilentMode() {
bool silentMode;
String key(L"SilentMode");
Osp::System::SettingInfo::GetValue(key, silentMode);
Tizen::System::SettingInfo::GetValue(key, silentMode);
return silentMode;
}
@ -79,59 +70,16 @@ void AudioThread::setMute(bool on) {
if (on) {
_timer->Cancel();
} else {
_timer->Start(_interval);
_timer->StartAsRepeatable(_interval);
}
}
}
int AudioThread::setVolume(bool up, bool minMax) {
int level = -1;
int numLevels = sizeof(levels) / sizeof(levels[0]);
if (_audioOut) {
int volume = _audioOut->GetVolume();
if (minMax) {
level = up ? numLevels - 1 : 0;
volume = levels[level];
} else {
// adjust volume to be one of the preset values
for (int i = 0; i < numLevels && level == -1; i++) {
if (volume == levels[i]) {
level = i;
if (up) {
if (i + 1 < numLevels) {
level = i + 1;
}
} else if (i > 0) {
level = i - 1;
}
}
}
// default to INIT_LEVEL when current not preset value
if (level == -1) {
level = INIT_LEVEL;
}
volume = levels[level];
}
_audioOut->SetVolume(volume);
// remember the chosen setting
AppRegistry *registry = Application::GetInstance()->GetAppRegistry();
if (registry) {
registry->Set(CONFIG_KEY, volume);
}
}
return level;
}
bool AudioThread::OnStart(void) {
logEntered();
_audioOut = new Osp::Media::AudioOut();
if (!_audioOut ||
IsFailed(_audioOut->Construct(*this))) {
_audioOut = new Tizen::Media::AudioOut();
if (!_audioOut || IsFailed(_audioOut->Construct(*this))) {
AppLog("Failed to create AudioOut");
return false;
}
@ -144,8 +92,7 @@ bool AudioThread::OnStart(void) {
}
if (IsFailed(_audioOut->Prepare(AUDIO_TYPE_PCM_S16_LE,
AUDIO_CHANNEL_TYPE_STEREO,
sampleRate))) {
AUDIO_CHANNEL_TYPE_STEREO, sampleRate))) {
AppLog("Failed to prepare AudioOut %d", sampleRate);
return false;
}
@ -164,26 +111,14 @@ bool AudioThread::OnStart(void) {
return false;
}
if (IsFailed(_timer->Start(_interval))) {
if (IsFailed(_timer->StartAsRepeatable(_interval))) {
AppLog("failed to start audio timer");
return false;
}
// get the volume from the app-registry
int volume = levels[INIT_LEVEL];
AppRegistry *registry = Application::GetInstance()->GetAppRegistry();
if (registry) {
if (E_KEY_NOT_FOUND == registry->Get(CONFIG_KEY, volume)) {
registry->Add(CONFIG_KEY, volume);
volume = levels[INIT_LEVEL];
} else {
AppLog("Setting volume: %d", volume);
}
}
_muted = false;
_mixer->setReady(true);
_audioOut->SetVolume(isSilentMode() ? 0 : volume);
_audioOut->SetVolume(isSilentMode() ? 0 : VOLUME);
_audioOut->Start();
return true;
}
@ -206,20 +141,20 @@ void AudioThread::OnStop(void) {
}
}
void AudioThread::OnAudioOutErrorOccurred(Osp::Media::AudioOut &src, result r) {
void AudioThread::OnAudioOutErrorOccurred(Tizen::Media::AudioOut &src, result r) {
logEntered();
}
void AudioThread::OnAudioOutInterrupted(Osp::Media::AudioOut &src) {
void AudioThread::OnAudioOutInterrupted(Tizen::Media::AudioOut &src) {
logEntered();
}
void AudioThread::OnAudioOutReleased(Osp::Media::AudioOut &src) {
void AudioThread::OnAudioOutReleased(Tizen::Media::AudioOut &src) {
logEntered();
_audioOut->Start();
}
void AudioThread::OnAudioOutBufferEndReached(Osp::Media::AudioOut &src) {
void AudioThread::OnAudioOutBufferEndReached(Tizen::Media::AudioOut &src) {
if (_ready > 0) {
_playing = _tail;
_audioOut->WriteBuffer(_audioBuffer[_tail]);
@ -228,10 +163,6 @@ void AudioThread::OnAudioOutBufferEndReached(Osp::Media::AudioOut &src) {
} else {
// audio buffer empty: decrease timer inverval
_playing = -1;
_interval -= TIMER_INCREMENT;
if (_interval < MIN_TIMER_INTERVAL) {
_interval = MIN_TIMER_INTERVAL;
}
}
}
@ -243,18 +174,8 @@ void AudioThread::OnTimerExpired(Timer &timer) {
_head = (_head + 1) % NUM_AUDIO_BUFFERS;
_ready++;
}
} else {
// audio buffer full: increase timer inverval
_interval += TIMER_INCREMENT;
if (_interval > MAX_TIMER_INTERVAL) {
_interval = MAX_TIMER_INTERVAL;
}
}
if (_ready && _playing == -1) {
OnAudioOutBufferEndReached(*_audioOut);
}
_timer->Start(_interval);
}

37
backends/platform/bada/audio.h → backends/platform/tizen/audio.h
View File

@ -20,8 +20,8 @@
*
*/
#ifndef BADA_AUDIO_H
#define BADA_AUDIO_H
#ifndef TIZEN_AUDIO_H
#define TIZEN_AUDIO_H
#include <FBase.h>
#include <FMedia.h>
@ -33,17 +33,19 @@
#include "common/system.h"
#include "audio/mixer_intern.h"
using namespace Osp::Base;
using namespace Osp::Base::Collection;
using namespace Osp::Base::Runtime;
using namespace Osp::Media;
using namespace Osp::Io;
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 Osp::Media::IAudioOutEventListener,
public Osp::Base::Runtime::ITimerEventListener,
public Osp::Base::Runtime::Thread {
class AudioThread:
public Tizen::Media::IAudioOutEventListener,
public Tizen::Base::Runtime::ITimerEventListener,
public Tizen::Base::Runtime::EventDrivenThread {
public:
AudioThread(void);
~AudioThread(void);
@ -51,21 +53,20 @@ public:
Audio::MixerImpl *Construct(OSystem *system);
bool isSilentMode();
void setMute(bool on);
int setVolume(bool up, bool minMax);
bool OnStart(void);
void OnStop(void);
void OnAudioOutErrorOccurred(Osp::Media::AudioOut &src, result r);
void OnAudioOutInterrupted(Osp::Media::AudioOut &src);
void OnAudioOutReleased(Osp::Media::AudioOut &src);
void OnAudioOutBufferEndReached(Osp::Media::AudioOut &src);
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);
private:
Audio::MixerImpl *_mixer;
Osp::Base::Runtime::Timer *_timer;
Osp::Media::AudioOut *_audioOut;
Osp::Base::ByteBuffer _audioBuffer[NUM_AUDIO_BUFFERS];
Tizen::Base::Runtime::Timer *_timer;
Tizen::Media::AudioOut *_audioOut;
Tizen::Base::ByteBuffer _audioBuffer[NUM_AUDIO_BUFFERS];
int _head, _tail, _ready, _interval, _playing;
bool _muted;
};

419
backends/platform/tizen/form.cpp Normal file
View File

@ -0,0 +1,419 @@
/* 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(kShowKeypad) {
}
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);
// 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.synthetic = false;
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;
pushKey(Common::KEYCODE_F7);
}
}
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);
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);
}
}
}

113
backends/platform/tizen/form.h Normal file
View File

@ -0,0 +1,113 @@
/* 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 "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;
//
// TizenAppForm
//
class TizenAppForm :
public Controls::Form,
public IRunnable,
public IOrientationEventListener,
public ITouchEventListener {
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 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

294
backends/platform/bada/fs.cpp → backends/platform/tizen/fs.cpp
View File

@ -20,33 +20,38 @@
*/
#include "config.h"
#include "backends/platform/bada/system.h"
#include "backends/platform/bada/fs.h"
#include "common/translation.h"
#include "backends/platform/tizen/system.h"
#include "backends/platform/tizen/fs.h"
#include <FAppApp.h>
#define BUFFER_SIZE 1024
// internal BADA paths
#define PATH_ROOT "/"
#define PATH_HOME "/Home"
#define PATH_HOME_SHARE "/Home/Share"
#define PATH_HOME_SHARE2 "/Home/Share2"
#define PATH_HOME_X "/Home/"
#define PATH_HOME_EXT "/HomeExt"
#define PATH_MEDIA "/Media"
#define PATH_CARD "/Storagecard"
#define PATH_CARD_MEDIA "/Storagecard/Media"
using namespace Tizen::App;
//
// BadaFileStream
// converts a Tizen (wchar) String into a scummVM (char) string
//
class BadaFileStream : public Common::SeekableReadStream,
public Common::WriteStream,
public Common::NonCopyable {
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 BadaFileStream *makeFromPath(const String &path, bool writeMode);
static TizenFileStream *makeFromPath(const String &path, bool writeMode);
BadaFileStream(File *file, bool writeMode);
~BadaFileStream();
TizenFileStream(File *file, bool writeMode);
~TizenFileStream();
bool err() const;
void clearErr();
@ -61,81 +66,81 @@ public:
uint32 read(void *dataPtr, uint32 dataSize);
private:
byte buffer[BUFFER_SIZE];
uint32 bufferIndex;
uint32 bufferLength;
bool writeMode;
File *file;
byte _buffer[BUFFER_SIZE];
uint32 _bufferIndex;
uint32 _bufferLength;
bool _writeMode;
File *_file;
};
BadaFileStream::BadaFileStream(File *ioFile, bool writeMode) :
bufferIndex(0),
bufferLength(0),
writeMode(writeMode),
file(ioFile) {
TizenFileStream::TizenFileStream(File *ioFile, bool writeMode) :
_bufferIndex(0),
_bufferLength(0),
_writeMode(writeMode),
_file(ioFile) {
AppAssert(ioFile != 0);
}
BadaFileStream::~BadaFileStream() {
if (file) {
if (writeMode) {
TizenFileStream::~TizenFileStream() {
if (_file) {
if (_writeMode) {
flush();
}
delete file;
delete _file;
}
}
bool BadaFileStream::err() const {
bool TizenFileStream::err() const {
result r = GetLastResult();
return (r != E_SUCCESS && r != E_END_OF_FILE);
}
void BadaFileStream::clearErr() {
void TizenFileStream::clearErr() {
SetLastResult(E_SUCCESS);
}
bool BadaFileStream::eos() const {
return (bufferLength - bufferIndex == 0) && (GetLastResult() == E_END_OF_FILE);
bool TizenFileStream::eos() const {
return (_bufferLength - _bufferIndex == 0) && (GetLastResult() == E_END_OF_FILE);
}
int32 BadaFileStream::pos() const {
return file->Tell() - (bufferLength - bufferIndex);
int32 TizenFileStream::pos() const {
return _file->Tell() - (_bufferLength - _bufferIndex);
}
int32 BadaFileStream::size() const {
int32 oldPos = file->Tell();
file->Seek(FILESEEKPOSITION_END, 0);
int32 TizenFileStream::size() const {
int32 oldPos = _file->Tell();
_file->Seek(FILESEEKPOSITION_END, 0);
int32 length = file->Tell();
SetLastResult(file->Seek(FILESEEKPOSITION_BEGIN, oldPos));
int32 length = _file->Tell();
SetLastResult(_file->Seek(FILESEEKPOSITION_BEGIN, oldPos));
return length;
}
bool BadaFileStream::seek(int32 offs, int whence) {
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));
SetLastResult(_file->Seek(FILESEEKPOSITION_BEGIN, offs));
result = (E_SUCCESS == GetLastResult());
break;
case SEEK_CUR:
// set relative to offs
if (bufferIndex < bufferLength && bufferIndex > (uint32)-offs) {
if (_bufferIndex < _bufferLength && _bufferIndex > (uint32)-offs) {
// re-position within the buffer
SetLastResult(E_SUCCESS);
bufferIndex += offs;
_bufferIndex += offs;
return true;
} else {
offs -= (bufferLength - bufferIndex);
if (offs < 0 && file->Tell() + offs < 0) {
offs -= (_bufferLength - _bufferIndex);
if (offs < 0 && _file->Tell() + offs < 0) {
// avoid negative positioning
offs = 0;
}
if (offs != 0) {
SetLastResult(file->Seek(FILESEEKPOSITION_CURRENT, offs));
SetLastResult(_file->Seek(FILESEEKPOSITION_CURRENT, offs));
result = (E_SUCCESS == GetLastResult());
} else {
result = true;
@ -145,7 +150,7 @@ bool BadaFileStream::seek(int32 offs, int whence) {
case SEEK_END:
// set relative to end - positive will increase the file size
SetLastResult(file->Seek(FILESEEKPOSITION_END, offs));
SetLastResult(_file->Seek(FILESEEKPOSITION_END, offs));
result = (E_SUCCESS == GetLastResult());
break;
@ -158,46 +163,46 @@ bool BadaFileStream::seek(int32 offs, int whence) {
AppLog("seek failed");
}
bufferIndex = bufferLength = 0;
_bufferIndex = _bufferLength = 0;
return result;
}
uint32 BadaFileStream::read(void *ptr, uint32 len) {
uint32 TizenFileStream::read(void *ptr, uint32 len) {
uint32 result = 0;
if (!eos()) {
if (bufferIndex < bufferLength) {
if (_bufferIndex < _bufferLength) {
// use existing buffer
uint32 available = bufferLength - bufferIndex;
uint32 available = _bufferLength - _bufferIndex;
if (len <= available) {
// use allocation
memcpy((byte *)ptr, &buffer[bufferIndex], len);
bufferIndex += len;
memcpy((byte *)ptr, &_buffer[_bufferIndex], len);
_bufferIndex += len;
result = len;
} else {
// use remaining allocation
memcpy((byte *)ptr, &buffer[bufferIndex], available);
memcpy((byte *)ptr, &_buffer[_bufferIndex], available);
uint32 remaining = len - available;
result = available;
if (remaining) {
result += file->Read(((byte *)ptr) + available, remaining);
result += _file->Read(((byte *)ptr) + available, remaining);
}
bufferIndex = bufferLength = 0;
_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;
_bufferIndex = 0;
_bufferLength = _file->Read(_buffer, BUFFER_SIZE);
if (_bufferLength) {
if (_bufferLength < len) {
len = _bufferLength;
}
memcpy((byte *)ptr, buffer, len);
result = bufferIndex = len;
memcpy((byte *)ptr, _buffer, len);
result = _bufferIndex = len;
}
} else {
result = file->Read((byte *)ptr, len);
bufferIndex = bufferLength = 0;
result = _file->Read((byte *)ptr, len);
_bufferIndex = _bufferLength = 0;
}
} else {
AppLog("Attempted to read past EOS");
@ -205,59 +210,77 @@ uint32 BadaFileStream::read(void *ptr, uint32 len) {
return result;
}
uint32 BadaFileStream::write(const void *ptr, uint32 len) {
result r = file->Write(ptr, len);
uint32 TizenFileStream::write(const void *ptr, uint32 len) {
result r = _file->Write(ptr, len);
SetLastResult(r);
return (r == E_SUCCESS ? len : 0);
}
bool BadaFileStream::flush() {
bool TizenFileStream::flush() {
logEntered();
SetLastResult(file->Flush());
SetLastResult(_file->Flush());
return (E_SUCCESS == GetLastResult());
}
BadaFileStream *BadaFileStream::makeFromPath(const String &path, bool writeMode) {
TizenFileStream *TizenFileStream::makeFromPath(const String &path, bool writeMode) {
File *ioFile = new File();
String filePath = path;
if (writeMode && (path[0] != '.' && path[0] != '/')) {
filePath.Insert(PATH_HOME_X, 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) {
return new BadaFileStream(ioFile, writeMode);
stream = new TizenFileStream(ioFile, writeMode);
} else {
AppLog("Failed to open file");
delete ioFile;
stream = NULL;
}
AppLog("Failed to open file");
delete ioFile;
return 0;
return stream;
}
//
// converts a bada (wchar) String into a scummVM (char) string
// TizenFilesystemNode
//
Common::String fromString(const Osp::Base::String &in) {
ByteBuffer *buf = StringUtil::StringToUtf8N(in);
Common::String result((const char*)buf->GetPointer());
delete buf;
return result;
}
//
// BadaFilesystemNode
//
BadaFilesystemNode::BadaFilesystemNode(const Common::String &nodePath) {
TizenFilesystemNode::TizenFilesystemNode(const Common::String &nodePath) {
AppAssert(nodePath.size() > 0);
init(nodePath);
}
BadaFilesystemNode::BadaFilesystemNode(const Common::String &root,
const Common::String &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('/'));
@ -272,71 +295,54 @@ BadaFilesystemNode::BadaFilesystemNode(const Common::String &root,
init(newPath);
}
void BadaFilesystemNode::init(const Common::String &nodePath) {
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 == PATH_ROOT ||
_path == PATH_HOME ||
_path == PATH_HOME_SHARE ||
_path == PATH_HOME_SHARE2 ||
_path == PATH_CARD);
_isVirtualDir = (_path == "/");
_isValid = _isVirtualDir || !IsFailed(File::GetAttributes(_unicodePath, _attr));
}
bool BadaFilesystemNode::exists() const {
bool TizenFilesystemNode::exists() const {
return _isValid;
}
bool BadaFilesystemNode::isReadable() const {
bool TizenFilesystemNode::isReadable() const {
return _isVirtualDir || _isValid;
}
bool BadaFilesystemNode::isDirectory() const {
bool TizenFilesystemNode::isDirectory() const {
return _isVirtualDir || (_isValid && _attr.IsDirectory());
}
bool BadaFilesystemNode::isWritable() const {
bool result = (_isValid && !_isVirtualDir && !_attr.IsDirectory() && !_attr.IsReadOnly());
if (_path == PATH_HOME ||
_path == PATH_HOME_EXT ||
_path == PATH_HOME_SHARE ||
_path == PATH_HOME_SHARE2) {
result = true;
bool TizenFilesystemNode::isWritable() const {
bool result = (_isValid && !_attr.IsReadOnly());
if (_unicodePath == App::GetInstance()->GetAppResourcePath()) {
result = false;
}
return result;
}
AbstractFSNode *BadaFilesystemNode::getChild(const Common::String &n) const {
AbstractFSNode *TizenFilesystemNode::getChild(const Common::String &n) const {
AppAssert(!_path.empty());
AppAssert(isDirectory());
return new BadaFilesystemNode(_path, n);
return new TizenFilesystemNode(_path, n);
}
bool BadaFilesystemNode::getChildren(AbstractFSList &myList,
ListMode mode, bool hidden) const {
bool TizenFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool hidden) const {
AppAssert(isDirectory());
bool result = false;
if (_isVirtualDir && mode != Common::FSNode::kListFilesOnly) {
// present well known BADA file system areas
if (_path == PATH_ROOT) {
myList.push_back(new BadaFilesystemNode(PATH_HOME));
myList.push_back(new BadaFilesystemNode(PATH_HOME_EXT));
myList.push_back(new BadaFilesystemNode(PATH_MEDIA));
myList.push_back(new BadaFilesystemNode(PATH_CARD));
result = true; // no more entries
} else if (_path == PATH_CARD) {
myList.push_back(new BadaFilesystemNode(PATH_CARD_MEDIA));
result = true; // no more entries
} else if (_path == PATH_HOME) {
// ensure share path is always included
myList.push_back(new BadaFilesystemNode(PATH_HOME_SHARE));
myList.push_back(new BadaFilesystemNode(PATH_HOME_SHARE2));
}
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(kResource));
myList.push_back(new TizenFilesystemNode(kSdCard));
myList.push_back(new TizenFilesystemNode(kMedia));
myList.push_back(new TizenFilesystemNode(kShared));
}
if (!result) {
@ -358,7 +364,7 @@ bool BadaFilesystemNode::getChildren(AbstractFSList &myList,
DirEntry dirEntry = pDirEnum->GetCurrentDirEntry();
// skip 'invisible' files if necessary
Osp::Base::String fileName = dirEntry.GetName();
Tizen::Base::String fileName = dirEntry.GetName();
if (fileName[0] == '.' && !hidden) {
continue;
@ -374,7 +380,7 @@ bool BadaFilesystemNode::getChildren(AbstractFSList &myList,
(mode == Common::FSNode::kListDirectoriesOnly && !dirEntry.IsDirectory())) {
continue;
}
myList.push_back(new BadaFilesystemNode(_path, fromString(fileName)));
myList.push_back(new TizenFilesystemNode(_path, ::fromString(fileName)));
}
}
@ -392,9 +398,9 @@ bool BadaFilesystemNode::getChildren(AbstractFSList &myList,
return result;
}
AbstractFSNode *BadaFilesystemNode::getParent() const {
logEntered();
if (_path == PATH_ROOT) {
AbstractFSNode *TizenFilesystemNode::getParent() const {
logEntered();
if (_path == "/") {
return 0; // The filesystem root has no parent
}
@ -412,22 +418,22 @@ AbstractFSNode *BadaFilesystemNode::getParent() const {
// 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 0;
return NULL;
}
return new BadaFilesystemNode(Common::String(start, end));
return new TizenFilesystemNode(Common::String(start, end));
}
Common::SeekableReadStream *BadaFilesystemNode::createReadStream() {
Common::SeekableReadStream *result = BadaFileStream::makeFromPath(_unicodePath, false);
Common::SeekableReadStream *TizenFilesystemNode::createReadStream() {
Common::SeekableReadStream *result = TizenFileStream::makeFromPath(_unicodePath, false);
if (result != NULL) {
_isValid = !IsFailed(File::GetAttributes(_unicodePath, _attr));
}
return result;
}
Common::WriteStream *BadaFilesystemNode::createWriteStream() {
Common::WriteStream *result = BadaFileStream::makeFromPath(_unicodePath, true);
Common::WriteStream *TizenFilesystemNode::createWriteStream() {
Common::WriteStream *result = TizenFileStream::makeFromPath(_unicodePath, true);
if (result != NULL) {
_isValid = !IsFailed(File::GetAttributes(_unicodePath, _attr));
}

38
backends/platform/bada/fs.h → backends/platform/tizen/fs.h
View File

@ -19,8 +19,8 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef BADA_FILESYSTEM_H
#define BADA_FILESYSTEM_H
#ifndef TIZEN_FILESYSTEM_H
#define TIZEN_FILESYSTEM_H
#include <FBaseString.h>
#include <FBaseUtilStringUtil.h>
@ -32,23 +32,40 @@
#include "common/stream.h"
#include "backends/fs/abstract-fs.h"
using namespace Osp::Io;
using namespace Osp::Base;
using namespace Osp::Base::Utility;
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 BADA.
* Implementation of the ScummVM file system API based on TIZEN.
*
* Parts of this class are documented in the base interface class, AbstractFSNode.
*/
class BadaFilesystemNode : public AbstractFSNode {
class TizenFilesystemNode : public AbstractFSNode {
public:
/**
* Creates a BadaFilesystemNode for a given path.
* Creates a TizenFilesystemNode for a given path.
*
* @param path the path the new node should point to.
*/
BadaFilesystemNode(const Common::String &path);
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; }
@ -67,8 +84,7 @@ public:
Common::WriteStream *createWriteStream();
protected:
BadaFilesystemNode(const Common::String &root,
const Common::String &p);
TizenFilesystemNode(const Common::String &root, const Common::String &p);
void init(const Common::String &nodePath);
Common::String _displayName;

108
backends/platform/bada/graphics.cpp → backends/platform/tizen/graphics.cpp
View File

@ -22,29 +22,40 @@
#include "graphics/fontman.h"
#include "backends/platform/bada/form.h"
#include "backends/platform/bada/system.h"
#include "backends/platform/bada/graphics.h"
#include "backends/platform/tizen/form.h"
#include "backends/platform/tizen/system.h"
#include "backends/platform/tizen/graphics.h"
//
// BadaGraphicsManager
// TizenGraphicsManager
//
BadaGraphicsManager::BadaGraphicsManager(BadaAppForm *appForm) :
TizenGraphicsManager::TizenGraphicsManager(TizenAppForm *appForm) :
_appForm(appForm),
_eglDisplay(EGL_DEFAULT_DISPLAY),
_eglSurface(EGL_NO_SURFACE),
_eglConfig(0),
_eglConfig(NULL),
_eglContext(EGL_NO_CONTEXT),
_initState(true) {
assert(appForm != NULL);
_videoMode.fullscreen = true;
}
const Graphics::Font *BadaGraphicsManager::getFontOSD() {
TizenGraphicsManager::~TizenGraphicsManager() {
logEntered();
if (_eglDisplay != EGL_NO_DISPLAY) {
eglMakeCurrent(_eglDisplay, NULL, NULL, NULL);
if (_eglContext != EGL_NO_CONTEXT) {
eglDestroyContext(_eglDisplay, _eglContext);
}
}
}
const Graphics::Font *TizenGraphicsManager::getFontOSD() {
return FontMan.getFontByUsage(Graphics::FontManager::kBigGUIFont);
}
bool BadaGraphicsManager::moveMouse(int16 &x, int16 &y) {
bool TizenGraphicsManager::moveMouse(int16 &x, int16 &y) {
int16 currentX = _cursorState.x;
int16 currentY = _cursorState.y;
@ -62,7 +73,7 @@ bool BadaGraphicsManager::moveMouse(int16 &x, int16 &y) {
return (currentX != x || currentY != y);
}
Common::List<Graphics::PixelFormat> BadaGraphicsManager::getSupportedFormats() const {
Common::List<Graphics::PixelFormat> TizenGraphicsManager::getSupportedFormats() const {
logEntered();
Common::List<Graphics::PixelFormat> res;
@ -73,33 +84,37 @@ Common::List<Graphics::PixelFormat> BadaGraphicsManager::getSupportedFormats() c
return res;
}
bool BadaGraphicsManager::hasFeature(OSystem::Feature f) {
bool TizenGraphicsManager::hasFeature(OSystem::Feature f) {
bool result = (f == OSystem::kFeatureFullscreenMode ||
f == OSystem::kFeatureVirtualKeyboard ||
OpenGLGraphicsManager::hasFeature(f));
f == OSystem::kFeatureVirtualKeyboard ||
OpenGLGraphicsManager::hasFeature(f));
return result;
}
void BadaGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
OpenGLGraphicsManager::setFeatureState(f, enable);
void TizenGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
if (f == OSystem::kFeatureVirtualKeyboard && enable) {
_appForm->showKeypad();
} else {
OpenGLGraphicsManager::setFeatureState(f, enable);
}
}
void BadaGraphicsManager::setReady() {
void TizenGraphicsManager::setReady() {
_initState = false;
}
void BadaGraphicsManager::updateScreen() {
void TizenGraphicsManager::updateScreen() {
if (_transactionMode == kTransactionNone) {
internUpdateScreen();
}
}
bool BadaGraphicsManager::loadEgl() {
bool TizenGraphicsManager::loadEgl() {
logEntered();
EGLint numConfigs = 1;
EGLint eglConfigList[] = {
EGL_RED_SIZE, 5,
EGL_RED_SIZE, 5,
EGL_GREEN_SIZE, 6,
EGL_BLUE_SIZE, 5,
EGL_ALPHA_SIZE, 0,
@ -132,8 +147,7 @@ bool BadaGraphicsManager::loadEgl() {
return false;
}
if (EGL_FALSE == eglChooseConfig(_eglDisplay, eglConfigList,
&_eglConfig, 1, &numConfigs) ||
if (EGL_FALSE == eglChooseConfig(_eglDisplay, eglConfigList, &_eglConfig, 1, &numConfigs) ||
EGL_SUCCESS != eglGetError()) {
systemError("eglChooseConfig() failed");
return false;
@ -144,15 +158,13 @@ bool BadaGraphicsManager::loadEgl() {
return false;
}
_eglSurface = eglCreateWindowSurface(_eglDisplay, _eglConfig,
(EGLNativeWindowType)_appForm, NULL);
_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);
_eglContext = eglCreateContext(_eglDisplay, _eglConfig, EGL_NO_CONTEXT, eglContextList);
if (EGL_NO_CONTEXT == _eglContext ||
EGL_SUCCESS != eglGetError()) {
systemError("eglCreateContext() failed");
@ -169,7 +181,7 @@ bool BadaGraphicsManager::loadEgl() {
return true;
}
bool BadaGraphicsManager::loadGFXMode() {
bool TizenGraphicsManager::loadGFXMode() {
logEntered();
if (!loadEgl()) {
@ -181,35 +193,28 @@ bool BadaGraphicsManager::loadGFXMode() {
_appForm->GetBounds(x, y, width, height);
_videoMode.overlayWidth = _videoMode.hardwareWidth = width;
_videoMode.overlayHeight = _videoMode.hardwareHeight = height;
_videoMode.scaleFactor = 3; // for proportional sized cursor in the launcher
_videoMode.scaleFactor = 4; // for proportional sized cursor in the launcher
AppLog("screen size: %dx%d", _videoMode.hardwareWidth, _videoMode.hardwareHeight);
return OpenGLGraphicsManager::loadGFXMode();
}
void BadaGraphicsManager::loadTextures() {
void TizenGraphicsManager::loadTextures() {
logEntered();
OpenGLGraphicsManager::loadTextures();
// prevent image skew in some games, see:
// http://www.opengl.org/resources/features/KilgardTechniques/oglpitfall
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
}
void BadaGraphicsManager::internUpdateScreen() {
void TizenGraphicsManager::internUpdateScreen() {
if (!_initState) {
OpenGLGraphicsManager::internUpdateScreen();
eglSwapBuffers(_eglDisplay, _eglSurface);
} else {
showSplash();
}
}
void BadaGraphicsManager::unloadGFXMode() {
void TizenGraphicsManager::unloadGFXMode() {
logEntered();
if (EGL_NO_DISPLAY != _eglDisplay) {
if (_eglDisplay != EGL_NO_DISPLAY) {
eglMakeCurrent(_eglDisplay, NULL, NULL, NULL);
if (_eglContext != EGL_NO_CONTEXT) {
@ -227,35 +232,6 @@ void BadaGraphicsManager::unloadGFXMode() {
}
_eglConfig = NULL;
OpenGLGraphicsManager::unloadGFXMode();
logLeaving();
}
// display a simple splash screen until launcher is ready
void BadaGraphicsManager::showSplash() {
Canvas canvas;
canvas.Construct();
canvas.SetBackgroundColor(Color::COLOR_BLACK);
canvas.Clear();
int x = _videoMode.hardwareWidth / 3;
int y = _videoMode.hardwareHeight / 3;
Font *pFont = new Font();
pFont->Construct(FONT_STYLE_ITALIC | FONT_STYLE_BOLD, 55);
canvas.SetFont(*pFont);
canvas.SetForegroundColor(Color::COLOR_GREEN);
canvas.DrawText(Point(x, y), L"ScummVM");
delete pFont;
pFont = new Font();
pFont->Construct(FONT_STYLE_ITALIC | FONT_STYLE_BOLD, 35);
canvas.SetFont(*pFont);
canvas.SetForegroundColor(Color::COLOR_WHITE);
canvas.DrawText(Point(x + 70, y + 50), L"Loading ...");
delete pFont;
canvas.Show();
}

19
backends/platform/bada/graphics.h → backends/platform/tizen/graphics.h
View File

@ -20,8 +20,8 @@
*
*/
#ifndef BADA_GRAPHICS_H
#define BADA_GRAPHICS_H
#ifndef TIZEN_GRAPHICS_H
#define TIZEN_GRAPHICS_H
#include <FBase.h>
#include <FGraphics.h>
@ -33,15 +33,16 @@
#include "config.h"
#include "backends/graphics/opengl/opengl-graphics.h"
#include "graphics/font.h"
#include "backends/platform/bada/form.h"
#include "backends/platform/tizen/form.h"
using namespace Osp::Graphics;
using namespace Osp::Graphics::Opengl;
using namespace Osp::App;
using namespace Tizen::Graphics;
using namespace Tizen::Graphics::Opengl;
using namespace Tizen::App;
class BadaGraphicsManager : public OpenGLGraphicsManager {
class TizenGraphicsManager : public OpenGLGraphicsManager {
public:
BadaGraphicsManager(BadaAppForm *appForm);
TizenGraphicsManager(TizenAppForm *appForm);
virtual ~TizenGraphicsManager();
Common::List<Graphics::PixelFormat> getSupportedFormats() const;
bool hasFeature(OSystem::Feature f);
@ -61,7 +62,7 @@ private:
void showSplash();
bool loadEgl();
BadaAppForm *_appForm;
TizenAppForm *_appForm;
EGLDisplay _eglDisplay;
EGLSurface _eglSurface;
EGLConfig _eglConfig;

36
backends/platform/bada/main.cpp → backends/platform/tizen/main.cpp
View File

@ -24,44 +24,28 @@
#include <FApp.h>
#include <FSystem.h>
#include "backends/platform/bada/portdefs.h"
#include "backends/platform/bada/form.h"
#include "backends/platform/bada/system.h"
#include "backends/platform/bada/application.h"
#include "backends/platform/tizen/application.h"
using namespace Osp::Base;
using namespace Osp::Base::Collection;
C_LINKAGE_BEGIN
_EXPORT_ int OspMain(int argc, char *pArgv[]);
using namespace Tizen::Base;
using namespace Tizen::Base::Collection;
/**
* The entry function of bada application called by the operating system.
* The entry function of tizen application called by the operating system.
*/
int OspMain(int argc, char *pArgv[]) {
extern "C" _EXPORT_ int OspMain(int argc, char *pArgv[]) {
result r = E_SUCCESS;
AppLog("Application started.");
ArrayList *pArgs = new ArrayList();
pArgs->Construct();
ArrayList args(SingleObjectDeleter);
args.Construct();
for (int i = 0; i < argc; i++) {
pArgs->Add(*(new String(pArgv[i])));
args.Add(new (std::nothrow) String(pArgv[i]));
}
r = Osp::App::Application::Execute(BadaScummVM::createInstance, pArgs);
if (IsFailed(r)) {
r &= 0x0000FFFF;
}
pArgs->RemoveAll(true);
delete pArgs;
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);
}
C_LINKAGE_END

37
backends/platform/bada/missing.cpp → backends/platform/tizen/missing.cpp
View File

@ -26,7 +26,7 @@
#include <FSystem.h>
#include <FBase.h>
#include "backends/platform/bada/portdefs.h"
#include "backends/platform/tizen/portdefs.h"
#include <stdio.h>
#include <string.h>
@ -48,7 +48,7 @@ void __assert_func(const char *file, int line,
systemError(buffer);
}
void stderr_fprintf(void*, const char *format, ...) {
void stderr_fprintf(void *, const char *format, ...) {
va_list ap;
char buffer[BUF_SIZE];
@ -59,7 +59,7 @@ void stderr_fprintf(void*, const char *format, ...) {
AppLog(buffer);
}
void stderr_vfprintf(void*, const char *format, va_list ap) {
void stderr_vfprintf(void *, const char *format, va_list ap) {
char buffer[BUF_SIZE];
vsnprintf(buffer, sizeof(buffer), format, ap);
AppLog(buffer);
@ -79,35 +79,4 @@ int printf(const char *format, ...) {
return result;
}
int sprintf(char *str, const char *format, ...) {
va_list ap;
int result;
char buffer[BUF_SIZE];
va_start(ap, format);
result = vsnprintf(buffer, sizeof(buffer), format, ap);
va_end(ap);
strcpy(str, buffer);
return result;
}
char *strdup(const char *strSource) {
char *buffer;
int len = strlen(strSource) + 1;
buffer = (char *)malloc(len);
if (buffer) {
memcpy(buffer, strSource, len);
}
return buffer;
}
int vsprintf(char *str, const char *format, va_list ap) {
char buffer[BUF_SIZE];
int result = vsnprintf(buffer, sizeof(buffer), format, ap);
strcpy(str, buffer);
return result;
}
C_LINKAGE_END

12
backends/platform/bada/portdefs.h → backends/platform/tizen/portdefs.h
View File

@ -43,6 +43,9 @@
#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
@ -51,11 +54,11 @@ C_LINKAGE_BEGIN
#define fseeko fseek
#define ftello ftell
// overcome use of fprintf since bada/newlib (1.2) does not
// 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);
void stderr_fprintf(void *, const char *format, ...);
void stderr_vfprintf(void *, const char *format, va_list ap);
#undef fprintf
#undef vfprintf
@ -75,10 +78,7 @@ void stderr_vfprintf(void*, const char *format, va_list ap);
#define vfprintf stderr_vfprintf
int printf(const char *format, ...);
int sprintf(char *str, const char *format, ...);
int simple_sscanf(const char *buffer, const char *format, ...);
char *strdup(const char *s1);
int vsprintf(char *str, const char *format, va_list ap);
C_LINKAGE_END

0
backends/platform/bada/sscanf.cpp → backends/platform/tizen/sscanf.cpp
View File

289
backends/platform/bada/system.cpp → backends/platform/tizen/system.cpp
View File

@ -34,53 +34,53 @@
#include "backends/audiocd/default/default-audiocd.h"
#include "backends/mutex/mutex.h"
#include "backends/fs/fs-factory.h"
#include "backends/timer/bada/timer.h"
#include "backends/timer/tizen/timer.h"
#include "backends/platform/bada/form.h"
#include "backends/platform/bada/system.h"
#include "backends/platform/bada/graphics.h"
#include "backends/platform/bada/audio.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 Osp::Base;
using namespace Osp::Base::Runtime;
using namespace Osp::Locales;
using namespace Osp::Ui::Controls;
using namespace Osp::System;
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 "/Home/scummvm.ini"
#define RESOURCE_PATH "/Res"
#define DEFAULT_CONFIG_FILE "scummvm.ini"
#define MUTEX_BUFFER_SIZE 5
//
// BadaFilesystemFactory
// TizenFilesystemFactory
//
class BadaFilesystemFactory : public FilesystemFactory {
class TizenFilesystemFactory : public FilesystemFactory {
AbstractFSNode *makeRootFileNode() const;
AbstractFSNode *makeCurrentDirectoryFileNode() const;
AbstractFSNode *makeFileNodePath(const Common::String &path) const;
};
AbstractFSNode *BadaFilesystemFactory::makeRootFileNode() const {
return new BadaFilesystemNode("/");
AbstractFSNode *TizenFilesystemFactory::makeRootFileNode() const {
return new TizenFilesystemNode("/");
}
AbstractFSNode *BadaFilesystemFactory::makeCurrentDirectoryFileNode() const {
return new BadaFilesystemNode("/Home");
AbstractFSNode *TizenFilesystemFactory::makeCurrentDirectoryFileNode() const {
return new TizenFilesystemNode("/");
}
AbstractFSNode *BadaFilesystemFactory::makeFileNodePath(const Common::String &path) const {
AbstractFSNode *TizenFilesystemFactory::makeFileNodePath(const Common::String &path) const {
AppAssert(!path.empty());
return new BadaFilesystemNode(path);
return new TizenFilesystemNode(path);
}
//
// BadaSaveFileManager
// TizenSaveFileManager
//
struct BadaSaveFileManager : public DefaultSaveFileManager {
struct TizenSaveFileManager : public DefaultSaveFileManager {
bool removeSavefile(const Common::String &filename);
};
bool BadaSaveFileManager::removeSavefile(const Common::String &filename) {
bool TizenSaveFileManager::removeSavefile(const Common::String &filename) {
Common::String savePathName = getSavePath();
checkPath(Common::FSNode(savePathName));
@ -95,18 +95,18 @@ bool BadaSaveFileManager::removeSavefile(const Common::String &filename) {
String unicodeFileName;
StringUtil::Utf8ToString(file.getPath().c_str(), unicodeFileName);
switch (Osp::Io::File::Remove(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());
file.getName());
break;
default:
setError(Common::kPathDoesNotExist, "removeSavefile: '" + file.getName() +
"' does not exist or path is invalid");
"' does not exist or path is invalid");
break;
}
@ -114,40 +114,40 @@ bool BadaSaveFileManager::removeSavefile(const Common::String &filename) {
}
//
// BadaMutexManager
// TizenMutexManager
//
struct BadaMutexManager : public MutexManager {
BadaMutexManager();
~BadaMutexManager();
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];
Mutex *_buffer[MUTEX_BUFFER_SIZE];
};
BadaMutexManager::BadaMutexManager() {
TizenMutexManager::TizenMutexManager() {
for (int i = 0; i < MUTEX_BUFFER_SIZE; i++) {
buffer[i] = NULL;
_buffer[i] = NULL;
}
}
BadaMutexManager::~BadaMutexManager() {
TizenMutexManager::~TizenMutexManager() {
for (int i = 0; i < MUTEX_BUFFER_SIZE; i++) {
if (buffer[i] != NULL) {
delete buffer[i];
if (_buffer[i] != NULL) {
delete _buffer[i];
}
}
}
OSystem::MutexRef BadaMutexManager::createMutex() {
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;
if (_buffer[i] == NULL) {
_buffer[i] = mutex;
break;
}
}
@ -155,22 +155,22 @@ OSystem::MutexRef BadaMutexManager::createMutex() {
return (OSystem::MutexRef) mutex;
}
void BadaMutexManager::lockMutex(OSystem::MutexRef mutex) {
void TizenMutexManager::lockMutex(OSystem::MutexRef mutex) {
Mutex *m = (Mutex *)mutex;
m->Acquire();
}
void BadaMutexManager::unlockMutex(OSystem::MutexRef mutex) {
void TizenMutexManager::unlockMutex(OSystem::MutexRef mutex) {
Mutex *m = (Mutex *)mutex;
m->Release();
}
void BadaMutexManager::deleteMutex(OSystem::MutexRef mutex) {
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;
if (_buffer[i] == m) {
_buffer[i] = NULL;
}
}
@ -178,84 +178,101 @@ void BadaMutexManager::deleteMutex(OSystem::MutexRef mutex) {
}
//
// BadaEventManager
// TizenEventManager
//
struct BadaEventManager : public DefaultEventManager {
BadaEventManager(Common::EventSource *boss);
struct TizenEventManager : public DefaultEventManager {
TizenEventManager(Common::EventSource *boss);
void init();
int shouldQuit() const;
};
BadaEventManager::BadaEventManager(Common::EventSource *boss) :
TizenEventManager::TizenEventManager(Common::EventSource *boss) :
DefaultEventManager(boss) {
}
void BadaEventManager::init() {
void TizenEventManager::init() {
DefaultEventManager::init();
// theme and vkbd should have now loaded - clear the splash screen
BadaSystem *system = (BadaSystem *)g_system;
BadaGraphicsManager *graphics = system->getGraphics();
TizenSystem *system = (TizenSystem *)g_system;
TizenGraphicsManager *graphics = system->getGraphics();
if (graphics) {
graphics->setReady();
graphics->updateScreen();
}
}
int BadaEventManager::shouldQuit() const {
BadaSystem *system = (BadaSystem *)g_system;
int TizenEventManager::shouldQuit() const {
TizenSystem *system = (TizenSystem *)g_system;
return DefaultEventManager::shouldQuit() || system->isClosing();
}
//
// BadaSystem
// TizenAppFrame - avoid drawing the misplaced UiTheme at startup
//
BadaSystem::BadaSystem(BadaAppForm *appForm) :
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 BadaSystem::Construct(void) {
result TizenSystem::Construct(void) {
logEntered();
_fsFactory = new BadaFilesystemFactory();
_fsFactory = new TizenFilesystemFactory();
if (!_fsFactory) {
return E_OUT_OF_MEMORY;
}
_resourcePath = fromString(App::GetInstance()->GetAppResourcePath());
return E_SUCCESS;
}
BadaSystem::~BadaSystem() {
TizenSystem::~TizenSystem() {
logEntered();
}
result BadaSystem::initModules() {
result TizenSystem::initModules() {
logEntered();
_mutexManager = new BadaMutexManager();
_mutexManager = new TizenMutexManager();
if (!_mutexManager) {
return E_OUT_OF_MEMORY;
}
_timerManager = new BadaTimerManager();
_timerManager = new TizenTimerManager();
if (!_timerManager) {
return E_OUT_OF_MEMORY;
}
_savefileManager = new BadaSaveFileManager();
_savefileManager = new TizenSaveFileManager();
if (!_savefileManager) {
return E_OUT_OF_MEMORY;
}
_graphicsManager = (GraphicsManager *)new BadaGraphicsManager(_appForm);
_graphicsManager = (GraphicsManager *)new TizenGraphicsManager(_appForm);
if (!_graphicsManager) {
return E_OUT_OF_MEMORY;
}
// depends on _graphicsManager when ENABLE_VKEYBD enabled
_eventManager = new BadaEventManager(this);
_eventManager = new TizenEventManager(this);
if (!_eventManager) {
return E_OUT_OF_MEMORY;
}
@ -284,19 +301,21 @@ result BadaSystem::initModules() {
return E_SUCCESS;
}
void BadaSystem::initBackend() {
void TizenSystem::initBackend() {
logEntered();
// use the mobile device theme
ConfMan.set("gui_theme", "/Res/scummmobile");
Common::String dataPath = fromString(App::GetInstance()->GetAppDataPath());
// allow bada virtual keypad pack to be found
ConfMan.set("vkeybdpath", "/Res/vkeybd_bada");
// use the mobile device theme
ConfMan.set("gui_theme", _resourcePath + "scummmodern");
// 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", "/Home/Share");
ConfMan.set("savepath", dataPath);
}
// default to no auto-save
@ -314,85 +333,93 @@ void BadaSystem::initBackend() {
AppLog("initModules failed");
} else {
OSystem::initBackend();
}
// replace kBigGUIFont using the large font from the scummmobile theme
Common::File fontFile;
Common::String fileName = "/Res/scummmobile/helvB14-iso-8859-1.fcc";
BadaFilesystemNode file(fileName);
if (file.exists()) {
Common::SeekableReadStream *stream = file.createReadStream();
if (stream) {
if (fontFile.open(stream, fileName)) {
// 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) {
// use this font for the vkbd and on-screen messages
FontMan.setFont(Graphics::FontManager::kBigGUIFont, font);
}
}
}
}
logLeaving();
}
void BadaSystem::addSysArchivesToSearchSet(Common::SearchSet &s, int priority) {
void TizenSystem::addSysArchivesToSearchSet(Common::SearchSet &s, int priority) {
// allow translations.dat and game .DAT files to be found
s.addDirectory(RESOURCE_PATH, RESOURCE_PATH, priority);
s.addDirectory(_resourcePath, _resourcePath, priority);
}
void BadaSystem::destroyBackend() {
void TizenSystem::destroyBackend() {
closeAudio();
delete _graphicsManager;
_graphicsManager = 0;
_graphicsManager = NULL;
delete _savefileManager;
_savefileManager = 0;
_savefileManager = NULL;
delete _fsFactory;
_fsFactory = 0;
_fsFactory = NULL;
delete _mixer;
_mixer = 0;
_mixer = NULL;
delete _audiocdManager;
_audiocdManager = 0;
_audiocdManager = NULL;
delete _timerManager;
_timerManager = 0;
_timerManager = NULL;
delete _eventManager;
_eventManager = 0;
_eventManager = NULL;
delete _mutexManager;
_mutexManager = 0;
_mutexManager = NULL;
}
bool BadaSystem::pollEvent(Common::Event &event) {
bool TizenSystem::pollEvent(Common::Event &event) {
return _appForm->pollEvent(event);
}
uint32 BadaSystem::getMillis(bool skipRecord) {
uint32 TizenSystem::getMillis(bool skipRecord) {
long long result, ticks = 0;
SystemTime::GetTicks(ticks);
result = ticks - _epoch;
return result;
}
void BadaSystem::delayMillis(uint msecs) {
void TizenSystem::delayMillis(uint msecs) {
if (!_appForm->isClosing()) {
Thread::Sleep(msecs);
}
}
void BadaSystem::updateScreen() {
void TizenSystem::updateScreen() {
if (_graphicsManager != NULL) {
_graphicsManager->updateScreen();
}
}
void BadaSystem::getTimeAndDate(TimeDate &td) const {
void TizenSystem::getTimeAndDate(TimeDate &td) const {
DateTime currentTime;
if (E_SUCCESS == SystemTime::GetCurrentTime(WALL_TIME, currentTime)) {
@ -410,11 +437,11 @@ void BadaSystem::getTimeAndDate(TimeDate &td) const {
}
}
void BadaSystem::fatalError() {
void TizenSystem::fatalError() {
systemError("ScummVM: Fatal internal error.");
}
void BadaSystem::exitSystem() {
void TizenSystem::exitSystem() {
if (_appForm) {
closeAudio();
closeGraphics();
@ -422,7 +449,7 @@ void BadaSystem::exitSystem() {
}
}
void BadaSystem::logMessage(LogMessageType::Type type, const char *message) {
void TizenSystem::logMessage(LogMessageType::Type type, const char *message) {
if (type == LogMessageType::kError) {
systemError(message);
} else {
@ -430,69 +457,70 @@ void BadaSystem::logMessage(LogMessageType::Type type, const char *message) {
}
}
Common::SeekableReadStream *BadaSystem::createConfigReadStream() {
BadaFilesystemNode file(DEFAULT_CONFIG_FILE);
Common::SeekableReadStream *TizenSystem::createConfigReadStream() {
TizenFilesystemNode file(fromString(App::GetInstance()->GetAppDataPath()) + DEFAULT_CONFIG_FILE);
return file.createReadStream();
}
Common::WriteStream *BadaSystem::createConfigWriteStream() {
BadaFilesystemNode file(DEFAULT_CONFIG_FILE);
Common::WriteStream *TizenSystem::createConfigWriteStream() {
TizenFilesystemNode file(fromString(App::GetInstance()->GetAppDataPath()) + DEFAULT_CONFIG_FILE);
return file.createWriteStream();
}
void BadaSystem::closeAudio() {
void TizenSystem::closeAudio() {
if (_audioThread) {
_audioThread->Stop();
_audioThread->Quit();
_audioThread->Join();
delete _audioThread;
_audioThread = 0;
_audioThread = NULL;
}
}
void BadaSystem::closeGraphics() {
void TizenSystem::closeGraphics() {
if (_graphicsManager) {
delete _graphicsManager;
_graphicsManager = 0;
_graphicsManager = NULL;
}
}
void BadaSystem::setMute(bool on) {
void TizenSystem::setMute(bool on) {
// only change mute after eventManager init() has completed
if (_audioThread) {
BadaGraphicsManager *graphics = getGraphics();
TizenGraphicsManager *graphics = getGraphics();
if (graphics && graphics->isReady()) {
_audioThread->setMute(on);
}
}
}
int BadaSystem::setVolume(bool up, bool minMax) {
int level = -1;
if (_audioThread) {
level = _audioThread->setVolume(up, minMax);
}
return level;
}
//
// create the ScummVM system
//
BadaAppForm *systemStart(Osp::App::Application *app) {
TizenAppForm *systemStart(Tizen::App::Application *app) {
logEntered();
BadaAppForm *appForm = new BadaAppForm();
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 != app->GetAppFrame()->GetFrame()->AddControl(*appForm)) {
E_SUCCESS != appFrame->AddControl(*appForm)) {
delete appForm;
AppLog("Failed to construct appForm");
return NULL;
}
appFrame->SetCurrentForm(appForm);
logLeaving();
return appForm;
}
@ -502,13 +530,18 @@ BadaAppForm *systemStart(Osp::App::Application *app) {
void systemError(const char *message) {
AppLog("Fatal system error: %s", message);
ArrayList *args = new ArrayList();
args->Construct();
args->Add(*(new String(message)));
Application::GetInstance()->SendUserEvent(USER_MESSAGE_EXIT_ERR, args);
if (strspn(message, "Config file buggy:") > 0) {
Tizen::Io::File::Remove(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) {
BadaSystem *system = (BadaSystem *)g_system;
TizenSystem *system = (TizenSystem *)g_system;
system->exitSystem();
}
}

44
backends/platform/bada/system.h → backends/platform/tizen/system.h
View File

@ -20,8 +20,8 @@
*
*/
#ifndef BADA_SYSTEM_H
#define BADA_SYSTEM_H
#ifndef TIZEN_SYSTEM_H
#define TIZEN_SYSTEM_H
#include <FApp.h>
#include <FGraphics.h>
@ -34,47 +34,46 @@
#include "common/scummsys.h"
#include "backends/modular-backend.h"
#include "backends/platform/bada/fs.h"
#include "backends/platform/bada/form.h"
#include "backends/platform/bada/audio.h"
#include "backends/platform/bada/graphics.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__);
#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
BadaAppForm *systemStart(Osp::App::Application *app);
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 1000
#define USER_MESSAGE_EXIT_ERR 1001
#define USER_MESSAGE_EXIT_ERR_CONFIG 1002
//
// BadaSystem
// TizenSystem
//
class BadaSystem : public ModularBackend,
Common::EventSource {
class TizenSystem :
public ModularBackend,
Common::EventSource {
public:
BadaSystem(BadaAppForm *appForm);
~BadaSystem();
TizenSystem(TizenAppForm *appForm);
~TizenSystem();
result Construct();
void closeAudio();
void closeGraphics();
void destroyBackend();
void setMute(bool on);
int setVolume(bool up, bool minMax);
void exitSystem();
bool isClosing() { return _appForm->isClosing(); }
BadaGraphicsManager *getGraphics() {
return (BadaGraphicsManager *)_graphicsManager;
TizenGraphicsManager *getGraphics() {
return (TizenGraphicsManager *)_graphicsManager;
}
private:
@ -94,9 +93,10 @@ private:
Common::SeekableReadStream *createConfigReadStream();
Common::WriteStream *createConfigWriteStream();
BadaAppForm *_appForm;
TizenAppForm *_appForm;
AudioThread *_audioThread;
long long _epoch;
Common::String _resourcePath;
};
#endif

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

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

50
backends/timer/bada/timer.cpp → backends/timer/tizen/timer.cpp
View File

@ -20,15 +20,14 @@
*
*/
#if defined(BADA)
#if defined(TIZEN)
#include "backends/timer/bada/timer.h"
#include "backends/timer/tizen/timer.h"
//
// TimerSlot
// TimerSlot - an event driven thread
//
TimerSlot::TimerSlot(Common::TimerManager::TimerProc callback,
uint32 interval, void *refCon) :
TimerSlot::TimerSlot(Common::TimerManager::TimerProc callback, uint32 interval, void *refCon) :
_timer(0),
_callback(callback),
_interval(interval),
@ -36,16 +35,17 @@ TimerSlot::TimerSlot(Common::TimerManager::TimerProc callback,
}
TimerSlot::~TimerSlot() {
delete _timer;
}
bool TimerSlot::OnStart() {
_timer = new Osp::Base::Runtime::Timer();
_timer = new Tizen::Base::Runtime::Timer();
if (!_timer || IsFailed(_timer->Construct(*this))) {
AppLog("Failed to create timer");
return false;
}
if (IsFailed(_timer->Start(_interval))) {
if (IsFailed(_timer->StartAsRepeatable(_interval))) {
AppLog("failed to start timer");
return false;
}
@ -65,28 +65,28 @@ void TimerSlot::OnStop() {
void TimerSlot::OnTimerExpired(Timer &timer) {
_callback(_refCon);
timer.Start(_interval);
}
//
// BadaTimerManager
// TizenTimerManager
//
BadaTimerManager::BadaTimerManager() {
TizenTimerManager::TizenTimerManager() {
}
BadaTimerManager::~BadaTimerManager() {
for (Common::List<TimerSlot>::iterator slot = _timers.begin();
slot != _timers.end(); ) {
slot->Stop();
slot = _timers.erase(slot);
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 BadaTimerManager::installTimerProc(TimerProc proc, int32 interval, void *refCon,
const Common::String &id) {
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(THREAD_TYPE_EVENT_DRIVEN))) {
if (IsFailed(slot->Construct())) {
AppLog("Failed to create timer thread");
delete slot;
return false;
@ -98,16 +98,18 @@ bool BadaTimerManager::installTimerProc(TimerProc proc, int32 interval, void *re
return false;
}
_timers.push_back(*slot);
_timers.push_back(slot);
return true;
}
void BadaTimerManager::removeTimerProc(TimerProc proc) {
for (Common::List<TimerSlot>::iterator slot = _timers.begin();
slot != _timers.end(); ++slot) {
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->Stop();
slot = _timers.erase(slot);
slot->Quit();
slot->Join();
delete slot;
it = _timers.erase(it);
}
}
}

23
backends/timer/bada/timer.h → backends/timer/tizen/timer.h
View File

@ -20,20 +20,18 @@
*
*/
#ifndef BADA_TIMER_H
#define BADA_TIMER_H
#ifndef TIZEN_TIMER_H
#define TIZEN_TIMER_H
#include <FBase.h>
#include "common/timer.h"
#include "common/list.h"
using namespace Osp::Base::Runtime;
using namespace Tizen::Base::Runtime;
struct TimerSlot: public ITimerEventListener, public Thread {
TimerSlot(Common::TimerManager::TimerProc callback,
uint32 interval,
void *refCon);
struct TimerSlot: public EventDrivenThread, public ITimerEventListener {
TimerSlot(Common::TimerManager::TimerProc callback, uint32 interval, void *refCon);
~TimerSlot();
bool OnStart(void);
@ -46,17 +44,16 @@ struct TimerSlot: public ITimerEventListener, public Thread {
void *_refCon;
};
class BadaTimerManager : public Common::TimerManager {
class TizenTimerManager : public Common::TimerManager {
public:
BadaTimerManager();
~BadaTimerManager();
TizenTimerManager();
~TizenTimerManager();
bool installTimerProc(TimerProc proc, int32 interval, void *refCon,
const Common::String &id);
bool installTimerProc(TimerProc proc, int32 interval, void *refCon, const Common::String &id);
void removeTimerProc(TimerProc proc);
private:
Common::List<TimerSlot> _timers;
Common::List<TimerSlot *> _timers;
};
#endif

130
configure vendored
View File

@ -817,7 +817,7 @@ Usage: $0 [OPTIONS]...
Configuration:
-h, --help display this help and exit
--backend=BACKEND backend to build (android, bada, dc, dingux, ds, gph,
--backend=BACKEND backend to build (android, tizen, dc, dingux, ds, gph,
iphone, linuxmoto, maemo, n64, null, openpandora, ps2,
psp, samsungtv, sdl, webos, wii, wince) [sdl]
@ -846,7 +846,7 @@ Fine tuning of the installation directories:
Special configuration feature:
--host=HOST cross-compile to target HOST (arm-linux, ...)
special targets: android for Android
bada for Samsung BADA
tizen for Samsung Tizen
caanoo for Caanoo
dingux for Dingux
dreamcast for Sega Dreamcast
@ -1250,16 +1250,6 @@ arm-riscos)
_host_os=riscos
_host_cpu=arm
;;
bada)
_host_os=bada
if test "$_debug_build" = yes; then
_host_cpu=i686
_host_alias=i686-mingw32
else
_host_cpu=arm
_host_alias=arm-samsung-nucleuseabi
fi
;;
caanoo)
_host_os=gph-linux
_host_cpu=arm
@ -1385,6 +1375,11 @@ samsungtv)
_host_cpu=arm
_host_alias=arm-linux-gnueabi
;;
tizen)
_host_os=tizen
_host_cpu=arm
_host_alias=arm-linux-gnueabi
;;
webos)
_host_os=webos
_host_cpu=arm
@ -1494,12 +1489,6 @@ android)
exit 1
fi
;;
bada)
if test -z "$BADA_SDK"; then
echo "Please set BADA_SDK in your environment. export BADA_SDK=<path to Bada SDK>"
exit 1
fi
;;
ds | gamecube | wii)
if test -z "$DEVKITPRO"; then
echo "Please set DEVKITPRO in your environment. export DEVKITPRO=<path to devkitPRO>"
@ -1541,6 +1530,12 @@ psp)
exit 1
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>"
@ -1734,7 +1729,7 @@ if test "$have_gcc" = yes ; then
case $_host_os in
# newlib-based system include files suppress non-C89 function
# declarations under __STRICT_ANSI__
amigaos* | android | bada | dreamcast | ds | gamecube | mingw* | n64 | psp | ps2 | ps3 | wii | wince )
amigaos* | android | dreamcast | ds | gamecube | mingw* | n64 | psp | ps2 | ps3 | tizen | wii | wince )
;;
*)
CXXFLAGS="$CXXFLAGS -ansi"
@ -1770,7 +1765,7 @@ echo $_use_cxx11
# However, some platforms use GNU extensions in system header files, so
# for these we must not use -pedantic.
case $_host_os in
android | gamecube | psp | wii | webos)
android | gamecube | psp | tizen | wii | webos)
;;
*)
# ICC does not support pedantic, while GCC and clang do.
@ -2054,16 +2049,6 @@ case $_host_os in
add_line_to_config_mk "ANDROID_SDK = $ANDROID_SDK"
_seq_midi=no
;;
bada)
BADA_SDK_ROOT="`cygpath -m ${BADA_SDK}`"
add_line_to_config_mk "BADA_SDK = $BADA_SDK"
add_line_to_config_mk "BADA_SDK_ROOT = $BADA_SDK_ROOT"
# assume dependencies have been installed in cygwin's /usr/local
CYGWIN_USR_LOCAL="`cygpath -m /usr/local`"
LDFLAGS="$LDFLAGS -L${CYGWIN_USR_LOCAL}/lib"
CXXFLAGS="$CXXFLAGS -I${CYGWIN_USR_LOCAL}/include"
;;
beos*)
DEFINES="$DEFINES -DSYSTEM_NOT_SUPPORTING_D_TYPE"
# Needs -lbind -lsocket for the timidity MIDI driver
@ -2241,6 +2226,12 @@ case $_host_os in
# Needs -lbind -lsocket for the timidity MIDI driver
LIBS="$LIBS -lnsl -lsocket"
;;
tizen)
add_line_to_config_mk "TIZEN_ROOTSTRAP = $TIZEN_ROOTSTRAP"
LDFLAGS="$LDFLAGS --sysroot=${TIZEN_ROOTSTRAP}"
LDFLAGS="$LDFLAGS -L${TIZEN_LIBS}/lib"
CXXFLAGS="$CXXFLAGS -I${TIZEN_LIBS}/include"
;;
webos)
CXXFLAGS="$CXXFLAGS --sysroot=$WEBOS_PDK/arm-gcc/sysroot"
CXXFLAGS="$CXXFLAGS -I$WEBOS_PDK/include"
@ -2319,22 +2310,6 @@ if test -n "$_host"; then
arm-riscos|linupy)
DEFINES="$DEFINES -DLINUPY"
;;
bada)
_unix=yes
_backend="bada"
_port_mk="backends/platform/bada/bada.mk"
if test "$_debug_build" = yes; then
_arm_asm=no
else
_arm_asm=yes
fi
_taskbar=no
_build_scalers=no
_seq_midi=no
_mt32emu=no
_timidity=no
_vkeybd=yes
;;
bfin*)
;;
caanoo)
@ -2647,6 +2622,18 @@ if test -n "$_host"; then
_mt32emu=no
_vkeybd=yes
;;
tizen)
_unix=yes
_backend="tizen"
_port_mk="backends/platform/tizen/tizen.mk"
_arm_asm=yes
_taskbar=no
_build_scalers=no
_seq_midi=no
_mt32emu=no
_timidity=no
_vkeybd=yes
;;
webos)
_backend="webos"
_port_mk="backends/platform/webos/webos.mk"
@ -2697,34 +2684,6 @@ case $_backend in
LDFLAGS="$LDFLAGS -Wl,-z,noexecstack"
INCLUDES="$INCLUDES -I$ANDROID_NDK/sources/cxx-stl/system/include"
;;
bada)
# dirent.h not available. NONSTANDARD_PORT==ensure portdefs.h is included
DEFINES="$DEFINES -DBADA -DDISABLE_STDIO_FILESTREAM -DNONSTANDARD_PORT"
DEFINES="$DEFINES -DNO_STDERR_STDOUT"
DEFINES="$DEFINES -DDISABLE_COMMAND_LINE"
INCLUDES="$INCLUDES "'-I$(srcdir)/backends/platform/bada '
INCLUDES="$INCLUDES "'-I$(BADA_SDK)/include'
INCLUDES="$INCLUDES "'-I$(BADA_SDK_ROOT)/Include'
if test "$_debug_build" = yes; then
# debug using with the simulator
CXXFLAGS="$CXXFLAGS -D_DEBUG -DSHP -DBUILD_DLL -fmessage-length=0"
else
# created a shared library for inclusion via the eclipse build
CXXFLAGS="$CXXFLAGS -DSHP"
CXXFLAGS="$CXXFLAGS -fpic"
CXXFLAGS="$CXXFLAGS -fshort-wchar"
CXXFLAGS="$CXXFLAGS -mcpu=cortex-a8"
CXXFLAGS="$CXXFLAGS -mfpu=vfpv3"
CXXFLAGS="$CXXFLAGS -mfloat-abi=hard"
CXXFLAGS="$CXXFLAGS -mlittle-endian"
CXXFLAGS="$CXXFLAGS -mthumb-interwork"
CXXFLAGS="$CXXFLAGS -Wno-psabi"
CXXFLAGS="$CXXFLAGS -fno-strict-aliasing"
CXXFLAGS="$CXXFLAGS -fno-short-enums"
fi
HOSTEXEPRE=lib
HOSTEXEEXT=.a
;;
dc)
INCLUDES="$INCLUDES "'-I$(srcdir)/backends/platform/dc'
INCLUDES="$INCLUDES "'-isystem $(ronindir)/include'
@ -2807,6 +2766,25 @@ case $_backend in
LDFLAGS="$LDFLAGS -shared"
LDFLAGS="$LDFLAGS -fpic"
;;
tizen)
# dirent.h not available. NONSTANDARD_PORT==ensure portdefs.h is included
DEFINES="$DEFINES -DTIZEN -DDISABLE_STDIO_FILESTREAM -DNONSTANDARD_PORT"
DEFINES="$DEFINES -DNO_STDERR_STDOUT"
DEFINES="$DEFINES -DDISABLE_COMMAND_LINE"
INCLUDES="$INCLUDES "'-I$(srcdir)/backends/platform/tizen'
INCLUDES="$INCLUDES "'-I$(TIZEN_ROOTSTRAP)/usr/include'
INCLUDES="$INCLUDES "'-I$(TIZEN_ROOTSTRAP)/usr/include/osp'
if test "$_debug_build" = yes; then
CXXFLAGS="$CXXFLAGS -D_DEBUG -DBUILD_DLL -O0 -g3"
fi
# created a shared library for inclusion via the eclipse build
CXXFLAGS="$CXXFLAGS -Wno-psabi"
CXXFLAGS="$CXXFLAGS --sysroot=${TIZEN_ROOTSTRAP}"
CXXFLAGS="$CXXFLAGS -fmessage-length=0"
CXXFLAGS="$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.
@ -2872,7 +2850,7 @@ esac
# Enable 16bit support only for backends which support it
#
case $_backend in
android | bada | dingux | dc | gph | iphone | maemo | openpandora | psp | samsungtv | sdl | webos | wii)
android | dingux | dc | gph | iphone | maemo | openpandora | psp | samsungtv | sdl | tizen | webos | wii)
if test "$_16bit" = auto ; then
_16bit=yes
else
@ -3738,7 +3716,7 @@ EOF
fi
case $_host_os in
bada)
tizen)
# components live in non-standard locations so just assume sane SDK
_opengl=yes
_opengles=yes

8
devtools/credits.pl
View File

@ -754,10 +754,6 @@ begin_credits("Credits");
add_person("Angus Lees", "Gus", "");
end_section();
begin_section("BADA");
add_person("Chris Warren-Smith", "", "");
end_section();
begin_section("Dreamcast");
add_person("Marcus Comstedt", "", "");
end_section();
@ -818,6 +814,10 @@ begin_credits("Credits");
add_person("Lars Persson", "AnotherGuest", "");
end_section();
begin_section("Tizen / BADA");
add_person("Chris Warren-Smith", "", "");
end_section();
begin_section("WebOS");
add_person("Klaus Reimer", "kayahr", "");
end_section();

6
gui/credits.h
View File

@ -294,9 +294,6 @@ static const char *credits[] = {
"C0""Andre Heider",
"C0""Angus Lees",
"",
"C1""BADA",
"C0""Chris Warren-Smith",
"",
"C1""Dreamcast",
"C0""Marcus Comstedt",
"",
@ -352,6 +349,9 @@ static const char *credits[] = {
"C0""Jurgen Braam",
"C0""Lars Persson",
"",
"C1""Tizen / BADA",
"C0""Chris Warren-Smith",
"",
"C1""WebOS",
"C0""Klaus Reimer",
"",

8
gui/widgets/edittext.cpp
View File

@ -19,6 +19,7 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "common/system.h"
#include "gui/widgets/edittext.h"
#include "gui/gui-manager.h"
@ -79,8 +80,13 @@ void EditTextWidget::handleMouseDown(int x, int y, int button, int clickCount) {
}
if (setCaretPos(i))
draw();
}
#ifdef TIZEN
// Display the virtual keypad to allow text entry. Samsung app-store testers expected
// the keypad to be displayed when clicking the filter edit control in the laucher gui.
g_system->setFeatureState(OSystem::kFeatureVirtualKeyboard, true);
#endif
}
void EditTextWidget::drawWidget() {
g_gui.theme()->drawWidgetBackground(Common::Rect(_x, _y, _x+_w, _y+_h), 0, ThemeEngine::kWidgetBackgroundEditText);