view src/video/bwindow/SDL_BWin.h @ 2349:0381047f2210 gsoc2008_iphone

The class SDL_uikitappdelegate acts as the UIApplicationDelegate for an iPhone SDL project. This class is reponsible for application control flow, including initial setup of working directory, forwarding command line arguments to the user's main function, and handling application termination.
author Holmes Futrell <hfutrell@umail.ucsb.edu>
date Thu, 17 Jul 2008 22:29:37 +0000
parents c121d94672cb
children 99210400e8b9
line wrap: on
line source

/*
    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
*/

#ifndef _SDL_BWin_h
#define _SDL_BWin_h

#include "SDL_config.h"

#include <stdio.h>
#include <AppKit.h>
#include <InterfaceKit.h>
#include <be/game/DirectWindow.h>
#if SDL_VIDEO_OPENGL
#include <be/opengl/GLView.h>
#endif
#include <support/UTF8.h>

#include "../../main/beos/SDL_BeApp.h"
#include "SDL_events.h"
#include "SDL_BView.h"

extern "C"
{
#include "../../events/SDL_events_c.h"
};

class SDL_BWin:public BDirectWindow
{
  public:
    SDL_BWin(BRect bounds):BDirectWindow(bounds, "Untitled",
                                         B_TITLED_WINDOW, 0)
    {
        InitKeyboard();
        last_buttons = 0;

        the_view = NULL;
#if SDL_VIDEO_OPENGL
        SDL_GLView = NULL;
#endif
        SDL_View = NULL;
        Unlock();
        shown = false;
        inhibit_resize = false;
    }

    virtual ~ SDL_BWin()
    {
        Lock();
        if (the_view) {
#if SDL_VIDEO_OPENGL
            if (the_view == SDL_GLView) {
                SDL_GLView->UnlockGL();
            }
#endif
            RemoveChild(the_view);
            the_view = NULL;
        }
        Unlock();
#if SDL_VIDEO_OPENGL
        if (SDL_GLView) {
            delete SDL_GLView;
        }
#endif
        if (SDL_View) {
            delete SDL_View;
        }
    }

    virtual void InitKeyboard(void)
    {
        for (uint 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;
    }

    /* Override the Show() method so we can tell when we've been shown */
    virtual void Show(void)
    {
        BWindow::Show();
        shown = true;
    }
    virtual bool Shown(void)
    {
        return (shown);
    }
    /* If called, the next resize event will not be forwarded to SDL. */
    virtual void InhibitResize(void)
    {
        inhibit_resize = true;
    }
    /* Handle resizing of the window */
    virtual void FrameResized(float width, float height)
    {
        if (inhibit_resize)
            inhibit_resize = false;
        else
            SDL_PrivateResize((int) width, (int) height);
    }
    virtual int CreateView(Uint32 flags, Uint32 gl_flags)
    {
        int retval;

        retval = 0;
        Lock();
        if (flags & SDL_INTERNALOPENGL) {
#if SDL_VIDEO_OPENGL
            if (SDL_GLView == NULL) {
                SDL_GLView = new BGLView(Bounds(), "SDL GLView",
                                         B_FOLLOW_ALL_SIDES,
                                         (B_WILL_DRAW | B_FRAME_EVENTS),
                                         gl_flags);
            }
            if (the_view != SDL_GLView) {
                if (the_view) {
                    RemoveChild(the_view);
                }
                AddChild(SDL_GLView);
                SDL_GLView->LockGL();
                the_view = SDL_GLView;
            }
#else
            SDL_SetError("OpenGL support not enabled");
            retval = -1;
#endif
        } else {
            if (SDL_View == NULL) {
                SDL_View = new SDL_BView(Bounds());
            }
            if (the_view != SDL_View) {
                if (the_view) {
#if SDL_VIDEO_OPENGL
                    if (the_view == SDL_GLView) {
                        SDL_GLView->UnlockGL();
                    }
#endif
                    RemoveChild(the_view);
                }
                AddChild(SDL_View);
                the_view = SDL_View;
            }
        }
        Unlock();
        return (retval);
    }
    virtual void SetBitmap(BBitmap * bitmap)
    {
        SDL_View->SetBitmap(bitmap);
    }
    virtual void SetXYOffset(int x, int y)
    {
#if SDL_VIDEO_OPENGL
        if (the_view == SDL_GLView) {
            return;
        }
#endif
        SDL_View->SetXYOffset(x, y);
    }
    virtual void GetXYOffset(int &x, int &y)
    {
#if SDL_VIDEO_OPENGL
        if (the_view == SDL_GLView) {
            x = 0;
            y = 0;
            return;
        }
#endif
        SDL_View->GetXYOffset(x, y);
    }
    virtual bool BeginDraw(void)
    {
        return (Lock());
    }
    virtual void DrawAsync(BRect updateRect)
    {
        SDL_View->DrawAsync(updateRect);
    }
    virtual void EndDraw(void)
    {
        SDL_View->Sync();
        Unlock();
    }
#if SDL_VIDEO_OPENGL
    virtual void SwapBuffers(void)
    {
        SDL_GLView->UnlockGL();
        SDL_GLView->LockGL();
        SDL_GLView->SwapBuffers();
    }
#endif
    virtual BView *View(void)
    {
        return (the_view);
    }

    /* Hook functions -- overridden */
    virtual void Minimize(bool minimize)
    {
        /* This is only called when mimimized, not when restored */
        //SDL_PrivateAppActive(minimize, SDL_APPACTIVE);
        BWindow::Minimize(minimize);
    }
    virtual void WindowActivated(bool active)
    {
        SDL_PrivateAppActive(active, SDL_APPINPUTFOCUS);
    }
    virtual bool QuitRequested(void)
    {
        if (SDL_BeAppActive > 0) {
            SDL_PrivateQuit();
            /* We don't ever actually close the window here because
               the application should respond to the quit request,
               or ignore it as desired.
             */
            return (false);
        }
        return (true);          /* Close the app window */
    }
    virtual void Quit()
    {
        if (!IsLocked())
            Lock();
        BDirectWindow::Quit();
    }

    virtual int16 Translate2Unicode(const char *buf)
    {
        int32 state, srclen, dstlen;
        unsigned char destbuf[2];
        Uint16 unicode = 0;

        if ((uchar) buf[0] > 127) {
            state = 0;
            srclen = SDL_strlen(buf);
            dstlen = sizeof(destbuf);
            convert_from_utf8(B_UNICODE_CONVERSION, buf, &srclen,
                              (char *) destbuf, &dstlen, &state);
            unicode = destbuf[0];
            unicode <<= 8;
            unicode |= destbuf[1];
        } else
            unicode = buf[0];

        /* For some reason function keys map to control characters */
# define CTRL(X)	((X)-'@')
        switch (unicode) {
        case CTRL('A'):
        case CTRL('B'):
        case CTRL('C'):
        case CTRL('D'):
        case CTRL('E'):
        case CTRL('K'):
        case CTRL('L'):
        case CTRL('P'):
            if (!(SDL_GetModState() & KMOD_CTRL))
                unicode = 0;
            break;
            /* Keyboard input maps newline to carriage return */
        case '\n':
            unicode = '\r';
            break;
        default:
            break;
        }

        return unicode;
    }

    virtual void DispatchMessage(BMessage * msg, BHandler * target)
    {
        switch (msg->what) {
        case B_MOUSE_MOVED:
            {
                BPoint where;
                int32 transit;
                if (msg->FindPoint("where", &where) == B_OK
                    && msg->FindInt32("be:transit", &transit) == B_OK) {
                    if (transit == B_EXITED_VIEW) {
                        if (SDL_GetAppState() & SDL_APPMOUSEFOCUS) {
                            SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
                            be_app->SetCursor(B_HAND_CURSOR);
                        }
                    } else {
                        int x, y;
                        if (!(SDL_GetAppState() & SDL_APPMOUSEFOCUS)) {
                            SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
                            SDL_SetCursor(NULL);
                        }
                        GetXYOffset(x, y);
                        x = (int) where.x - x;
                        y = (int) where.y - y;
                        SDL_PrivateMouseMotion(0, 0, x, y);
                    }
                }
                break;
            }

        case B_MOUSE_DOWN:
            {
                /*      it looks like mouse down is send only for first clicked
                   button, each next is not send while last one is holded */
                int32 buttons;
                int sdl_buttons = 0;
                if (msg->FindInt32("buttons", &buttons) == B_OK) {
                    /* Add any mouse button events */
                    if (buttons & B_PRIMARY_MOUSE_BUTTON) {
                        sdl_buttons |= SDL_BUTTON_LEFT;
                    }
                    if (buttons & B_SECONDARY_MOUSE_BUTTON) {
                        sdl_buttons |= SDL_BUTTON_RIGHT;
                    }
                    if (buttons & B_TERTIARY_MOUSE_BUTTON) {
                        sdl_buttons |= SDL_BUTTON_MIDDLE;
                    }
                    SDL_PrivateMouseButton(SDL_PRESSED, sdl_buttons, 0, 0);

                    last_buttons = buttons;
                }
                break;
            }

        case B_MOUSE_UP:
            {
                /*      mouse up doesn't give which button was released,
                   only state of buttons (after release, so it's always = 0),
                   which is not what we need ;]
                   So we need to store button in mouse down, and restore
                   in mouse up :(
                   mouse up is (similarly to mouse down) send only for
                   first button down (ie. it's no send if we click another button
                   without releasing previous one first) - but that's probably
                   because of how drivers are written?, not BeOS itself. */
                int32 buttons;
                int sdl_buttons = 0;
                if (msg->FindInt32("buttons", &buttons) == B_OK) {
                    /* Add any mouse button events */
                    if ((buttons ^ B_PRIMARY_MOUSE_BUTTON) & last_buttons) {
                        sdl_buttons |= SDL_BUTTON_LEFT;
                    }
                    if ((buttons ^ B_SECONDARY_MOUSE_BUTTON) & last_buttons) {
                        sdl_buttons |= SDL_BUTTON_RIGHT;
                    }
                    if ((buttons ^ B_TERTIARY_MOUSE_BUTTON) & last_buttons) {
                        sdl_buttons |= SDL_BUTTON_MIDDLE;
                    }
                    SDL_PrivateMouseButton(SDL_RELEASED, sdl_buttons, 0, 0);

                    last_buttons = buttons;
                }
                break;
            }

        case B_MOUSE_WHEEL_CHANGED:
            {
                float x, y;
                x = y = 0;
                if (msg->FindFloat("be:wheel_delta_x", &x) == B_OK
                    && msg->FindFloat("be:wheel_delta_y", &y) == B_OK) {
                    if (x < 0 || y < 0) {
                        SDL_PrivateMouseButton(SDL_PRESSED,
                                               SDL_BUTTON_WHEELDOWN, 0, 0);
                        SDL_PrivateMouseButton(SDL_RELEASED,
                                               SDL_BUTTON_WHEELDOWN, 0, 0);
                    } else if (x > 0 || y > 0) {
                        SDL_PrivateMouseButton(SDL_PRESSED,
                                               SDL_BUTTON_WHEELUP, 0, 0);
                        SDL_PrivateMouseButton(SDL_RELEASED,
                                               SDL_BUTTON_WHEELUP, 0, 0);
                    }
                }
                break;
            }

        case B_KEY_DOWN:
        case B_UNMAPPED_KEY_DOWN:      /* modifier keys are unmapped */
            {
                int32 key;
                int32 modifiers;
                int32 key_repeat;
                /* Workaround for SDL message queue being filled too fast because of BeOS own key-repeat mechanism */
                if (msg->FindInt32("be:key_repeat", &key_repeat) == B_OK
                    && key_repeat > 0)
                    break;

                if (msg->FindInt32("key", &key) == B_OK
                    && msg->FindInt32("modifiers", &modifiers) == B_OK) {
                    SDL_keysym keysym;
                    keysym.scancode = key;
                    if ((key > 0) && (key < 128)) {
                        keysym.sym = keymap[key];
                    } else {
                        keysym.sym = SDLK_UNKNOWN;
                    }
                    /*      FIX THIS?
                       it seems SDL_PrivateKeyboard() changes mod value
                       anyway, and doesn't care about what we setup here */
                    keysym.mod = KMOD_NONE;
                    keysym.unicode = 0;
                    if (SDL_TranslateUNICODE) {
                        const char *bytes;
                        if (msg->FindString("bytes", &bytes) == B_OK) {
                            /*      FIX THIS?
                               this cares only about first "letter",
                               so if someone maps some key to print
                               "BeOS rulez!" only "B" will be used. */
                            keysym.unicode = Translate2Unicode(bytes);
                        }
                    }
                    SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
                }
                break;
            }

        case B_KEY_UP:
        case B_UNMAPPED_KEY_UP:        /* modifier keys are unmapped */
            {
                int32 key;
                int32 modifiers;
                if (msg->FindInt32("key", &key) == B_OK
                    && msg->FindInt32("modifiers", &modifiers) == B_OK) {
                    SDL_keysym keysym;
                    keysym.scancode = key;
                    if ((key > 0) && (key < 128)) {
                        keysym.sym = keymap[key];
                    } else {
                        keysym.sym = SDLK_UNKNOWN;
                    }
                    keysym.mod = KMOD_NONE;     /* FIX THIS? */
                    keysym.unicode = 0;
                    if (SDL_TranslateUNICODE) {
                        const char *bytes;
                        if (msg->FindString("bytes", &bytes) == B_OK) {
                            keysym.unicode = Translate2Unicode(bytes);
                        }
                    }
                    SDL_PrivateKeyboard(SDL_RELEASED, &keysym);
                }
                break;
            }

        default:
            /* move it after switch{} so it's always handled
               that way we keep BeOS feautures like:
               - CTRL+Q to close window (and other shortcuts)
               - PrintScreen to make screenshot into /boot/home
               - etc.. */
            //BDirectWindow::DispatchMessage(msg, target);
            break;
        }
        BDirectWindow::DispatchMessage(msg, target);
    }

  private:
#if SDL_VIDEO_OPENGL
    BGLView * SDL_GLView;
#endif
    SDL_BView *SDL_View;
    BView *the_view;

    bool shown;
    bool inhibit_resize;

    int32 last_buttons;
    SDLKey keymap[128];
};

#endif /* _SDL_BWin_h */
/* vi: set ts=4 sw=4 expandtab: */