Put some modifications in the overall. Font to texture doesn't work though.

8 files changed, 429 insertions, 30 deletions

diff --git a/lib/base.cc b/lib/base.cc
index 7a6c854..acfc654 100644
--- a/lib/base.cc
+++ b/lib/base.cc
@@ -17,7 +17,7 @@ mogltk::base::base(int w, int h, int flags) throw(GeneralException) : surface(0)
         throw GeneralException(String("Couldn't initialise Video SubSystem: ") + SDL_GetError());
     }
 
-    if (!(surface = SDL_SetVideoMode(width, height, 0, flags))) {
+    if (!(surface = SDL_SetVideoMode(width, height, 0, flags | SDL_HWSURFACE))) {
         throw GeneralException(String("Couldn't set SDL mode: ") + SDL_GetError());
     }
 
@@ -94,3 +94,17 @@ void mogltk::base::changeviewport(int x, int y, unsigned int w, unsigned int h)
 
     SDL_SetClipRect(surface, &r);
 }
+
+void mogltk::base::ToggleFullscreen() {
+    int newflags = surface->flags;
+
+    if (surface->flags & SDL_FULLSCREEN)
+        newflags &= ~SDL_FULLSCREEN;
+    else
+        newflags |= SDL_FULLSCREEN;
+
+    texture::Taintall();
+
+    surface = SDL_SetVideoMode(surface->w, surface->h, surface->format->BitsPerPixel,
+        SDL_HWSURFACE | newflags);
+}
diff --git a/lib/engine.cc b/lib/engine.cc
index 6e899e2..3a2aaa0 100644
--- a/lib/engine.cc
+++ b/lib/engine.cc
@@ -20,9 +20,27 @@ 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");
 }
@@ -31,6 +49,31 @@ void mogltk::engine::keyevent::down(SDL_keysym) {
     printm(M_INFO, "Generic keyevent::down called\n");
 }
 
+mogltk::engine::mouseevent::mouseevent() {
+    new_handler = 0;
+    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"));
@@ -154,7 +197,7 @@ void mogltk::engine::pollevents() throw (GeneralException) {
     }
     
     while(true) {
-	if (hastoreturn)
+	if (hastoreturn || quitrequest)
 	    if (!SDL_PollEvent(NULL)) {
 		updatemouse();
 		return;
@@ -186,8 +229,6 @@ void mogltk::engine::pollevents() throw (GeneralException) {
 	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 (event.key.keysym.sym == 27)
-		hastoreturn = quitrequest = true;
 	    if (keyevent_h) {
 		if (event.key.state == SDL_PRESSED) {
 		    keyevent_h->down(event.key.keysym);
@@ -205,18 +246,24 @@ void mogltk::engine::pollevents() throw (GeneralException) {
 	    }
 	    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 == 4) {
+	    if (event.button.state == SDL_PRESSED) { 
+		if (event.button.button == SDL_BUTTON_WHEELUP) {
 		    mz--;
 		}
-		if (event.button.button == 5) {
+		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");
@@ -249,6 +296,10 @@ bool mogltk::engine::getcursorvisible() {
     return cursorvisible;
 }
 
+void mogltk::engine::quit() {
+    quitrequest = true;
+}
+
 bool mogltk::engine::quitrequested() {
     return quitrequest;
 }
@@ -269,6 +320,20 @@ 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;
 }
@@ -286,6 +351,17 @@ void mogltk::engine::unlockmouse() {
 }
 
 void mogltk::engine::setkeyevent(keyevent * k) {
-    printm(M_INFO, "Setting up a new keyevent\n");
     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;
+}
diff --git a/lib/font.cc b/lib/font.cc
index cd04177..4062c37 100644
--- a/lib/font.cc
+++ b/lib/font.cc
@@ -232,6 +232,44 @@ void mogltk::font::drawentry(Uint16 entry, int x, int y, ColorP c) {
 	SDL_UnlockSurface(mogltk::engine::base_o->getsurface());
 }
 
+void mogltk::font::drawtotex(texture * t, Uint16 entry, int x, int y, ColorP c) {
+    bool locked = false;
+    int trueentry, cx, cy, px, py;
+    SDL_Rect src, dst;
+    
+    if (SDL_MUSTLOCK(t->GetSurface())) {
+	locked = true;
+	SDL_LockSurface(t->GetSurface());
+    }
+
+    if (shadow) {
+	int os = shadow;
+	shadow = 0;
+	
+	drawtotex(t, entry, x + os, y + os, BLACK);
+	
+	shadow = os;
+    }
+
+    checknbind(entry / nbcT, c);    
+
+    y -= base;
+    
+    trueentry = entry % nbcT;
+    cx = trueentry % nbcU;
+    cy = trueentry / nbcU;
+    px = cx * maxX;
+    py = cy * maxY;
+    
+    src.x = px; src.y = py; src.w = maxX; src.h = maxY;
+    dst.x = x;  dst.y = y;  dst.w = maxX; dst.h = maxY;
+    
+    SDL_BlitSurface(fonttex[entry / nbcT]->GetSurface(), &src, t->GetSurface(), &dst);
+    
+    if (locked)
+	SDL_UnlockSurface(t->GetSurface());
+}
+
 void mogltk::font::putcursor(int x, int y) {
     cx = ox = x;
     cy = y;
@@ -242,6 +280,11 @@ void mogltk::font::putentry(Uint16 entry, ColorP c) {
     cx += sizes[entry] + wspace;
 }
 
+void mogltk::font::putentryontex(texture * t, Uint16 entry, ColorP c) {
+    drawtotex(t, entry, cx, cy, c);
+    cx += sizes[entry] + wspace;
+}
+
 void mogltk::font::drawchar(char ch, ColorP c) {
     Uint16 * p;
     int i;
@@ -254,6 +297,18 @@ void mogltk::font::drawchar(char ch, ColorP c) {
     }
 }
 
+void mogltk::font::drawcharontex(texture * t, char ch, ColorP c) {
+    Uint16 * p;
+    int i;
+
+    for (i = 0, p = corresp; i < nbentries; i++, p++) {
+	if (*(p++) == ch) {
+	    putentryontex(t, *p, c);
+	    return;
+	}
+    }
+}
+
 int mogltk::font::findchar(char ch) const {
     Uint16 * p;
     int i;
@@ -319,6 +374,256 @@ int mogltk::font::printf(const char * p, ...) {
     return r;
 }
 
+mogltk::rect mogltk::font::size(const ugly_string & m, va_list ap) {
+    char * p;
+    static char buffer[STRBUFSIZ + 1];
+    rect r;
+    int mw, w;
+
+    r.x = cx;
+    r.y = cy;
+    r.h = inter;
+    r.w = 0;
+    mw = 0;
+    w = 0;
+
+#ifdef HAVE_VSNPRINTF
+    vsnprintf(buffer, STRBUFSIZ, m.p, ap);
+#else
+    vsprintf(buffer, m.p, ap);
+#endif
+    
+    for (p = buffer; *p; p++) {
+	if (*p == '\n') {
+            if (*(p+1)) {
+                r.h += inter;
+                if (w > mw) {
+                    mw = w;
+                }
+                w = 0;
+            }
+	} else {
+	    w += sizes[findchar(*p)] + wspace;
+	}
+    }
+
+    if (w > mw) {
+        mw = w;
+    }
+
+    r.w = mw;
+    
+    return r;
+}
+
+mogltk::rect mogltk::font::size(const ugly_string & m, ...) {
+    va_list ap;
+    rect r;
+    
+    va_start(ap, m);
+    r = size(m, ap);
+    va_end(ap);
+    
+    return r;
+}
+
+mogltk::rect mogltk::font::size(const char * p, ...) {
+    ugly_string m;
+    va_list ap;
+    rect r;
+    
+    m.p = p;
+    
+    va_start(ap, p);
+    r = size(m, ap);
+    va_end(ap);
+    
+    return r;
+}
+
+mogltk::rect mogltk::font::printtotex(texture * t, const ugly_string & m, va_list ap) {
+    char * p;
+    static char buffer[STRBUFSIZ + 1];
+    rect r;
+    int mw, w;
+
+    r.x = cx;
+    r.y = cy;
+    r.h = inter;
+    r.w = 0;
+    mw = 0;
+    w = 0;
+
+#ifdef HAVE_VSNPRINTF
+    vsnprintf(buffer, STRBUFSIZ, m.p, ap);
+#else
+    vsprintf(buffer, m.p, ap);
+#endif
+    
+    for (p = buffer; *p; p++) {
+	if (*p == '\n') {
+            if (*(p+1)) {
+                r.h += inter;
+                if (w > mw) {
+                    mw = w;
+                }
+                w = 0;
+            }
+	} else {
+	    w += sizes[findchar(*p)] + wspace;
+	}
+    }
+
+    if (w > mw) {
+        mw = w;
+    }
+
+    r.w = mw;
+    
+    for (p = buffer; *p; p++) {
+	if (*p == '\n') {
+	    newline();
+	} else {
+	    drawcharontex(t, *p, textcolor);
+	}
+    }
+
+    return r;
+}
+
+mogltk::rect mogltk::font::printtotex(texture * t, const ugly_string & m, ...) {
+    va_list ap;
+    rect r;
+    
+    va_start(ap, m);
+    r = printtotex(t, m, ap);
+    va_end(ap);
+    
+    return r;
+}
+
+mogltk::rect mogltk::font::printtotex(texture * t, const char * p, ...) {
+    ugly_string m;
+    va_list ap;
+    rect r;
+    
+    m.p = p;
+    
+    va_start(ap, p);
+    r = printtotex(t, m, ap);
+    va_end(ap);
+    
+    return r;
+}
+
+inline unsigned int nextpower(unsigned int n) {
+    unsigned int i;
+
+    if (!n)
+        return n;
+
+    if (ISPOT(n))
+        return n;
+
+    for (i = 31; i >= 0; i--) {
+        if ((n >> i) & 1) {
+            return 1 << (i + 1);
+        }
+    }
+}
+
+mogltk::texture * mogltk::font::printtex(rect * _r, const ugly_string & m, va_list ap) {
+    rect r;
+    char * p;
+    static char buffer[STRBUFSIZ + 1];
+    int mw, w, pw, ph;
+    texture * t;
+    int ocx, ocy, oox;
+
+    ocx = cx;
+    ocy = cy;
+    oox = ox;
+
+    cx = ox = 0;
+    cy = base;
+
+    r.x = cx;
+    r.y = cy;
+    r.h = inter;
+    r.w = 0;
+    mw = 0;
+    w = 0;
+
+#ifdef HAVE_VSNPRINTF
+    vsnprintf(buffer, STRBUFSIZ, m.p, ap);
+#else
+    vsprintf(buffer, m.p, ap);
+#endif
+    
+    for (p = buffer; *p; p++) {
+	if (*p == '\n') {
+            if (*(p+1)) {
+                r.h += inter;
+                if (w > mw) {
+                    mw = w;
+                }
+                w = 0;
+            }
+	} else {
+	    w += sizes[findchar(*p)] + wspace;
+	}
+    }
+
+    if (w > mw) {
+        mw = w;
+    }
+
+    r.w = mw;
+
+    pw = nextpower(r.w);
+    ph = nextpower(r.h);
+
+    t = new texture(pw, ph);
+    
+    for (p = buffer; *p; p++) {
+	if (*p == '\n') {
+	    newline();
+	} else {
+	    drawcharontex(t, *p, textcolor);
+	}
+    }
+
+    if (_r)
+        *_r = r;
+
+    return t;
+}
+
+mogltk::texture * mogltk::font::printtex(rect * r, const ugly_string & m, ...) {
+    va_list ap;
+    texture * t;
+    
+    va_start(ap, m);
+    t = printtex(r, m, ap);
+    va_end(ap);
+    
+    return t;
+}
+
+mogltk::texture * mogltk::font::printtex(rect * r, const char * p, ...) {
+    ugly_string m;
+    va_list ap;
+    texture * t;
+    
+    m.p = p;
+    
+    va_start(ap, p);
+    t = printtex(r, m, ap);
+    va_end(ap);
+    
+    return t;
+}
+
 void mogltk::font::setcolor(ColorP c) {
     textcolor = c;
 }
@@ -336,7 +641,7 @@ int mogltk::font::singletextsize(const String & s) const {
     int r = 0;
     
     for (i = 0; i < s.strlen(); i++) {
-	r += sizes[findchar(s[i])];
+	r += sizes[findchar(s[i])] + wspace;
     }
     
     return r;
diff --git a/lib/glbase.cc b/lib/glbase.cc
index ebbfe08..3d89644 100644
--- a/lib/glbase.cc
+++ b/lib/glbase.cc
@@ -16,7 +16,7 @@ mogltk::glbase::glbase(int w, int h, int flags) throw (GeneralException) : moglt
         throw GeneralException(String("Couldn't initialise Video SubSystem: ") + SDL_GetError());
     }
 
-    if (!(surface = SDL_SetVideoMode(w, h, 0, flags | SDL_OPENGL))) {
+    if (!(surface = SDL_SetVideoMode(w, h, 0, flags | SDL_OPENGL | SDL_HWSURFACE))) {
         throw GeneralException(String("Couldn't set GL mode: ") + SDL_GetError());
     }
     
diff --git a/lib/glsprite.cc b/lib/glsprite.cc
index f60c3a2..44322b7 100644
--- a/lib/glsprite.cc
+++ b/lib/glsprite.cc
@@ -61,12 +61,12 @@ void mogltk::glSprite::drawrotate(int cx, int cy, double a, ColorP c) {
 
     glMatrixMode(GL_MODELVIEW);
     glPushMatrix();
-    glRotated(a, 0, 0, 1);
     glTranslated(cx, cy, 0);
-    
-    glMatrixMode(GL_TEXTURE);
     glRotated(a, 0, 0, 1);
     
+//    glMatrixMode(GL_TEXTURE);
+//    glRotated(a, 0, 0, 1);
+    
     c.Bind();
 
     Bind();
diff --git a/lib/sprite.cc b/lib/sprite.cc
index e62fb1b..13c09da 100644
--- a/lib/sprite.cc
+++ b/lib/sprite.cc
@@ -3,14 +3,14 @@
 #include "base.h"
 #include "sprite.h"
 
-#define TEXSIZE 256
+#define TEXSIZE 1024
 
 mogltk::Sprite::TexList * mogltk::Sprite::TexList::header = 0;
 
-mogltk::Sprite::Sprite(Handle * h, int asx, int asy) : sx(asx), sy(asy) {
+mogltk::Sprite::Sprite(Handle * h, int asx, int asy) throw (GeneralException) : sx(asx), sy(asy) {
     alloc();
     for (int y = 0; y < sy; y++) {
-	h->read(tlist->GetTex()->GetPixels() + TEXSIZE * y + posx, sx * 4);
+        h->read(tlist->GetTex()->GetPixels() + TEXSIZE * y + posx, sx * 4);
     }
 }
 
diff --git a/lib/texture.cc b/lib/texture.cc
index d7cfa7c..a8036bc 100644
--- a/lib/texture.cc
+++ b/lib/texture.cc
@@ -11,10 +11,8 @@
 
 #define DEBUG 1
 
-#ifdef TRACE_TEXTURES
 mogltk::texture * mogltk::texture::header = 0;
 mogltk::texture * mogltk::texture::footer = 0;
-#endif
 
 mogltk::texture * mogltk::texture::active = 0;
 
@@ -41,7 +39,6 @@ mogltk::texture::texture(int w, int h, bool plane) throw (GeneralException) : wi
     
     SDL_FillRect(surface, 0, 0);
     
-#ifdef TRACE_TEXTURES
     next = 0;
     prev = footer;
     footer = this;
@@ -51,7 +48,6 @@ mogltk::texture::texture(int w, int h, bool plane) throw (GeneralException) : wi
     if (prev) {
 	prev->next = this;
     }
-#endif
 }
 
 mogltk::texture::texture(Handle * h, bool plane) throw (GeneralException) :
@@ -107,7 +103,6 @@ mogltk::texture::texture(Handle * h, bool plane) throw (GeneralException) :
     
     SDL_FreeSurface(temp);
 
-#ifdef TRACE_TEXTURES
     next = 0;
     prev = footer;
     footer = this;
@@ -117,7 +112,6 @@ mogltk::texture::texture(Handle * h, bool plane) throw (GeneralException) :
     if (prev) {
 	prev->next = this;
     }
-#endif
 }
 
 mogltk::texture::~texture() {
@@ -129,7 +123,6 @@ mogltk::texture::~texture() {
 	glDeleteTextures(1, &tex);
     }
     
-#ifdef TRACE_TEXTURES
     if (prev) {
 	prev->next = next;
     }
@@ -145,7 +138,6 @@ mogltk::texture::~texture() {
     if (this == header) {
 	header = next;
     }
-#endif
 }
 
 Uint32 * mogltk::texture::GetPixels() {
@@ -215,7 +207,6 @@ void mogltk::texture::Bind(bool expand) {
     
     active = this;
     
-#ifdef TRACE_TEXTURES
     if (header == this)
 	return;
     
@@ -231,9 +222,10 @@ void mogltk::texture::Bind(bool expand) {
 	footer = prev;
     }
     
+    next = header;
+    prev = 0;
     header->prev = this;
     header = this;
-#endif
 }
 
 GLuint mogltk::texture::GetWidth() {
@@ -256,6 +248,17 @@ void mogltk::texture::Taint(void) {
     tainted = true;
 }
 
+void mogltk::texture::Taintall(void) {
+    if (header)
+        header->recTaint();
+}
+
+void mogltk::texture::recTaint(void) {
+    Taint();
+    if (next)
+        next->recTaint();
+}
+
 #ifdef WORDS_BIGENDIAN
 #define NTEX_SIGNATURE 0x4e544558
 #else
diff --git a/lib/widgets.cc b/lib/widgets.cc
index 1f540f2..91e5904 100644
--- a/lib/widgets.cc
+++ b/lib/widgets.cc
@@ -113,10 +113,11 @@ mogltk::shape * mogltk::widget::Shaper() {
 }
 
 void mogltk::widget::fulldraw() {
-    bool was2D;
+    bool was2D = true;
     
-    if (!(was2D = mogltk::engine::glbase_o->is2D()))
-	mogltk::engine::glbase_o->Enter2DMode();
+    if (mogltk::engine::glbase_o)
+        if (!(was2D = mogltk::engine::glbase_o->is2D()))
+	    mogltk::engine::glbase_o->Enter2DMode();
 
     texture::Unbind();
     mogltk::ColorP::Max = WHITE;
@@ -165,7 +166,7 @@ void mogltk::Root::draw() {
     if (dr)
 	dr->draw(this);
     else
-	Shaper()->box(GetAX(), GetAY(), GetAX2(), GetAY2());

+	Shaper()->box(GetAX(), GetAY(), GetAX2(), GetAY2());
 }
 
 void mogltk::Root::setdrawer(drawer * _dr) {