path: root/lib/engine.cc

/*
 *  mogltk
 *  Copyright (C) 1999-2004 Nicolas "Pixel" Noble
 *
 *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/* $Id: engine.cc,v 1.31 2006-10-28 16:50:46 pixel Exp $ */

#include <SDL.h>
#include <Input.h>
#include "engine.h"
#include "glfont.h"
#include "glsprite.h"

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "gettext.h"

bool mogltk::engine::inited = false, mogltk::engine::postsetuped = false;
bool mogltk::engine::appactive = false, mogltk::engine::cursorvisible = false, mogltk::engine::quitrequest = false;
int mogltk::engine::mx, mogltk::engine::my, mogltk::engine::mz = 0, mogltk::engine::mbuttons;
int mogltk::engine::frames, mogltk::engine::locked = 0;
double mogltk::engine::curfps = -1;
Uint32 mogltk::engine::curticks;
mogltk::Widget * mogltk::engine::root = 0;

mogltk::glbase * mogltk::engine::glbase_o = 0;
mogltk::base * mogltk::engine::base_o = 0;

mogltk::engine::keyevent * mogltk::engine::keyevent_h = 0;
mogltk::engine::mouseevent * mogltk::engine::mouseevent_h = 0;

#define UPDATERATE 1000

mogltk::engine::keyevent::keyevent() {
    new_handler = 0;
    if ((old_handler = getkeyevent()))
        old_handler->new_handler = this;
    setkeyevent(this);
}

mogltk::engine::keyevent::~keyevent() {
    if (new_handler)
        new_handler->old_handler = old_handler;
    if (old_handler)
        old_handler->new_handler = new_handler;

    if (getkeyevent() == this)
        setkeyevent(old_handler);
}

void mogltk::engine::keyevent::up(SDL_keysym) {
    printm(M_INFO, "Generic keyevent::up called\n");
}

void mogltk::engine::keyevent::down(SDL_keysym) {
    printm(M_INFO, "Generic keyevent::down called\n");
}

class keyhandler_t : public mogltk::engine::keyevent {
    virtual void down(SDL_keysym keysym) {
        if (keysym.sym == SDLK_ESCAPE)
            mogltk::engine::quit();
        else if ((keysym.sym == SDLK_RETURN) && (keysym.mod & KMOD_ALT))
            mogltk::engine::base_o->ToggleFullscreen();
        else if (old_handler)
            old_handler->down(keysym);
    }
    virtual void up(SDL_keysym keysym) {
        if (old_handler)
            old_handler->up(keysym);
    }
} basic_keyhandler;

mogltk::engine::mouseevent::mouseevent() {
    new_handler = 0;
    if ((old_handler = getmouseevent()))
        old_handler->new_handler = this;
    setmouseevent(this);
}

mogltk::engine::mouseevent::~mouseevent() {
    if (new_handler)
        new_handler->old_handler = old_handler;
    if (old_handler)
        old_handler->new_handler = new_handler;

    if (getmouseevent() == this)
        setmouseevent(old_handler);
}

void mogltk::engine::mouseevent::move(SDL_MouseMotionEvent) {
    printm(M_INFO, "Generic mouseevent::move called\n");
}

void mogltk::engine::mouseevent::action(SDL_MouseButtonEvent) {
    printm(M_INFO, "Generic mouseevent::action called\n");
}

int mogltk::engine::setup() throw(GeneralException) {
    if (inited) {
	printm(M_WARNING, FUNCNAME + _(" called twice, ignoring second call.\n"));
        return -1;
    }
    if (SDL_Init(0) < 0) {
	throw GeneralException(FUNCNAME + _(": Unable to start SDL base system"));
    }
    atexit(SDL_Quit);
    
    inited = true;
    
    return 0;
}

int mogltk::engine::postsetup() throw(GeneralException) {
    if (postsetuped) {
        printm(M_WARNING, FUNCNAME + _(" called twice, ignoring second call.\n"));
        return -1;
    }
    
    SDL_EnableUNICODE(1);
    curticks = SDL_GetTicks();
    
    postsetuped = true;

    if (glbase_o) {
	mogltk::SystemFont = new mogltk::glfont(&Input("font.bin"));
	mogltk::FixedFont = new mogltk::glfont(&Input("fixed-font.bin"));
        Sprite::Cursor = new mogltk::glSprite(&Input("cursor.rgba"), 25, 25);
    } else {
	mogltk::SystemFont = new mogltk::Font(&Input("font.bin"));
	mogltk::FixedFont = new mogltk::Font(&Input("fixed-font.bin"));
        Sprite::Cursor = new mogltk::Sprite(&Input("cursor.rgba"), 25, 25);
    }

    return 0;
}

int mogltk::engine::GetInited() {
    return inited;
}

class embedRWops : public Base {
  public:
      embedRWops(Handle *, bool);
      virtual ~embedRWops();
    int seek(int, int);
    int read(void *, int, int);
    int write(const void *, int, int);
    static int s_seek(SDL_RWops * context, int, int);
    static int s_read(SDL_RWops * context, void *, int, int);
    static int s_write(SDL_RWops * context, const void *, int, int);
    static int s_close(SDL_RWops * context);
  private:
    Handle * h;
    bool destroy_when_close;
};

embedRWops::embedRWops(Handle * ah, bool _destroy_when_close) : h(ah), destroy_when_close(_destroy_when_close) {}
embedRWops::~embedRWops() {
    if (destroy_when_close)
        delete h;
}

int embedRWops::seek(int offset, int whence) {
    return h->seek(offset, whence);
}

int embedRWops::read(void * ptr, int size, int num) {
    return h->read(ptr, size * num);
}

int embedRWops::write(const void * ptr, int size, int num) {
    return h->write(ptr, size * num);
}

int embedRWops::s_seek(SDL_RWops * context, int offset, int whence) {
    if (context->hidden.unknown.data1)
	return ((embedRWops *)(context->hidden.unknown.data1))->seek(offset, whence);
    return -1;
}

int embedRWops::s_read(SDL_RWops * context, void * ptr, int size, int num) {
    if (context->hidden.unknown.data1)
	return ((embedRWops *)(context->hidden.unknown.data1))->read(ptr, size, num);
    return -1;
}

int embedRWops::s_write(SDL_RWops * context, const void * ptr, int size, int num) {
    if (context->hidden.unknown.data1)
	return ((embedRWops *)(context->hidden.unknown.data1))->write(ptr, size, num);
    return -1;
}

int embedRWops::s_close(SDL_RWops * context) {
    if (context->hidden.unknown.data1) {
	delete ((embedRWops *)(context->hidden.unknown.data1));
	context->hidden.unknown.data1 = 0;
	return 0;
    }
    return -1;
}

SDL_RWops * mogltk::engine::RWFromHandle(Handle * h, bool destroy_when_close) throw (GeneralException) {
    SDL_RWops * r = 0;
    if (h) {
	if (!(r = SDL_AllocRW()))
	    throw GeneralException(_("Couldn't allocate memory for SDL_RWops"));
	r->hidden.unknown.data1 = (void *) new embedRWops(h, destroy_when_close);
	r->seek = embedRWops::s_seek;
	r->read = embedRWops::s_read;
	r->write = embedRWops::s_write;
	r->close = embedRWops::s_close;
    }
    return r;
}

void mogltk::engine::pollevents() throw (GeneralException) {
    SDL_Event event;
    bool hastoreturn = appactive;
    
    if (!postsetuped)
	postsetup();
    
    if (appactive) {
	Uint32 ticks = SDL_GetTicks();
	frames++;
	if (ticks - curticks > UPDATERATE) {
	    curfps = (double) frames * 1000 / (ticks - curticks);
	    frames = 0;
	    curticks = ticks;
	}
    } else {
	curfps = -1;
    }
    
    while(true) {
	if (hastoreturn || quitrequest)
	    if (!SDL_PollEvent(NULL)) {
		updatemouse();
		return;
	    }
	if (!SDL_WaitEvent(&event)) {
	    throw GeneralException("Error polling for SDL Event");
	}
	switch(event.type) {
	case SDL_ACTIVEEVENT:
	    switch (event.active.state) {
	    case SDL_APPMOUSEFOCUS:
		printm(M_INFO, String("Application ") + (event.active.gain ? "gained" : "loosed") + " mouse focus\n");
		if (cursorvisible)
		    hastoreturn = true;
		break;
	    case SDL_APPINPUTFOCUS:
		printm(M_INFO, String("Application ") + (event.active.gain ? "gained" : "loosed") + " input focus\n");
		if (cursorvisible)
		    hastoreturn = true;
		break;
	    case SDL_APPACTIVE:
		printm(M_INFO, String("Application was ") + (event.active.gain ? "restored" : "iconified"));
		if (cursorvisible)
		    hastoreturn = true;
		break;		
	    }
	    break;
	case SDL_KEYDOWN:
	case SDL_KEYUP:
	    printm(M_INFO, String("Key ") + event.key.keysym.scancode + " on keyboard " + event.key.which + (event.key.state == SDL_PRESSED ? " pressed" : " released") + "\n");
	    printm(M_INFO, "SDL keysym: %i - Unicode: %04x = `%c`- modifiers: %04x\n", event.key.keysym.sym, event.key.keysym.unicode, event.key.keysym.unicode, event.key.keysym.mod);
	    if (keyevent_h) {
		if (event.key.state == SDL_PRESSED) {
		    keyevent_h->down(event.key.keysym);
		} else {
		    keyevent_h->up(event.key.keysym);
		}
	    }
	    break;
	case SDL_MOUSEMOTION:
            if ((event.motion.x == mx) && (event.motion.y == my))
                break;
	    printm(M_INFO, "Mouse slept over the screen - (%i, %i)\n", event.motion.x, event.motion.y);
	    if (locked) {
    	        SDL_WarpMouse(mx, my);
	    }
	    if (cursorvisible)
		hastoreturn = true;
            if (mouseevent_h) {
                mouseevent_h->move(event.motion);
            }
	    break;
	case SDL_MOUSEBUTTONDOWN:
	case SDL_MOUSEBUTTONUP:
	    printm(M_INFO, String().set("Mouse button %02x ", event.button.button) + String((event.button.state == SDL_PRESSED ? "pressed" : "released")) + " at (" + event.button.x + ", " + event.button.y + ")\n");
	    if (event.button.state == SDL_PRESSED) { 
		if (event.button.button == SDL_BUTTON_WHEELUP) {
		    mz--;
		}
		if (event.button.button == SDL_BUTTON_WHEELDOWN) {
		    mz++;
		}
	    }
            if (mouseevent_h) {
                mouseevent_h->action(event.button);
            }
	    break;
	case SDL_QUIT:
	    printm(M_INFO, "Quit requested\n");
	    hastoreturn = quitrequest = true;
	    break;
	case SDL_VIDEOEXPOSE:
	    printm(M_INFO, "Needs to redraw\n");
	    hastoreturn = true;
	    break;
	default:
	    printm(M_INFO, "Unknow event: %i\n", event.type);
	    break;
	}
    }
}

void mogltk::engine::setappactive(bool p) {
    appactive = p;
}

bool mogltk::engine::getappactive() {
    return appactive;
}

void mogltk::engine::setcursorvisible(bool p) {
    cursorvisible = p;
}

bool mogltk::engine::getcursorvisible() {
    return cursorvisible;
}

void mogltk::engine::quit() {
    quitrequest = true;
}

bool mogltk::engine::quitrequested() {
    return quitrequest;
}

void mogltk::engine::updatemouse() {
    mbuttons = SDL_GetMouseState(&mx, &my);
}

int mogltk::engine::mouseX() {
    return mx;
}

int mogltk::engine::mouseY() {
    return my;
}

int mogltk::engine::mouseZ() {
    return mz;
}

void mogltk::engine::setmouseX(int _mx) {
    mx = _mx;
    SDL_WarpMouse(mx, my);
}

void mogltk::engine::setmouseY(int _my) {
    my = _my;
    SDL_WarpMouse(mx, my);
}

void mogltk::engine::setmouseZ(int _mz) {
    mz = _mz;
}

int mogltk::engine::mousebuttons() {
    return mbuttons;
}

double mogltk::engine::FPS() {
    return curfps;
}

void mogltk::engine::lockmouse() {
    locked = 1;
}

void mogltk::engine::unlockmouse() {
    locked = 0;
}

void mogltk::engine::setkeyevent(keyevent * k) {
    keyevent_h = k;
}

void mogltk::engine::setmouseevent(mouseevent * m) {
    mouseevent_h = m;
}

mogltk::engine::keyevent * mogltk::engine::getkeyevent() {
    return keyevent_h;
}

mogltk::engine::mouseevent * mogltk::engine::getmouseevent() {
    return mouseevent_h;
}