pandory500/SDL-mirror
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

David Hedbor is no longer maintaining the Qtopia code.

Browse source 
--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%402024
This commit is contained in:
Sam Lantinga 2006-08-10 14:35:42 +00:00
parent 3972b7795d
commit f63cb9f282
18 changed files with 0 additions and 2051 deletions
Download patch file Download diff file Expand all files Collapse all files

84
README.Qtopia
View file

@ -1,84 +0,0 @@
==============================================================================
Using the Simple DirectMedia Layer with Qtopia/OPIE
==============================================================================
==============================================================================
I. Setting up the Qtopia development environment.
This document will not explain how to setup the Qtopia development
environment. That is outside the scope of the document. You can read
more on this subject in this excellent howto:
http://www.zauruszone.com/howtos/linux_compiler_setup_howto.html
==============================================================================
II. Building the Simple DirectMedia Layer libraries using the arm
cross-compiler
This is somewhat tricky since the name of the compiler binaries
differ from the standard. Also you should disable features not
needed. The command below works for me. Note that it's all one
line. You can also set the NM, LD etc environment variables
separately.
NM=arm-linux-nm LD=arm-linux-ld CC=arm-linux-gcc CXX=arm-linux-g++ RANLIB=arm-linux-ranlib AR=arm-linux-ar ./configure --enable-video-qtopia --disable-video-dummy --disable-video-fbcon --disable-video-dga --disable-arts --disable-esd --disable-alsa --disable-cdrom --disable-video-x11 --disable-nasm --prefix=/opt/Qtopia/sharp/ arm-unknown-linux-gnu
One thing to note is that the above configure will include joystick
support, even though you can't have joysticks on the Zaurus. The
reason for this is to avoid link / compile / runtime errors with
applications that have joystick support.
==============================================================================
III. Building the Simple DirectMedia Layer test programs:
After installing, making sure the correct sdl-config is in your
path, run configure like this:
NM=arm-linux-nm LD=arm-linux-ld CC=arm-linux-gcc CXX=arm-linux-g++ AR=arm-linux-ar ./configure arm-unknown-linux-gnu
==============================================================================
IV. Application porting notes
One thing I have noticed is that applications sometimes don't exit
correctly. Their icon remains in the taskbar and they tend to
relaunch themselves automatically. I believe this problem doesn't
occur if you exit your application using the exit() method. However,
if you end main() with 'return 0;' or so, this seems to happen.
Also note that when running in landscape mode - i.e requesting a
window that is HEIGHT pixels wide and WIDTH pixels high, where WIDTH
and HEIGHT normally is 240 and 320 - the image is blitted so that
the hardware buttons are on the left side of the display. This might
not always be desirable but such is the code today.
==============================================================================
V. Enjoy! :)
If you have a project you'd like me to know about, or want to ask questions,
go ahead and join the SDL developer's mailing list by sending e-mail to:
sdl-request@libsdl.org
and put "subscribe" into the subject of the message. Or alternatively you
can use the web interface:
http://www.libsdl.org/mailman/listinfo/sdl
==============================================================================
VI. What is supported:
Keyboard (Sharp Zaurus)
Hardware buttons
Stylus input (mouse)
Video. Allows fullscreen both in portrait mode (up to WIDTHxHEIGHT
size window) and in landscape mode (up to HEIGHTxWIDTH).
All other SDL functionality works like a normal Linux system (threads,
audio etc).
--
David Hedbor <david@hedbor.org>
http://david.hedbor.org/ http://eongames.com/

35
configure.in
View file

@ -1268,40 +1268,6 @@ AC_HELP_STRING([--enable-video-wscons], [use wscons video driver [[default=yes]]
fi
}
dnl Set up the QTopia video driver if enabled
CheckQtopia()
{
AC_ARG_ENABLE(video-qtopia,
AC_HELP_STRING([--enable-video-qtopia], [use Qtopia video driver [[default=no]]]),
, enable_video_qtopia=no)
if test x$enable_video = xyes -a x$enable_video_qtopia = xyes; then
AC_MSG_CHECKING(for Qtopia support)
video_qtopia=no
QTOPIA_FLAGS="-DQT_QWS_EBX -DQT_QWS_CUSTOM -DQWS -I${QPEDIR}/include -I${QTDIR}/include/ -DNO_DEBUG -fno-rtti -fno-exceptions"
AC_LANG_CPLUSPLUS
OLD_CXX="$CXXFLAGS"
CXXFLAGS="$QTOPIA_FLAGS"
AC_TRY_COMPILE([
#include <qpe/qpeapplication.h>
],[
],[
video_qtopia=yes
])
CXXFLAGS="$OLD_CXX"
AC_MSG_RESULT($video_qtopia)
if test x$video_qtopia = xyes; then
AC_DEFINE(SDL_VIDEO_DRIVER_QTOPIA)
SOURCES="$SOURCES $srcdir/src/video/qtopia/*.cc"
SDLMAIN_SOURCES="$srcdir/src/main/qtopia/*.cc"
EXTRA_CFLAGS="$EXTRA_CFLAGS $QTOPIA_FLAGS"
SDL_CFLAGS="$SDL_CFLAGS -DQWS -Dmain=SDL_main"
SDL_LIBS="-lSDLmain $SDL_LIBS -L${QPEDIR}/lib -L${QTDIR}/lib/ -lqpe -lqte"
have_video=yes
fi
AC_LANG_C
fi
}
dnl Set up the Atari Bios keyboard driver
CheckAtariBiosEvent()
{
@ -2045,7 +2011,6 @@ case "$host" in
CheckSVGA
CheckVGL
CheckWscons
CheckQtopia
CheckOpenGLX11
CheckInputEvents
CheckTslib

1
include/SDL_config.h.in
View file

@ -266,7 +266,6 @@
#undef SDL_VIDEO_DRIVER_OS2FS
#undef SDL_VIDEO_DRIVER_PHOTON
#undef SDL_VIDEO_DRIVER_PS2GS
#undef SDL_VIDEO_DRIVER_QTOPIA
#undef SDL_VIDEO_DRIVER_RISCOS
#undef SDL_VIDEO_DRIVER_SVGALIB
#undef SDL_VIDEO_DRIVER_TOOLBOX

56
src/main/qtopia/SDL_qtopia_main.cc
View file

@ -1,56 +0,0 @@
/* Include the SDL main definition header */
#include "SDL_main.h"
#include <stdlib.h>
#include <unistd.h>
#ifdef main
#undef main
#endif
#ifdef QWS
#include <qpe/qpeapplication.h>
#include <qapplication.h>
#include <qpe/qpeapplication.h>
#include <stdlib.h>
// Workaround for OPIE to remove taskbar icon. Also fixes
// some issues in Qtopia where there are left-over qcop files in /tmp/.
// I'm guessing this will also clean up the taskbar in the Sharp version
// of Qtopia.
static inline void
cleanupQCop()
{
QString appname(qApp->argv()[0]);
int slash = appname.findRev("/");
if (slash != -1) {
appname = appname.mid(slash + 1);
}
QString cmd =
QPEApplication::qpeDir() +
"bin/qcop QPE/System 'closing(QString)' '" + appname + "'";
system(cmd.latin1());
cmd = "/tmp/qcop-msg-" + appname;
unlink(cmd.latin1());
}
static QPEApplication *app;
#endif
extern int SDL_main(int argc, char *argv[]);
int
main(int argc, char *argv[])
{
#ifdef QWS
// This initializes the Qtopia application. It needs to be done here
// because it parses command line options.
app = new QPEApplication(argc, argv);
QWidget dummy;
app->showMainWidget(&dummy);
atexit(cleanupQCop);
#endif
// Exit here because if return is used, the application
// doesn't seem to quit correctly.
exit(SDL_main(argc, argv));
}
/* vi: set ts=4 sw=4 expandtab: */

3
src/video/SDL_sysvideo.h
View file

@ -306,9 +306,6 @@ extern VideoBootStrap NX_bootstrap;
#if SDL_VIDEO_DRIVER_IPOD
extern VideoBootStrap iPod_bootstrap;
#endif
#if SDL_VIDEO_DRIVER_QTOPIA
extern VideoBootStrap Qtopia_bootstrap;
#endif
#if SDL_VIDEO_DRIVER_WSCONS
extern VideoBootStrap WSCONS_bootstrap;
#endif

3
src/video/SDL_video.c
View file

@ -55,9 +55,6 @@ static VideoBootStrap *bootstrap[] = {
#if SDL_VIDEO_DRIVER_IPOD
&iPod_bootstrap,
#endif
#if SDL_VIDEO_DRIVER_QTOPIA
&Qtopia_bootstrap,
#endif
#if SDL_VIDEO_DRIVER_WSCONS
&WSCONS_bootstrap,
#endif

68
src/video/qtopia/SDL_QPEApp.cc
View file

@ -1,68 +0,0 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2004 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include <qpe/qpeapplication.h>
#include <qapplication.h>
#include <qevent.h>
#include "SDL_thread.h"
#include "SDL_timer.h"
#include "SDL_error.h"
/* Flag to tell whether or not the Be application is active or not */
int SDL_QPEAppActive = 0;
static QPEApplication *app;
int
SDL_InitQPEApp()
{
if (SDL_QPEAppActive <= 0) {
if (!qApp) {
int argc = 1;
char *argv[] = { {"SDLApp"} };
app = new QPEApplication(argc, argv);
QWidget dummy;
app->showMainWidget(&dummy);
} else {
app = (QPEApplication *) qApp;
}
SDL_QPEAppActive++;
}
return 0;
}
/* Quit the QPE Application, if there's nothing left to do */
void
SDL_QuitQPEApp(void)
{
/* Decrement the application reference count */
SDL_QPEAppActive--;
/* If the reference count reached zero, clean up the app */
if (SDL_QPEAppActive == 0 && app) {
delete app;
app = 0;
qApp = 0;
}
}
/* vi: set ts=4 sw=4 expandtab: */

34
src/video/qtopia/SDL_QPEApp.h
View file

@ -1,34 +0,0 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
/* Handle the QPE application loop */
/* Initialize the QPE Application, if it's not already started */
extern int SDL_InitQPEApp(void);
/* Quit the QPE Application, if there's nothing left to do */
extern void SDL_QuitQPEApp(void);
/* Flag to tell whether the app is active or not */
extern int SDL_QPEAppActive;
/* vi: set ts=4 sw=4 expandtab: */

693
src/video/qtopia/SDL_QWin.cc
View file

@ -1,693 +0,0 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include "SDL_QWin.h"
#include <qapplication.h>
#include <qdirectpainter_qws.h>
screenRotationT screenRotation = SDL_QT_NO_ROTATION;
SDL_QWin::SDL_QWin(const QSize & size):
QWidget(0, "SDL_main"),
my_painter(0),
my_image(0),
my_inhibit_resize(false),
my_mouse_pos(-1, -1),
my_flags(0),
my_has_fullscreen(false),
my_locked(0)
{
setBackgroundMode(NoBackground);
}
SDL_QWin::~SDL_QWin()
{
// Nothing to do yet.
if (my_image) {
delete my_image;
}
}
void
SDL_QWin::setImage(QImage * image)
{
if (my_image) {
delete my_image;
}
my_image = image;
// setFixedSize(image->size());
}
void
SDL_QWin::resizeEvent(QResizeEvent * e)
{
if (size() != qApp->desktop()->size()) {
// Widget is not the correct size, so do the fullscreen magic
my_has_fullscreen = false;
enableFullscreen();
}
if (my_inhibit_resize) {
my_inhibit_resize = false;
} else {
SDL_PrivateResize(e->size().width(), e->size().height());
}
}
void
SDL_QWin::focusInEvent(QFocusEvent *)
{
// Always do it here, no matter the size.
enableFullscreen();
SDL_PrivateAppActive(true, SDL_APPINPUTFOCUS);
}
void
SDL_QWin::focusOutEvent(QFocusEvent *)
{
my_has_fullscreen = false;
SDL_PrivateAppActive(false, SDL_APPINPUTFOCUS);
}
void
SDL_QWin::closeEvent(QCloseEvent * e)
{
SDL_PrivateQuit();
e->ignore();
}
void
SDL_QWin::setMousePos(const QPoint & pos)
{
if (my_image->width() == height()) {
if (screenRotation == SDL_QT_ROTATION_90)
my_mouse_pos = QPoint(height() - pos.y(), pos.x());
else if (screenRotation == SDL_QT_ROTATION_270)
my_mouse_pos = QPoint(pos.y(), width() - pos.x());
} else {
my_mouse_pos = pos;
}
}
void
SDL_QWin::mouseMoveEvent(QMouseEvent * e)
{
Qt::ButtonState button = e->button();
int sdlstate = 0;
if ((button & Qt::LeftButton)) {
sdlstate |= SDL_BUTTON_LMASK;
}
if ((button & Qt::RightButton)) {
sdlstate |= SDL_BUTTON_RMASK;
}
if ((button & Qt::MidButton)) {
sdlstate |= SDL_BUTTON_MMASK;
}
setMousePos(e->pos());
SDL_PrivateMouseMotion(sdlstate, 0, my_mouse_pos.x(), my_mouse_pos.y());
}
void
SDL_QWin::mousePressEvent(QMouseEvent * e)
{
mouseMoveEvent(e);
Qt::ButtonState button = e->button();
SDL_PrivateMouseButton(SDL_PRESSED,
(button & Qt::LeftButton) ? 1 :
((button & Qt::RightButton) ? 2 : 3),
my_mouse_pos.x(), my_mouse_pos.y());
}
void
SDL_QWin::mouseReleaseEvent(QMouseEvent * e)
{
setMousePos(e->pos());
Qt::ButtonState button = e->button();
SDL_PrivateMouseButton(SDL_RELEASED,
(button & Qt::LeftButton) ? 1 :
((button & Qt::RightButton) ? 2 : 3),
my_mouse_pos.x(), my_mouse_pos.y());
my_mouse_pos = QPoint(-1, -1);
}
static inline void
gs_fastRotateBlit_3(unsigned short *fb,
unsigned short *bits, const QRect & rect)
{
// FIXME: this only works correctly for 240x320 displays
int startx, starty;
int width, height;
startx = rect.left() >> 1;
starty = rect.top() >> 1;
width = ((rect.right() - rect.left()) >> 1) + 2;
height = ((rect.bottom() - rect.top()) >> 1) + 2;
if ((startx + width) > 120) {
width = 120 - startx; // avoid horizontal overflow
}
if ((starty + height) > 160) {
height = 160 - starty; // avoid vertical overflow
}
ulong *sp1, *sp2, *dp1, *dp2;
ulong stop, sbot, dtop, dbot;
sp1 = (ulong *) bits + startx + starty * 240;
sp2 = sp1 + 120;
dp1 = (ulong *) fb + (159 - starty) + startx * 320;
dp2 = dp1 + 160;
int rowadd = (-320 * width) - 1;
int rowadd2 = 240 - width;
// transfer in cells of 2x2 pixels in words
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
// read source pixels
stop = *sp1;
sbot = *sp2;
// rotate pixels
dtop = (sbot & 0xffff) + ((stop & 0xffff) << 16);
dbot = ((sbot & 0xffff0000) >> 16) + (stop & 0xffff0000);
// write to framebuffer
*dp1 = dtop;
*dp2 = dbot;
// update source ptrs
sp1++;
sp2++;
// update dest ptrs - 2 pix at a time
dp1 += 320;
dp2 += 320;
}
// adjust src ptrs - skip a row as we work in pairs
sp1 += rowadd2;
sp2 += rowadd2;
// adjust dest ptrs for rotation
dp1 += rowadd;
dp2 += rowadd;
}
}
static inline void
gs_fastRotateBlit_1(unsigned short *fb,
unsigned short *bits, const QRect & rect)
{
// FIXME: this only works correctly for 240x320 displays
int startx, starty;
int width, height;
startx = rect.left() >> 1;
starty = rect.top() >> 1;
width = ((rect.right() - rect.left()) >> 1) + 2;
height = ((rect.bottom() - rect.top()) >> 1) + 2;
if ((startx + width) > 120) {
width = 120 - startx; // avoid horizontal overflow
}
if ((starty + height) > 160) {
height = 160 - starty; // avoid vertical overflow
}
ulong *sp1, *sp2, *dp1, *dp2;
ulong stop, sbot, dtop, dbot;
fb += 320 * 239; // Move "fb" to top left corner
sp1 = (ulong *) bits + startx + starty * 240;
sp2 = sp1 + 120;
dp1 = (ulong *) fb - startx * 320 - starty;
dp2 = dp1 - 160;
int rowadd = (320 * width) + 1;
int rowadd2 = 240 - width;
// transfer in cells of 2x2 pixels in words
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
// read
stop = *sp1;
sbot = *sp2;
// rotate
dtop = (stop & 0xffff) + ((sbot & 0xffff) << 16);
dbot = ((stop & 0xffff0000) >> 16) + (sbot & 0xffff0000);
// write
*dp1 = dtop;
*dp2 = dbot;
// update source ptrs
sp1++;
sp2++;
// update dest ptrs - 2 pix at a time
dp1 -= 320;
dp2 -= 320;
}
// adjust src ptrs - skip a row as we work in pairs
sp1 += rowadd2;
sp2 += rowadd2;
// adjust dest ptrs for rotation
dp1 += rowadd;
dp2 += rowadd;
}
}
// desktop, SL-A300 etc
/* *INDENT-OFF* */
bool SDL_QWin::repaintRotation0 (const QRect & rect)
{
if (my_image->width () == width ()) {
uchar * fb = (uchar *) my_painter->frameBuffer ();
uchar * buf = (uchar *) my_image->bits ();
if (rect == my_image->rect ()) {
SDL_memcpy (fb, buf, width () * height () * 2);
} else {
int h = rect.height ();
int wd = rect.width () << 1;
int fblineadd = my_painter->lineStep ();
int buflineadd = my_image->bytesPerLine ();
fb += (rect.left () << 1) + rect.top () * my_painter->lineStep ();
buf += (rect.left () << 1) + rect.top () * my_image->bytesPerLine ();
while (h--) {
SDL_memcpy (fb, buf, wd);
fb += fblineadd;
buf += buflineadd;
}
}
} else {
return false; // FIXME: Landscape
}
#ifdef __i386__
my_painter->fillRect (rect, QBrush (Qt::NoBrush));
#endif
return true;
}
/* *INDENT-ON* */
// Sharp Zaurus SL-5500 etc
/* *INDENT-OFF* */
bool SDL_QWin::repaintRotation3 (const QRect & rect)
{
if (my_image->width () == width ()) {
ushort * fb = (ushort *) my_painter->frameBuffer ();
ushort * buf = (ushort *) my_image->bits ();
gs_fastRotateBlit_3 (fb, buf, rect);
} else {
// landscape mode
if (screenRotation == SDL_QT_ROTATION_90) {
uchar * fb = (uchar *) my_painter->frameBuffer ();
uchar * buf = (uchar *) my_image->bits ();
if (rect == my_image->rect ()) {
SDL_memcpy (fb, buf, width () * height () * 2);
} else {
int h = rect.height ();
int wd = rect.width () << 1;
int fblineadd = my_painter->lineStep ();
int buflineadd = my_image->bytesPerLine ();
fb +=
(rect.left () << 1) +
rect.top () * my_painter->lineStep ();
buf +=
(rect.left () << 1) +
rect.top () * my_image->bytesPerLine ();
while (h--) {
SDL_memcpy (fb, buf, wd);
fb += fblineadd;
buf += buflineadd;
}
}
} else if (screenRotation == SDL_QT_ROTATION_270) {
int h = rect.height ();
int wd = rect.width ();
int fblineadd = my_painter->lineStep () - (rect.width () << 1);
int buflineadd = my_image->bytesPerLine () - (rect.width () << 1);
int w;
uchar * fb = (uchar *) my_painter->frameBuffer ();
uchar * buf = (uchar *) my_image->bits ();
fb +=
((my_painter->width () -
(rect.top () +
rect.height ())) * my_painter->lineStep ()) +
((my_painter->height () -
((rect.left () + rect.width ()))) << 1);
buf +=
my_image->bytesPerLine () * (rect.top () +
rect.height ()) -
(((my_image->width () -
(rect.left () + rect.width ())) << 1) + 2);
while (h--) {
w = wd;
while (w--)
*((unsigned short *) fb)++ = *((unsigned short *) buf)--;
fb += fblineadd;
buf -= buflineadd;
}
}
}
return true;
}
/* *INDENT-ON* */
// ipaq 3800...
/* *INDENT-OFF* */
bool SDL_QWin::repaintRotation1 (const QRect & rect)
{
if (my_image->width () == width ()) {
ushort *fb = (ushort *) my_painter->frameBuffer ();
ushort *buf = (ushort *) my_image->bits ();
gs_fastRotateBlit_1 (fb, buf, rect);
} else {
return false; // FIXME: landscape mode
}
return true;
}
/* *INDENT-ON* */
void
SDL_QWin::repaintRect(const QRect & rect)
{
if (!my_painter || !rect.width() || !rect.height()) {
return;
}
if (QPixmap::defaultDepth() == 16) {
switch (my_painter->transformOrientation()) {
case 3:
if (repaintRotation3(rect)) {
return;
}
break;
case 1:
if (repaintRotation1(rect)) {
return;
}
break;
case 0:
if (repaintRotation0(rect)) {
return;
}
break;
}
}
my_painter->drawImage(rect.topLeft(), *my_image, rect);
}
// This paints the current buffer to the screen, when desired.
void
SDL_QWin::paintEvent(QPaintEvent * ev)
{
if (my_image) {
lockScreen(true);
repaintRect(ev->rect());
unlockScreen();
}
}
/* Function to translate a keyboard transition and queue the key event
* This should probably be a table although this method isn't exactly
* slow.
*/
void
SDL_QWin::QueueKey(QKeyEvent * e, int pressed)
{
SDL_keysym keysym;
int scancode = e->key();
/* Set the keysym information */
if (scancode >= 'A' && scancode <= 'Z') {
// Qt sends uppercase, SDL wants lowercase
keysym.sym = static_cast < SDLKey > (scancode + 32);
} else if (scancode >= 0x1000) {
// Special keys
switch (scancode) {
case Qt::Key_Escape:
scancode = SDLK_ESCAPE;
break;
case Qt::Key_Tab:
scancode = SDLK_TAB;
break;
case Qt::Key_Backspace:
scancode = SDLK_BACKSPACE;
break;
case Qt::Key_Return:
scancode = SDLK_RETURN;
break;
case Qt::Key_Enter:
scancode = SDLK_KP_ENTER;
break;
case Qt::Key_Insert:
scancode = SDLK_INSERT;
break;
case Qt::Key_Delete:
scancode = SDLK_DELETE;
break;
case Qt::Key_Pause:
scancode = SDLK_PAUSE;
break;
case Qt::Key_Print:
scancode = SDLK_PRINT;
break;
case Qt::Key_SysReq:
scancode = SDLK_SYSREQ;
break;
case Qt::Key_Home:
scancode = SDLK_HOME;
break;
case Qt::Key_End:
scancode = SDLK_END;
break;
// We want the control keys to rotate with the screen
case Qt::Key_Left:
if (screenRotation == SDL_QT_ROTATION_90)
scancode = SDLK_UP;
else if (screenRotation == SDL_QT_ROTATION_270)
scancode = SDLK_DOWN;
else
scancode = SDLK_LEFT;
break;
case Qt::Key_Up:
if (screenRotation == SDL_QT_ROTATION_90)
scancode = SDLK_RIGHT;
else if (screenRotation == SDL_QT_ROTATION_270)
scancode = SDLK_LEFT;
else
scancode = SDLK_UP;
break;
case Qt::Key_Right:
if (screenRotation == SDL_QT_ROTATION_90)
scancode = SDLK_DOWN;
else if (screenRotation == SDL_QT_ROTATION_270)
scancode = SDLK_UP;
else
scancode = SDLK_RIGHT;
break;
case Qt::Key_Down:
if (screenRotation == SDL_QT_ROTATION_90)
scancode = SDLK_LEFT;
else if (screenRotation == SDL_QT_ROTATION_270)
scancode = SDLK_RIGHT;
else
scancode = SDLK_DOWN;
break;
case Qt::Key_Prior:
scancode = SDLK_PAGEUP;
break;
case Qt::Key_Next:
scancode = SDLK_PAGEDOWN;
break;
case Qt::Key_Shift:
scancode = SDLK_LSHIFT;
break;
case Qt::Key_Control:
scancode = SDLK_LCTRL;
break;
case Qt::Key_Meta:
scancode = SDLK_LMETA;
break;
case Qt::Key_Alt:
scancode = SDLK_LALT;
break;
case Qt::Key_CapsLock:
scancode = SDLK_CAPSLOCK;
break;
case Qt::Key_NumLock:
scancode = SDLK_NUMLOCK;
break;
case Qt::Key_ScrollLock:
scancode = SDLK_SCROLLOCK;
break;
case Qt::Key_F1:
scancode = SDLK_F1;
break;
case Qt::Key_F2:
scancode = SDLK_F2;
break;
case Qt::Key_F3:
scancode = SDLK_F3;
break;
case Qt::Key_F4:
scancode = SDLK_F4;
break;
case Qt::Key_F5:
scancode = SDLK_F5;
break;
case Qt::Key_F6:
scancode = SDLK_F6;
break;
case Qt::Key_F7:
scancode = SDLK_F7;
break;
case Qt::Key_F8:
scancode = SDLK_F8;
break;
case Qt::Key_F9:
scancode = SDLK_F9;
break;
case Qt::Key_F10:
scancode = SDLK_F10;
break;
case Qt::Key_F11:
scancode = SDLK_F11;
break;
case Qt::Key_F12:
scancode = SDLK_F12;
break;
case Qt::Key_F13:
scancode = SDLK_F13;
break;
case Qt::Key_F14:
scancode = SDLK_F14;
break;
case Qt::Key_F15:
scancode = SDLK_F15;
break;
case Qt::Key_Super_L:
scancode = SDLK_LSUPER;
break;
case Qt::Key_Super_R:
scancode = SDLK_RSUPER;
break;
case Qt::Key_Menu:
scancode = SDLK_MENU;
break;
case Qt::Key_Help:
scancode = SDLK_HELP;
break;
case Qt::Key_F33:
// FIXME: This is a hack to enable the OK key on
// Zaurii devices. SDLK_RETURN is a suitable key to use
// since it often is used as such.
// david@hedbor.org
scancode = SDLK_RETURN;
break;
default:
scancode = SDLK_UNKNOWN;
break;
}
keysym.sym = static_cast < SDLKey > (scancode);
} else {
keysym.sym = static_cast < SDLKey > (scancode);
}
keysym.scancode = scancode;
keysym.mod = KMOD_NONE;
ButtonState st = e->state();
if ((st & ShiftButton)) {
keysym.mod = static_cast < SDLMod > (keysym.mod | KMOD_LSHIFT);
}
if ((st & ControlButton)) {
keysym.mod = static_cast < SDLMod > (keysym.mod | KMOD_LCTRL);
}
if ((st & AltButton)) {
keysym.mod = static_cast < SDLMod > (keysym.mod | KMOD_LALT);
}
if (SDL_TranslateUNICODE) {
QChar qchar = e->text()[0];
keysym.unicode = qchar.unicode();
} else {
keysym.unicode = 0;
}
/* NUMLOCK and CAPSLOCK are implemented as double-presses in reality */
// if ( (keysym.sym == SDLK_NUMLOCK) || (keysym.sym == SDLK_CAPSLOCK) ) {
// pressed = 1;
// }
/* Queue the key event */
if (pressed) {
SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
} else {
SDL_PrivateKeyboard(SDL_RELEASED, &keysym);
}
}
void
SDL_QWin::setFullscreen(bool fs_on)
{
my_has_fullscreen = false;
enableFullscreen();
}
void
SDL_QWin::enableFullscreen()
{
// Make sure size is correct
if (!my_has_fullscreen) {
setFixedSize(qApp->desktop()->size());
// This call is needed because showFullScreen won't work
// correctly if the widget already considers itself to be fullscreen.
showNormal();
// This is needed because showNormal() forcefully changes the window
// style to WSTyle_TopLevel.
setWFlags(WStyle_Customize | WStyle_NoBorder);
// Enable fullscreen.
showFullScreen();
my_has_fullscreen = true;
}
}
/* *INDENT-OFF* */
bool
SDL_QWin::lockScreen (bool force)
{
if (!my_painter) {
if (force || (isVisible () && isActiveWindow ())) {
my_painter = new QDirectPainter (this);
} else {
return false;
}
}
my_locked++; // Increate lock refcount
return true;
}
/* *INDENT-ON* */
void
SDL_QWin::unlockScreen()
{
if (my_locked > 0) {
my_locked--; // decrease lock refcount;
}
if (!my_locked && my_painter) {
my_painter->end();
delete my_painter;
my_painter = 0;
}
}
/* vi: set ts=4 sw=4 expandtab: */

130
src/video/qtopia/SDL_QWin.h
View file

@ -1,130 +0,0 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#ifndef _SDL_QWin_h
#define _SDL_QWin_h
#include <stdio.h>
#include <qimage.h>
#include <qpixmap.h>
#include <qwidget.h>
#include <qpainter.h>
#include <qdirectpainter_qws.h>
#include "SDL_events.h"
extern "C"
{
#include "../../events/SDL_events_c.h"
};
typedef enum
{
SDL_QT_NO_ROTATION = 0,
SDL_QT_ROTATION_90,
SDL_QT_ROTATION_270
} screenRotationT;
extern screenRotationT screenRotation;
class SDL_QWin:public QWidget
{
void QueueKey(QKeyEvent * e, int pressed);
public:
SDL_QWin(const QSize & size);
virtual ~ SDL_QWin();
virtual bool shown(void)
{
return isVisible();
}
/* If called, the next resize event will not be forwarded to SDL. */
virtual void inhibitResize(void)
{
my_inhibit_resize = true;
}
void setImage(QImage * image);
void setOffset(int x, int y)
{
my_offset = QPoint(x, y);
}
void GetXYOffset(int &x, int &y)
{
x = my_offset.x();
y = my_offset.y();
}
QImage *image(void)
{
return my_image;
}
void setWFlags(WFlags flags)
{
QWidget::setWFlags(flags);
my_flags = flags;
}
const QPoint & mousePos() const
{
return my_mouse_pos;
}
void setMousePos(const QPoint & newpos);
void setFullscreen(bool);
bool lockScreen(bool force = false);
void unlockScreen();
void repaintRect(const QRect & rect);
protected:
/* Handle resizing of the window */
virtual void resizeEvent(QResizeEvent * e);
void focusInEvent(QFocusEvent *);
void focusOutEvent(QFocusEvent *);
void closeEvent(QCloseEvent * e);
void mouseMoveEvent(QMouseEvent * e);
void mousePressEvent(QMouseEvent * e);
void mouseReleaseEvent(QMouseEvent * e);
void paintEvent(QPaintEvent * ev);
void keyPressEvent(QKeyEvent * e)
{
QueueKey(e, 1);
}
void keyReleaseEvent(QKeyEvent * e)
{
QueueKey(e, 0);
}
private:
bool repaintRotation0(const QRect & rect);
bool repaintRotation1(const QRect & rect);
bool repaintRotation3(const QRect & rect);
void enableFullscreen();
QDirectPainter *my_painter;
QImage *my_image;
bool my_inhibit_resize;
QPoint my_offset;
QPoint my_mouse_pos;
WFlags my_flags;
WFlags my_has_fullscreen;
unsigned int my_locked;
};
#endif /* _SDL_QWin_h */
/* vi: set ts=4 sw=4 expandtab: */

67
src/video/qtopia/SDL_lowvideo.h
View file

@ -1,67 +0,0 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#ifndef _SDL_lowvideo_h
#define _SDL_lowvideo_h
#include "SDL_mouse.h"
#include "../SDL_sysvideo.h"
/* Hidden "this" pointer for the video functions */
#define _THIS SDL_VideoDevice *_this
/* Private display data */
struct SDL_PrivateVideoData
{
/* The main window */
SDL_QWin *SDL_Win;
/* The fullscreen mode list */
#define NUM_MODELISTS 4 /* 8, 16, 24, and 32 bits-per-pixel */
int SDL_nummodes[NUM_MODELISTS];
SDL_Rect **SDL_modelist[NUM_MODELISTS];
/* A completely clear cursor */
WMcursor *BlankCursor;
/* Mouse state variables */
Uint32 last_buttons;
QPoint last_point;
/* Keyboard state variables */
int key_flip;
//struct key_info keyinfo[2];
};
/* Old variable names */
#define SDL_Win (_this->hidden->SDL_Win)
#define saved_mode (_this->hidden->saved_mode)
#define SDL_nummodes (_this->hidden->SDL_nummodes)
#define SDL_modelist (_this->hidden->SDL_modelist)
#define SDL_BlankCursor (_this->hidden->BlankCursor)
#define last_buttons (_this->hidden->last_buttons)
#define last_point (_this->hidden->last_point)
#define key_flip (_this->hidden->key_flip)
#define keyinfo (_this->hidden->keyinfo)
#endif /* _SDL_lowvideo_h */
/* vi: set ts=4 sw=4 expandtab: */

272
src/video/qtopia/SDL_sysevents.cc
View file

@ -1,272 +0,0 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include <qpe/qpeapplication.h>
#include <stdio.h>
#include <string.h>
#include "SDL_error.h"
#include "SDL_events.h"
#include "SDL_QWin.h"
#include "SDL_lowvideo.h"
#include "SDL_timer.h"
extern "C"
{
#include "../../events/SDL_sysevents.h"
#include "../../events/SDL_events_c.h"
#include "SDL_sysevents_c.h"
// static SDLKey keymap[128];
/* This is special because we know it will be run in a loop in a separate
thread. Normally this function should loop as long as there are input
states changing, i.e. new events arriving.
*/
void QT_PumpEvents(_THIS)
{
if (!qApp) {
return;
}
// printf("processing events: %p\n", qApp);
//qApp->processOneEvent(); // wait for a event
qApp->processEvents(); // and process all outstanding ones
#if 0
BView *view;
BRect bounds;
BPoint point;
uint32 buttons;
const uint32 button_masks[3] = {
B_PRIMARY_MOUSE_BUTTON,
B_TERTIARY_MOUSE_BUTTON,
B_SECONDARY_MOUSE_BUTTON,
};
unsigned int i, j;
/* Check out the mouse buttons and position (slight race condition) */
if (SDL_Win->Lock()) {
/* Don't do anything if we have no view */
view = SDL_Win->View();
if (!view) {
SDL_Win->Unlock();
return;
}
bounds = view->Bounds();
/* Get new input state, if still active */
if (SDL_Win->IsActive()) {
key_flip = !key_flip;
get_key_info(&keyinfo[key_flip]);
view->GetMouse(&point, &buttons, true);
} else {
key_flip = key_flip;
point = last_point;
buttons = last_buttons;
}
SDL_Win->Unlock();
} else {
return;
}
/* If our view is active, we'll find key changes here */
if (SDL_memcmp(keyinfo[0].key_states, keyinfo[1].key_states, 16) != 0) {
for (i = 0; i < 16; ++i) {
Uint8 new_state, transition;
new_state = keyinfo[key_flip].key_states[i];
transition = keyinfo[!key_flip].key_states[i] ^
keyinfo[key_flip].key_states[i];
for (j = 0; j < 8; ++j) {
if (transition & 0x80)
QueueKey(i * 8 + j, new_state & 0x80);
transition <<= 1;
new_state <<= 1;
}
}
}
/* We check keyboard, but not mouse if mouse isn't in window */
if (!bounds.Contains(point)) {
/* Mouse moved outside our view? */
if (SDL_GetAppState() & SDL_APPMOUSEFOCUS) {
SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
be_app->SetCursor(B_HAND_CURSOR);
}
return;
}
/* Has the mouse moved back into our view? */
if (!(SDL_GetAppState() & SDL_APPMOUSEFOCUS)) {
/* Reset the B_HAND_CURSOR to our own */
SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
SDL_SetCursor(NULL);
}
/* Check for mouse motion */
if (point != last_point) {
int x, y;
SDL_Win->GetXYOffset(x, y);
x = (int) point.x - x;
y = (int) point.y - y;
SDL_PrivateMouseMotion(0, 0, x, y);
}
last_point = point;
/* Add any mouse button events */
for (i = 0; i < SDL_TABLESIZE(button_masks); ++i) {
if ((buttons ^ last_buttons) & button_masks[i]) {
if (buttons & button_masks[i]) {
SDL_PrivateMouseButton(SDL_PRESSED, 1 + i, 0, 0);
} else {
SDL_PrivateMouseButton(SDL_RELEASED, 1 + i, 0, 0);
}
}
}
last_buttons = buttons;
#endif
}
void QT_InitOSKeymap(_THIS)
{
#if 0
unsigned int i;
/* Initialize all the key states as "up" */
key_flip = 0;
SDL_memset(keyinfo[key_flip].key_states, 0, 16);
/* Initialize the key translation table */
for (i = 0; i < SDL_TABLESIZE(keymap); ++i)
keymap[i] = SDLK_UNKNOWN;
// keymap[0x01] = SDLK_ESCAPE;
// keymap[B_F1_KEY] = SDLK_F1;
// keymap[B_F2_KEY] = SDLK_F2;
// keymap[B_F3_KEY] = SDLK_F3;
// keymap[B_F4_KEY] = SDLK_F4;
// keymap[B_F5_KEY] = SDLK_F5;
// keymap[B_F6_KEY] = SDLK_F6;
// keymap[B_F7_KEY] = SDLK_F7;
// keymap[B_F8_KEY] = SDLK_F8;
// keymap[B_F9_KEY] = SDLK_F9;
// keymap[B_F10_KEY] = SDLK_F10;
// keymap[B_F11_KEY] = SDLK_F11;
// keymap[B_F12_KEY] = SDLK_F12;
// keymap[B_PRINT_KEY] = SDLK_PRINT;
//keymap[B_SCROLL_KEY] = SDLK_SCROLLOCK;
// keymap[B_PAUSE_KEY] = SDLK_PAUSE;
keymap[0x11] = SDLK_BACKQUOTE;
keymap[0x12] = SDLK_1;
keymap[0x13] = SDLK_2;
keymap[0x14] = SDLK_3;
keymap[0x15] = SDLK_4;
keymap[0x16] = SDLK_5;
keymap[0x17] = SDLK_6;
keymap[0x18] = SDLK_7;
keymap[0x19] = SDLK_8;
keymap[0x1a] = SDLK_9;
keymap[0x1b] = SDLK_0;
keymap[0x1c] = SDLK_MINUS;
keymap[0x1d] = SDLK_EQUALS;
keymap[0x1e] = SDLK_BACKSPACE;
keymap[0x1f] = SDLK_INSERT;
keymap[0x20] = SDLK_HOME;
keymap[0x21] = SDLK_PAGEUP;
//keymap[0x22] = SDLK_NUMLOCK;
keymap[0x23] = SDLK_KP_DIVIDE;
keymap[0x24] = SDLK_KP_MULTIPLY;
keymap[0x25] = SDLK_KP_MINUS;
keymap[0x26] = SDLK_TAB;
keymap[0x27] = SDLK_q;
keymap[0x28] = SDLK_w;
keymap[0x29] = SDLK_e;
keymap[0x2a] = SDLK_r;
keymap[0x2b] = SDLK_t;
keymap[0x2c] = SDLK_y;
keymap[0x2d] = SDLK_u;
keymap[0x2e] = SDLK_i;
keymap[0x2f] = SDLK_o;
keymap[0x30] = SDLK_p;
keymap[0x31] = SDLK_LEFTBRACKET;
keymap[0x32] = SDLK_RIGHTBRACKET;
keymap[0x33] = SDLK_BACKSLASH;
keymap[0x34] = SDLK_DELETE;
keymap[0x35] = SDLK_END;
keymap[0x36] = SDLK_PAGEDOWN;
keymap[0x37] = SDLK_KP7;
keymap[0x38] = SDLK_KP8;
keymap[0x39] = SDLK_KP9;
keymap[0x3a] = SDLK_KP_PLUS;
//keymap[0x3b] = SDLK_CAPSLOCK;
keymap[0x3c] = SDLK_a;
keymap[0x3d] = SDLK_s;
keymap[0x3e] = SDLK_d;
keymap[0x3f] = SDLK_f;
keymap[0x40] = SDLK_g;
keymap[0x41] = SDLK_h;
keymap[0x42] = SDLK_j;
keymap[0x43] = SDLK_k;
keymap[0x44] = SDLK_l;
keymap[0x45] = SDLK_SEMICOLON;
keymap[0x46] = SDLK_QUOTE;
keymap[0x47] = SDLK_RETURN;
keymap[0x48] = SDLK_KP4;
keymap[0x49] = SDLK_KP5;
keymap[0x4a] = SDLK_KP6;
keymap[0x4b] = SDLK_LSHIFT;
keymap[0x4c] = SDLK_z;
keymap[0x4d] = SDLK_x;
keymap[0x4e] = SDLK_c;
keymap[0x4f] = SDLK_v;
keymap[0x50] = SDLK_b;
keymap[0x51] = SDLK_n;
keymap[0x52] = SDLK_m;
keymap[0x53] = SDLK_COMMA;
keymap[0x54] = SDLK_PERIOD;
keymap[0x55] = SDLK_SLASH;
keymap[0x56] = SDLK_RSHIFT;
keymap[0x57] = SDLK_UP;
keymap[0x58] = SDLK_KP1;
keymap[0x59] = SDLK_KP2;
keymap[0x5a] = SDLK_KP3;
keymap[0x5b] = SDLK_KP_ENTER;
//keymap[0x5c] = SDLK_LCTRL;
//keymap[0x5d] = SDLK_LALT;
keymap[0x5e] = SDLK_SPACE;
//keymap[0x5f] = SDLK_RALT;
//keymap[0x60] = SDLK_RCTRL;
keymap[0x61] = SDLK_LEFT;
keymap[0x62] = SDLK_DOWN;
keymap[0x63] = SDLK_RIGHT;
keymap[0x64] = SDLK_KP0;
keymap[0x65] = SDLK_KP_PERIOD;
//keymap[0x66] = SDLK_LMETA;
//keymap[0x67] = SDLK_RMETA;
//keymap[0x68] = SDLK_MENU;
keymap[0x69] = SDLK_EURO;
keymap[0x6a] = SDLK_KP_EQUALS;
keymap[0x6b] = SDLK_POWER;
#endif
}
}; /* Extern C */
/* vi: set ts=4 sw=4 expandtab: */

32
src/video/qtopia/SDL_sysevents_c.h
View file

@ -1,32 +0,0 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include "SDL_lowvideo.h"
/* Variables and functions exported by SDL_sysevents.c to other parts
of the native video subsystem (SDL_sysvideo.c)
*/
extern void QT_InitOSKeymap(_THIS);
extern void QT_PumpEvents(_THIS);
/* vi: set ts=4 sw=4 expandtab: */

61
src/video/qtopia/SDL_sysmouse.cc
View file

@ -1,61 +0,0 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include "SDL_QWin.h"
extern "C"
{
#include "SDL_sysmouse_c.h"
/* The implementation dependent data for the window manager cursor */
struct WMcursor
{
char *bits;
};
WMcursor *QT_CreateWMCursor(_THIS,
Uint8 * data, Uint8 * mask, int w, int h,
int hot_x, int hot_y)
{
static WMcursor dummy;
dummy.bits = 0;
return &dummy;
}
int QT_ShowWMCursor(_THIS, WMcursor * cursor)
{
return 1;
}
void QT_FreeWMCursor(_THIS, WMcursor * cursor)
{
}
void QT_WarpWMCursor(_THIS, Uint16 x, Uint16 y)
{
SDL_Win->setMousePos(QPoint(x, y));
}
}; /* Extern C */
/* vi: set ts=4 sw=4 expandtab: */

33
src/video/qtopia/SDL_sysmouse_c.h
View file

@ -1,33 +0,0 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include "SDL_lowvideo.h"
/* Functions to be exported */
extern void QT_FreeWMCursor(_THIS, WMcursor * cursor);
extern WMcursor *QT_CreateWMCursor(_THIS,
Uint8 * data, Uint8 * mask, int w, int h,
int hot_x, int hot_y);
extern int QT_ShowWMCursor(_THIS, WMcursor * cursor);
extern void QT_WarpWMCursor(_THIS, Uint16 x, Uint16 y);
/* vi: set ts=4 sw=4 expandtab: */

414
src/video/qtopia/SDL_sysvideo.cc
View file

@ -1,414 +0,0 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
/* Qtopia based framebuffer implementation */
#include <unistd.h>
#include <qapplication.h>
#include <qpe/qpeapplication.h>
#include "SDL_timer.h"
#include "SDL_QWin.h"
extern "C"
{
#include "../SDL_sysvideo.h"
#include "../../events/SDL_events_c.h"
#include "SDL_sysevents_c.h"
#include "SDL_sysmouse_c.h"
#include "SDL_syswm_c.h"
#include "SDL_lowvideo.h"
//#define QTOPIA_DEBUG
#define QT_HIDDEN_SIZE 32 /* starting hidden window size */
/* Name of the environment variable used to invert the screen rotation or not:
Possible values:
!=0 : Screen is 270° rotated
0: Screen is 90° rotated */
#define SDL_QT_ROTATION_ENV_NAME "SDL_QT_INVERT_ROTATION"
/* Initialization/Query functions */
static int QT_VideoInit(_THIS, SDL_PixelFormat * vformat);
static SDL_Rect **QT_ListModes(_THIS, SDL_PixelFormat * format,
Uint32 flags);
static SDL_Surface *QT_SetVideoMode(_THIS, SDL_Surface * current,
int width, int height, int bpp,
Uint32 flags);
static void QT_UpdateMouse(_THIS);
static int QT_SetColors(_THIS, int firstcolor, int ncolors,
SDL_Color * colors);
static void QT_VideoQuit(_THIS);
/* Hardware surface functions */
static int QT_AllocHWSurface(_THIS, SDL_Surface * surface);
static int QT_LockHWSurface(_THIS, SDL_Surface * surface);
static void QT_UnlockHWSurface(_THIS, SDL_Surface * surface);
static void QT_FreeHWSurface(_THIS, SDL_Surface * surface);
static int QT_ToggleFullScreen(_THIS, int fullscreen);
static int QT_IconifyWindow(_THIS);
static SDL_GrabMode QT_GrabInput(_THIS, SDL_GrabMode mode);
/* FB driver bootstrap functions */
static int QT_Available(void)
{
return (1);
}
static void QT_DeleteDevice(SDL_VideoDevice * device)
{
SDL_free(device->hidden);
SDL_free(device);
}
static SDL_VideoDevice *QT_CreateDevice(int devindex)
{
SDL_VideoDevice *device;
/* Initialize all variables that we clean on shutdown */
device = (SDL_VideoDevice *) SDL_malloc(sizeof(SDL_VideoDevice));
if (device) {
SDL_memset(device, 0, (sizeof *device));
device->hidden = (struct SDL_PrivateVideoData *)
SDL_malloc((sizeof *device->hidden));
}
if ((device == NULL) || (device->hidden == NULL)) {
SDL_OutOfMemory();
if (device) {
SDL_free(device);
}
return (0);
}
SDL_memset(device->hidden, 0, (sizeof *device->hidden));
/* Set the function pointers */
device->VideoInit = QT_VideoInit;
device->ListModes = QT_ListModes;
device->SetVideoMode = QT_SetVideoMode;
device->UpdateMouse = QT_UpdateMouse;
device->SetColors = QT_SetColors;
device->UpdateRects = NULL;
device->VideoQuit = QT_VideoQuit;
device->AllocHWSurface = QT_AllocHWSurface;
device->CheckHWBlit = NULL;
device->FillHWRect = NULL;
device->SetHWColorKey = NULL;
device->SetHWAlpha = NULL;
device->LockHWSurface = QT_LockHWSurface;
device->UnlockHWSurface = QT_UnlockHWSurface;
device->FlipHWSurface = NULL;
device->FreeHWSurface = QT_FreeHWSurface;
device->SetIcon = NULL;
device->SetCaption = QT_SetWMCaption;
device->IconifyWindow = QT_IconifyWindow;
device->GrabInput = QT_GrabInput;
device->GetWMInfo = NULL;
device->FreeWMCursor = QT_FreeWMCursor;
device->CreateWMCursor = QT_CreateWMCursor;
device->ShowWMCursor = QT_ShowWMCursor;
device->WarpWMCursor = QT_WarpWMCursor;
device->InitOSKeymap = QT_InitOSKeymap;
device->PumpEvents = QT_PumpEvents;
device->free = QT_DeleteDevice;
device->ToggleFullScreen = QT_ToggleFullScreen;
/* Set the driver flags */
device->handles_any_size = 0;
return device;
}
VideoBootStrap Qtopia_bootstrap = {
"qtopia", "Qtopia / QPE graphics",
QT_Available, QT_CreateDevice
};
/* Function to sort the display_list */
static int CompareModes(const void *A, const void *B)
{
#if 0
const display_mode *a = (display_mode *) A;
const display_mode *b = (display_mode *) B;
if (a->space == b->space) {
return ((b->virtual_width * b->virtual_height) -
(a->virtual_width * a->virtual_height));
} else {
return (ColorSpaceToBitsPerPixel(b->space) -
ColorSpaceToBitsPerPixel(a->space));
}
#endif
return 0;
}
/* Yes, this isn't the fastest it could be, but it works nicely */
static int QT_AddMode(_THIS, int index, unsigned int w, unsigned int h)
{
SDL_Rect *mode;
int i;
int next_mode;
/* Check to see if we already have this mode */
if (SDL_nummodes[index] > 0) {
for (i = SDL_nummodes[index] - 1; i >= 0; --i) {
mode = SDL_modelist[index][i];
if ((mode->w == w) && (mode->h == h)) {
return (0);
}
}
}
/* Set up the new video mode rectangle */
mode = (SDL_Rect *) SDL_malloc(sizeof *mode);
if (mode == NULL) {
SDL_OutOfMemory();
return (-1);
}
mode->x = 0;
mode->y = 0;
mode->w = w;
mode->h = h;
#ifdef QTOPIA_DEBUG
fprintf(stderr, "Adding mode %dx%d at %d bytes per pixel\n", w, h,
index + 1);
#endif
/* Allocate the new list of modes, and fill in the new mode */
next_mode = SDL_nummodes[index];
SDL_modelist[index] = (SDL_Rect **)
SDL_realloc(SDL_modelist[index],
(1 + next_mode + 1) * sizeof(SDL_Rect *));
if (SDL_modelist[index] == NULL) {
SDL_OutOfMemory();
SDL_nummodes[index] = 0;
SDL_free(mode);
return (-1);
}
SDL_modelist[index][next_mode] = mode;
SDL_modelist[index][next_mode + 1] = NULL;
SDL_nummodes[index]++;
return (0);
}
int QT_VideoInit(_THIS, SDL_PixelFormat * vformat)
{
/* Initialize the QPE Application */
/* Determine the screen depth */
vformat->BitsPerPixel = QPixmap::defaultDepth();
// For now we hardcode the current depth because anything else
// might as well be emulated by SDL rather than by Qtopia.
QSize desktop_size = qApp->desktop()->size();
QT_AddMode(_this, ((vformat->BitsPerPixel + 7) / 8) - 1,
desktop_size.width(), desktop_size.height());
QT_AddMode(_this, ((vformat->BitsPerPixel + 7) / 8) - 1,
desktop_size.height(), desktop_size.width());
/* Determine the current screen size */
_this->info.current_w = desktop_size.width();
_this->info.current_h = desktop_size.height();
/* Create the window / widget */
SDL_Win = new SDL_QWin(QSize(QT_HIDDEN_SIZE, QT_HIDDEN_SIZE));
((QPEApplication *) qApp)->showMainWidget(SDL_Win);
/* Fill in some window manager capabilities */
_this->info.wm_available = 0;
/* We're done! */
return (0);
}
/* We support any dimension at our bit-depth */
SDL_Rect **QT_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags)
{
SDL_Rect **modes;
modes = ((SDL_Rect **) 0);
if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
modes = SDL_modelist[((format->BitsPerPixel + 7) / 8) - 1];
} else {
if (format->BitsPerPixel == _this->screen->format->BitsPerPixel) {
modes = ((SDL_Rect **) - 1);
}
}
return (modes);
}
/* Various screen update functions available */
static void QT_NormalUpdate(_THIS, int numrects, SDL_Rect * rects);
static int QT_SetFullScreen(_THIS, SDL_Surface * screen, int fullscreen)
{
return -1;
}
static int QT_ToggleFullScreen(_THIS, int fullscreen)
{
return -1;
}
/* FIXME: check return values and cleanup here */
SDL_Surface *QT_SetVideoMode(_THIS, SDL_Surface * current,
int width, int height, int bpp, Uint32 flags)
{
QImage *qimage;
QSize desktop_size = qApp->desktop()->size();
current->flags = 0; //SDL_FULLSCREEN; // We always run fullscreen.
if (width <= desktop_size.width()
&& height <= desktop_size.height()) {
current->w = desktop_size.width();
current->h = desktop_size.height();
} else if (width <= desktop_size.height()
&& height <= desktop_size.width()) {
// Landscape mode
char *envString = SDL_getenv(SDL_QT_ROTATION_ENV_NAME);
int envValue = envString ? atoi(envString) : 0;
screenRotation =
envValue ? SDL_QT_ROTATION_270 : SDL_QT_ROTATION_90;
current->h = desktop_size.width();
current->w = desktop_size.height();
} else {
SDL_SetError("Unsupported resolution, %dx%d\n", width, height);
}
if (flags & SDL_INTERNALOPENGL) {
SDL_SetError("OpenGL not supported");
return (NULL);
}
/* Create the QImage framebuffer */
qimage = new QImage(current->w, current->h, bpp);
if (qimage->isNull()) {
SDL_SetError("Couldn't create screen bitmap");
delete qimage;
return (NULL);
}
current->pitch = qimage->bytesPerLine();
current->pixels = (void *) qimage->bits();
SDL_Win->setImage(qimage);
_this->UpdateRects = QT_NormalUpdate;
SDL_Win->setFullscreen(true);
/* We're done */
return (current);
}
/* Update the current mouse state and position */
void QT_UpdateMouse(_THIS)
{
QPoint point(-1, -1);
if (SDL_Win->isActiveWindow()) {
point = SDL_Win->mousePos();
}
if ((point.x() >= 0) && (point.x() < SDL_VideoSurface->w) &&
(point.y() >= 0) && (point.y() < SDL_VideoSurface->h)) {
SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
SDL_PrivateMouseMotion(0, 0,
(Sint16) point.x(), (Sint16) point.y());
} else {
SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
}
}
/* We don't actually allow hardware surfaces other than the main one */
static int QT_AllocHWSurface(_THIS, SDL_Surface * surface)
{
return (-1);
}
static void QT_FreeHWSurface(_THIS, SDL_Surface * surface)
{
return;
}
static int QT_LockHWSurface(_THIS, SDL_Surface * surface)
{
return (0);
}
static void QT_UnlockHWSurface(_THIS, SDL_Surface * surface)
{
return;
}
static void QT_NormalUpdate(_THIS, int numrects, SDL_Rect * rects)
{
if (SDL_Win->lockScreen()) {
for (int i = 0; i < numrects; ++i) {
QRect rect(rects[i].x, rects[i].y, rects[i].w, rects[i].h);
SDL_Win->repaintRect(rect);
}
SDL_Win->unlockScreen();
}
}
/* Is the system palette settable? */
int QT_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color * colors)
{
return -1;
}
void QT_VideoQuit(_THIS)
{
// This is dumb, but if I free this, the app doesn't exit correctly.
// Of course, this will leak memory if init video is done more than once.
// Sucks but such is life.
// -- David Hedbor
// delete SDL_Win;
// SDL_Win = 0;
_this->screen->pixels = NULL;
QT_GrabInput(_this, SDL_GRAB_OFF);
}
static int QT_IconifyWindow(_THIS)
{
SDL_Win->hide();
return true;
}
static SDL_GrabMode QT_GrabInput(_THIS, SDL_GrabMode mode)
{
if (mode == SDL_GRAB_OFF) {
QPEApplication::grabKeyboard();
qApp->processEvents();
QPEApplication::ungrabKeyboard();
} else {
QPEApplication::grabKeyboard();
}
qApp->processEvents();
return mode;
}
}; /* Extern C */
/* vi: set ts=4 sw=4 expandtab: */

37
src/video/qtopia/SDL_syswm.cc
View file

@ -1,37 +0,0 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include "SDL_QWin.h"
extern "C"
{
#include "SDL_syswm_c.h"
void QT_SetWMCaption(_THIS, const char *title, const char *icon)
{
SDL_Win->setCaption(title);
}
}; /* Extern C */
/* vi: set ts=4 sw=4 expandtab: */

28
src/video/qtopia/SDL_syswm_c.h
View file

@ -1,28 +0,0 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include "SDL_lowvideo.h"
/* Functions to be exported */
extern void QT_SetWMCaption(_THIS, const char *title, const char *icon);
/* vi: set ts=4 sw=4 expandtab: */