GLICT/container.cpp

Go to the documentation of this file.

/*
        GLICT - Graphics Library Interface Creation Toolkit
        Copyright (C) 2006-2007 OBJECT Networks

        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
        Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/



#include <stdlib.h>
#ifdef WIN32
    #include <windows.h>
#endif
#include <GL/gl.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
//#include <time.h>
#include "container.h"
#include "types.h"
#include "globals.h"


#include <stdlib.h>

#ifndef min
#define min(a,b) (a<b ? a : b)
#define max(a,b) (a>b ? a : b)
#endif

glictContainer::glictContainer() {
        this->height = 32;
        this->width = 32;
        this->x = 0;
        this->y = 0;
        strcpy(this->objtype,"Container");

        this->parent = NULL;

        this->OnClick = NULL;
        this->OnPaint = NULL;
        this->OnMouseDown = NULL;
        this->OnMouseUp = NULL;

        this->guid = rand();

        this->ResetTransformations();

        this->SetCaption("");

        this->focusable = false;

        this->SetVisible(true);
        this->SetEnabled(true);

        this->containeroffsetx = 0;
        this->containeroffsety = 0;

        this->SetRect(this->x, this->y, this->x + this->width, this->y + this->height);
        this->SetClip(this->left, this->top, this->right, this->bottom);

        virtualsize.x = 0;
        virtualsize.y = 0;

        virtualpos.x = 0;
        virtualpos.y = 0;

        fontname = "system";
        fontsize = 10;

        previous = NULL;
        next = NULL;

        //printf("Container created.\n");

}

glictContainer::~glictContainer() {
        if (this == glictGlobals.topFocused) {
                glictGlobals.topFocused = NULL;
        }
}

void glictContainer::ResetTransformations() {
        int i=0;
        ModelviewMatrix[i++] = 1; ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 0;
        ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 1; ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 0;
        ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 1; ModelviewMatrix[i++] = 0;
        ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 1;
}
void glictContainer::AddObject(glictContainer* obj) {
        obj->parent = this;
        obj->ResetTransformations();
        this->objects.insert(this->objects.end(), obj);

        //this->SetPos(x,y); // just force the clipping code to execute
        this->RecursiveBoundaryFix();
    //if (parent) parent->SetPos(parent->x, parent->y);
}
void glictContainer::RemoveObject(glictContainer* object) {
        /*vector<glictContainer*>::iterator it;

        for (it=objects.begin(); it!=objects.end(); it++) {
                if ((*it)==object) {
                        //delete *it;
                        objects.erase(it);
                        return;
                }
        }*/

        delayedremove.insert(delayedremove.end(), object);
}

void glictContainer::DelayedRemove() {
        if (delayedremove.size()) {
                for (vector<glictContainer*>::iterator it = delayedremove.begin(); delayedremove.size(); ) {
                        for (std::vector<glictContainer*>::iterator it2 = objects.begin(); it2 != objects.end(); ) {
                                if ((*it) == (*it2)) {
                                        objects.erase(it2);
                                        it2 = objects.begin();
                                }
                                else {
                                        it2++;
                                }
                        }
                        delayedremove.erase(it);

                }
        }
}

void glictContainer::SetHeight(float h) {
        this->height = h;
    this->RecursiveBoundaryFix();
}

void glictContainer::SetWidth(float w) {
        this->width = w;
        this->RecursiveBoundaryFix();
}

void glictContainer::SetPos(float x, float y) {

        //printf("Postavka pozicije %s (%s) %s na %d %d\n", objtype, (parent ? parent->objtype : "NULL"), this->caption.c_str(), x, y);
        //printf("This->x %d This->y %d\n", this->x, this->y);

    this->FixContainerOffsets(); // in case the skin got just turned on, we'll have to fix the container offsets

    if (!parent) {
            this->SetRect(x, y, x+width, y+height);

        this->x = x;
        this->y = y;
    } else {
        this->SetRect(
            parent->left + x + parent->containeroffsetx - parent->virtualpos.x,
            parent->top + y + parent->containeroffsety  - parent->virtualpos.y,
            parent->left + x + width+ parent->containeroffsetx -  parent->virtualpos.x + containeroffsetx*2,
            parent->top + y + height+ parent->containeroffsety -  parent->virtualpos.y + containeroffsety*2 // FIXME containeroffsety*2 should be replaced by containeroffsety + bottomheight
        );


        this->x = x;
        this->y = y;
    }



        glictSize size;
        for (std::vector<glictContainer*>::iterator it=objects.begin(); it!=objects.end(); it++) {

                (*it)->GetPos(&x, &y);
#if 1
                (*it)->SetPos(x,y);
#else
// FIXME: this way, we have less ops but it's not recursive properly and does not fix the boundaries as it ought to.
//  check if we can still keep this way of doing things instead of sicko "setpos" recursively
                (*it)->GetSize(&size);

                (*it)->SetRect(this->left + x, this->top, this->left + x + size.w, this->top + y + size.h );
#endif
        }
}

void glictContainer::SetPos(glictPos pos) {
        this->SetPos(pos.x,pos.y);
}

void glictContainer::GetPos(float* x, float* y) {
        *x = this->x;
        *y = this->y;
}

void glictContainer::GetPos(glictPos* pos) {
        pos->x = this->x;
        pos->y = this->y;
}
/* TODO (Khaos#2#): GetSize(w,h); */

void glictContainer::GetSize(glictSize* size) {
        size->w = this->width;
        size->h = this->height;
}

float glictContainer::GetWidth() {
    return width;
}

float glictContainer::GetHeight() {
    return height;
}

void glictContainer::SetRect(float left, float top, float right, float bottom) {
        //printf("%s s parentom %s postaje %d %d %d %d\n", this->objtype, (parent ? parent->objtype : "NULL"), left, right, top, bottom);
        this->left = left;
        this->right = right;
        this->top = top;
        this->bottom = bottom;


    //printf("Sada, %s s parentom %s sebe postavlja na clip %d %d %d %d\n", this->objtype, (parent ? parent->objtype : "NULL"), left, right, top, bottom);
    this->SetClip(
        max(left, (parent ? parent->clipleft : 0)),
        max(top, (parent ? parent->cliptop:0)),
        min(right, (parent ? parent->clipright: right)),
        min(bottom, (parent ? parent->clipbottom:bottom)) );

}

void glictContainer::SetClip(float left, float top, float right, float bottom) {

        this->clipleft = left;
        this->clipright = right ;
        this->cliptop = top ;
        this->clipbottom = bottom ;

        //printf("%s s parentom %s clippa kao %d %d %d %d\n", this->objtype, (parent ? parent->objtype : "NULL"), clipleft, clipright, cliptop, clipbottom);

/*      glictSize size;
        int x, y;
        if (objects.size()) for (vector<glictContainer*>::iterator it=objects.begin(); it!=objects.end(); it++) {
                (*it)->GetPos(&x, &y);
                (*it)->GetSize(&size);


                (*it)->SetRect(this->left + x, this->top + y, this->left + x + size.w, this->top + y + size.h);
                (*it)->SetClip(max(this->left + (*it)->x, this->clipleft), max(this->top + (*it)->y, this->cliptop), min(this->left + (*it)->x + size.w, this->clipright), min(this->top + (*it)->y + size.h, this->clipbottom));
        }
*/

}

void glictContainer::SetScissor() {
        //printf("SCISSOR SET\n");
#ifdef NO_GL
        return;
#else
        if (glictGlobals.clippingMode==GLICT_SCISSORTEST) {
                //printf("Scissor testing %s (%s), %d %d %d %d\n", this->objtype, (this->parent ? this->parent->objtype : "NULL"), clipleft, clipright, cliptop, clipbottom);
                //glMatrixMode(GL_MODELVIEW);
                //glPushMatrix();
                //glLoadIdentity();
                glScissor(
                        (int)this->clipleft,
                        (int)glictGlobals.h - (int)this->clipbottom,
                        (int)this->clipright - (int)this->clipleft,
                        (int)this->clipbottom - (int)this->cliptop
                );
                //glPopMatrix();

        } else
        if (glictGlobals.clippingMode==GLICT_STENCILTEST) {
                //glLoadName(this->guid);
                //printf("Stencil testing %s (%s); %d %d %d %d\n", this->objtype, (this->parent ? this->parent->objtype : "NULL"), clipleft, clipright, cliptop, clipbottom);
                glClear(GL_STENCIL_BUFFER_BIT);
                //glDisable(GL_SCISSOR_TEST);
                //glEnable(GL_STENCIL_TEST); // was Disable
                glStencilFunc(GL_ALWAYS, 1, 1);
                glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
                glColorMask(0,0,0,0);
                glDepthMask(0);

                //glColor3b(rand(), rand(), rand());
                glMatrixMode(GL_MODELVIEW);
                glPushMatrix();
                        //glLoadIdentity();
                        glLoadMatrixf(ModelviewMatrix);
                        glictGlobals.PaintRect(this->clipleft, this->clipright, this->cliptop, this->clipbottom);
                glPopMatrix();

                //glEnable(GL_STENCIL_TEST);
                glColorMask(1,1,1,1);
                glDepthMask(1);

                glStencilFunc(GL_EQUAL, 1, 1);
                glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);


        }// else printf("CLIP TEST IS OFF!!\n");
#endif
}

void glictContainer::Paint() {
        if (!GetVisible()) return;
        this->SetScissor();

        this->CPaint();

}

void glictContainer::CPaint() {

        //printf("Rendering %s (child of %s)\n", objtype, parent ? parent->objtype : "NULL");

        DelayedRemove();

#if 0
// below is debug code ...
        glMatrixMode(GL_MODELVIEW);

        glPushMatrix();
        glLoadIdentity();


        if (glictGlobals.clippingMode==GLICT_SCISSORTEST) glDisable(GL_SCISSOR_TEST);
        if (glictGlobals.clippingMode==GLICT_STENCILTEST) glDisable(GL_STENCIL_TEST);


    glBegin(GL_LINES);
                glColor3f(1.0,0.0,0.0);
                glVertex2f(this->clipleft,this->clipbottom);
                glVertex2f(this->clipleft,this->cliptop);

                glColor3f(0.0,1.0,0.0);
                glVertex2f(this->clipright,this->clipbottom);
                glVertex2f(this->clipleft,this->clipbottom);


                glColor3f(0.0,0.0,1.0);
                glVertex2f(this->clipright,this->cliptop);
                glVertex2f(this->clipright,this->clipbottom);


                glColor3f(1.0,1.0,0.0);
                glVertex2f(this->clipleft,this->cliptop);
                glVertex2f(this->clipright,this->cliptop);

        glEnd();

        if (glictGlobals.clippingMode==GLICT_SCISSORTEST) glEnable(GL_SCISSOR_TEST);
        if (glictGlobals.clippingMode==GLICT_STENCILTEST) glEnable(GL_STENCIL_TEST);
        glPopMatrix();
#endif

        if (objects.size()) {

        glictGlobals.Translatef(this->x + containeroffsetx - virtualpos.x, this->y + containeroffsety - virtualpos.y,0.0);

        std::vector<glictContainer*>::iterator it;
        for (it=objects.begin(); it!=objects.end(); it++) {

                if (!glictGlobals.drawPartialOut) {
                                if ((*it)->GetX()+(*it)->GetWidth() > virtualpos.x + GetWidth())
                                        continue;
                        if ((*it)->GetY()+(*it)->GetHeight() > virtualpos.y + GetHeight())
                                        continue;
                                if ((*it)->GetX() < virtualpos.x )
                                        continue;
                                if ((*it)->GetY() < virtualpos.y )
                                        continue;
                }

            (*it)->SetScissor();
            (*it)->Paint();
        }
        glictGlobals.Translatef(-this->x - containeroffsetx + virtualpos.x, -this->y - containeroffsety + virtualpos.y,0.0);

        }
}

bool glictContainer::DefaultCastEvent(glictEvents evt, void* wparam, long lparam, void* returnvalue) {
        //printf("Default event of type %s passing through %s (%s) with %d children\n", EvtTypeDescriptor(evt), objtype, parent ? parent->objtype : "NULL", this->objects.size());
        switch (evt) {
                case GLICT_KEYPRESS:
                        // as default behaviour is that widget doesnt know what to do with
                        // a key, it'll pass exec to the top focused item, whatever it
                        // might be
                        if (glictGlobals.topFocused)
                                if (this!=glictGlobals.topFocused)
                                        return glictGlobals.topFocused->CastEvent(evt, wparam, lparam, returnvalue);
                        // if it cant find top focused item, or that it is actually the
                        // focused item, then it will report that it
                        // doesnt know how to proc the event
                        return false;
                case GLICT_KEYDOWN:

                        return false;
                case GLICT_KEYUP:

                        return false;

                case GLICT_MOUSEUP:
                case GLICT_MOUSEDOWN:
                case GLICT_MOUSECLICK:
                        {
                        std::vector<glictContainer*>::reverse_iterator it;
                        //vector<glictContainer*>::iterator it;


                        if  (((glictPos*)wparam)->x > this->clipleft &&
                 ((glictPos*)wparam)->x < this->clipright &&
                 ((glictPos*)wparam)->y > this->cliptop &&
                 ((glictPos*)wparam)->y < this->clipbottom) {
                                        if (objects.size()) {
                                                for (it=objects.rbegin(); it != objects.rend(); it++) {
                                                //for (it=objects.begin(); it!=objects.end(); it++) {
                                                        if (it != objects.rend() && *it ) {

                                                                //printf("Testing %s (%s)\n", (*it)->objtype, this->objtype );


                                                                if ((*it)->CastEvent(evt, wparam, lparam, returnvalue)) {
                                                                        //printf("%s (%s) returned true\n", (*it)->objtype, this->objtype );
                                                                        return true;
                                                                }


                                                        }
                                                }
                                        }

                        }


                        //printf("Passing on to specific mouseevent processing in %s (%s).\n", objtype, parent ? parent->objtype : "NULL");
                        if (evt == GLICT_MOUSEDOWN) {
                                //printf("Mouse down\n");
                                glictGlobals.lastMousePos.x = ((glictPos*)wparam)->x ; // remembers x and y when pressing the mouse down
                                glictGlobals.lastMousePos.y = ((glictPos*)wparam)->y ;
                                if (focusable) {
                                        if (((glictPos*)wparam)->x > this->clipleft &&
                                         ((glictPos*)wparam)->x < this->clipright &&
                                         ((glictPos*)wparam)->y > this->cliptop &&
                                         ((glictPos*)wparam)->y < this->clipbottom ) {


                                                if (this->OnMouseDown) {

                            glictPos relpos;
                            relpos.x = ((glictPos*)wparam)->x - this->left - this->containeroffsetx + this->virtualpos.x;
                            relpos.y = ((glictPos*)wparam)->y - this->top - this->containeroffsety + this->virtualpos.y;
                            this->OnMouseDown(&relpos, this);
                        }

                                                this->Focus(NULL);
                                                return true;
                                         }
                                }
                        } else if (evt == GLICT_MOUSEUP) {
                                //printf("Mouse up on %s\n", objtype);


                                if (fabs (((glictPos*)wparam)->x - glictGlobals.lastMousePos.x) < 3 && // upon release verifies the location of mouse, and if nearby then it's a click - cast a click event
                                        fabs (((glictPos*)wparam)->y - glictGlobals.lastMousePos.y) < 3 ) { // if up to 2 pixels diff
                                        //printf("Considering it a click\n");
                                        //if (!parent) {
                                                //printf("Casting click event.\n");

                                                return this->CastEvent(GLICT_MOUSECLICK, wparam, lparam, returnvalue);
                                        //} else {
                                                //Not toplevel! Has a parent. Thus ignoring a click, letting toplevel parse properly.
                                        //}

                                } else {
                                        //Considering it dragging. Ignoring it!
                                }

                if (((glictPos*)wparam)->x > this->clipleft &&
                 ((glictPos*)wparam)->x < this->clipright &&
                 ((glictPos*)wparam)->y > this->cliptop &&
                 ((glictPos*)wparam)->y < this->clipbottom ) {

                    if (this->OnMouseUp) {
                        glictPos relpos;
                        relpos.x = ((glictPos*)wparam)->x - this->left - this->containeroffsetx + this->virtualpos.x;
                        relpos.y = ((glictPos*)wparam)->y - this->top - this->containeroffsety + this->virtualpos.y;
                        this->OnMouseUp(&relpos, this);
                    }
                }



                        } else { // not mousedown , not mouseup? mouseclick!


                                if (((glictPos*)wparam)->x > this->clipleft &&
                                        ((glictPos*)wparam)->x < this->clipright &&
                                        ((glictPos*)wparam)->y > this->cliptop &&
                                        ((glictPos*)wparam)->y < this->clipbottom ) {
                                        if (this->OnClick) {
                                                //printf("Click on %s.\n", objtype);
                                                glictPos relpos;
                                                relpos.x = ((glictPos*)wparam)->x - this->left - this->containeroffsetx + this->virtualpos.x;
                                                relpos.y = ((glictPos*)wparam)->y - this->top - this->containeroffsety + this->virtualpos.y;
                                                this->OnClick(&relpos, this);
                                                return true;
                                        }
                                        // if it happened within our boundaries, let it be as if we proc'ed it!
                                        // of course, only if we're not a container

                                        if (strcmp(objtype, "Container")) {// FIXME this is ugly lowperformance check, we should make it a bool or sth
                        //printf("Announcing click in %s\n", objtype);
                                            return true;
                                        }
                                }
                                // it didnt? then lets ignore it

                                return false;

                        }
                        return false; // came here? defaultcastevent caught nothing
                        }


                default:
                        printf("Unhandled event\n");
                        return false; // unprocessed, unknown event
        }

        // should never come here, but just in case:
        return false;
}

bool glictContainer::CastEvent(glictEvents evt, void* wparam, long lparam) {
   return this->CastEvent(evt, wparam, lparam, NULL);
}

bool glictContainer::CastEvent(glictEvents evt, void* wparam, long lparam, void* returnvalue) {
        if (!GetVisible() || !GetEnabled()) 
                return false;
        //printf("Event of type %s passing through %s (%s)\n", EvtTypeDescriptor(evt), objtype, parent ? parent->objtype : "NULL");
        switch (evt) {
                default:
                        return DefaultCastEvent(evt, wparam, lparam, returnvalue); // use default processing for all events
                case GLICT_MOUSECLICK:
                        return DefaultCastEvent(evt, wparam, lparam, returnvalue); // we never catch a mouse click in glictContainer... but some child might do so
                        break;
        }
}

void glictContainer::SetOnClick(void(*f)(glictPos* relmousepos, glictContainer* callerclass)) {
        this->OnClick = f;
}

void glictContainer::SetOnMouseDown(void(*f)(glictPos* relmousepos, glictContainer* callerclass)) {
        this->OnMouseDown = f;
}
void glictContainer::SetOnMouseUp(void(*f)(glictPos* relmousepos, glictContainer* callerclass)) {
        this->OnMouseUp = f;
}

void glictContainer::SetOnPaint(void(*f)(glictRect* real, glictRect* clipped, glictContainer* callerclass)) {
        this->OnPaint = f;
}

void glictContainer::RememberTransformations() {

        std::vector<glictContainer*>::iterator it;
#ifdef NO_GL
        int i=0;
        ModelviewMatrix[i++] = 1; ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 0;
        ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 1; ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 0;
        ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 1; ModelviewMatrix[i++] = 0;
        ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 0; ModelviewMatrix[i++] = 1;
#else
        glGetFloatv(GL_MODELVIEW_MATRIX, ModelviewMatrix);
#endif
        //printf("Remembering %s's modelview matrix (child of %s)\n", objtype, parent ? parent->objtype : "NULL");

        for (it=objects.begin(); it!=objects.end(); it++) {
                (*it)->RememberTransformations();
        }
}

void glictContainer::ReportDebug() {

        printf("--%s--\n", objtype);
        printf("Height: %d\n", height);
        printf("Width: %d\n", width);
        printf("Pos: %d %d\n", x, y);
        printf("Rect TBLR: %d %d %d %d\n", top, bottom, left, right);
        printf("Clip TBLR: %d %d %d %d\n", cliptop, clipbottom, clipleft, clipright);
        printf("GUID: %d\n", guid);
        std::vector<glictContainer*>::iterator it;
        for (it=objects.begin(); it!=objects.end(); it++) {
                (*it)->ReportDebug();
        }
}

void glictContainer::TransformScreenCoords(glictPos *pos) {


        int i,j,k;

        /*printf("original\n");
        for (i=0;i<4;i++) {
                for (j=0;j<4;j++)
                        printf("%.02f ", ModelviewMatrix[i*4 + j]);
                printf("\n");
        }
        //system("pause");
*/

/*

        ModelviewMatrix[0] = 1;
        ModelviewMatrix[1] = 2;
        ModelviewMatrix[2] = 3;
        ModelviewMatrix[3] = 4;
        ModelviewMatrix[4] = 5;
        ModelviewMatrix[5] = 6;
        ModelviewMatrix[6] = 7;
        ModelviewMatrix[7] = 8;
        ModelviewMatrix[8] = 9;
        ModelviewMatrix[9] = 10;
        ModelviewMatrix[10] = 11;
        ModelviewMatrix[11] = 12;
        ModelviewMatrix[12] = 13;
        ModelviewMatrix[13] = 14;
        ModelviewMatrix[14] = 15;
        ModelviewMatrix[15] = 16;
*/
        // copy matrix for inversion; copy matrix in left part, and fill rest with identity matrix
        double m[32];
        m[0] = this->ModelviewMatrix[0];
        m[1] = this->ModelviewMatrix[1];
        m[2] = this->ModelviewMatrix[2];
        m[3] = this->ModelviewMatrix[3];
        m[4] = 1;
        m[5] = 0;
        m[6] = 0;
        m[7] = 0;

        m[8] = this->ModelviewMatrix[4];
        m[9] = this->ModelviewMatrix[5];
        m[10] = this->ModelviewMatrix[6];
        m[11] = this->ModelviewMatrix[7];
        m[12] = 0;
        m[13] = 1;
        m[14] = 0;
        m[15] = 0;

        m[16] = this->ModelviewMatrix[8];
        m[17] = this->ModelviewMatrix[9];
        m[18] = this->ModelviewMatrix[10];
        m[19] = this->ModelviewMatrix[11];
        m[20] = 0;
        m[21] = 0;
        m[22] = 1;
        m[23] = 0;

        m[24] = this->ModelviewMatrix[12];
        m[25] = this->ModelviewMatrix[13];
        m[26] = this->ModelviewMatrix[14];
        m[27] = this->ModelviewMatrix[15];
        m[28] = 0;
        m[29] = 0;
        m[30] = 0;
        m[31] = 1;



        int ti,tj;

        // invert matrix
        float tmprowel, tmprowel2; // temp row's element
        for (i=0;i<4;i++) { // go through each row
                for (j=0;j<8;j++) {
                        m[i*8 + j] /= m[i * 8 + i]; // divide the row by [row][row], that's where we want a 1
                }

                // go through all other rows except the one we're currently in
                for (j=0;j<4;j++) if (j!=i) {
                        tmprowel2 = m[j*8+i];
                        for (k=0;k<8;k++) {
                                // multiply the row's elements by [row][row2]
                                tmprowel = m[i*8 + k] * tmprowel2 * -1;
                                // sum resulting row with row2
                                m[j*8 + k] += tmprowel;
                        }
                }
        }


        // right part is the resulting matrix
        double result[16];
        result[0] = m[4];
        result[1] = m[5];
        result[2] = m[6];
        result[3] = m[7];
        result[4] = m[12];
        result[5] = m[13];
        result[6] = m[14];
        result[7] = m[15];
        result[8] = m[20];
        result[9] = m[21];
        result[10] = m[22];
        result[11] = m[23];
        result[12] = m[28];
        result[13] = m[29];
        result[14] = m[30];
        result[15] = m[31];





        /*printf("inverse\n");
        for (i=0;i<4;i++) {
                for (j=0;j<4;j++)
                        printf("%.02f ", result[i*4 + j]);
                printf("\n");
        }
        //system("pause");
*/


        // multiply matrix by coordinates
        pos->x = (int)((double)(pos->x) * result[0 * 4 + 0]
                        + (double)(pos->y) * result[1 * 4 + 0]
                        + (double)(0     ) * result[2 * 4 + 0]
                        + (double)(1     ) * result[3 * 4 + 0]);
        pos->y = (int)((double)(pos->x) * result[0 * 4 + 1]
                        + (double)(pos->y) * result[1 * 4 + 1]
                        + (double)(0     ) * result[2 * 4 + 1]
                        + (double)(1     ) * result[3 * 4 + 1]);

}

void glictContainer::SetCaption(const std::string caption) {
        this->caption = caption;
}
std::string glictContainer::GetCaption() {
        return caption;
}

glictContainer* glictContainer::GetParent() {
        return parent;
}

void glictContainer::Focus(glictContainer* callerchild) {
    //printf("FOCUSING ON %s\n", this->objtype);
        if (callerchild && callerchild->focusable && objects.size()) {
                std::vector<glictContainer*>::iterator it;
                bool heredone=false;
                for (it=objects.begin(); it!=objects.end(); it++) {
                        if ((*it)==callerchild) {
                                objects.erase(it);
                                heredone=true;
                                break;
                        }
                }
                if (heredone)
                        objects.insert(objects.end(), callerchild);
        }


        if (parent) {
                parent->Focus(this);
        } else { // we're on top level
        }

        //if (!callerchild) printf("Focused on %s\n", this->objtype);
        glictGlobals.topFocused = this;
}

void glictContainer::SetVisible(bool vsbl) {
        this->visible = vsbl;
}

bool glictContainer::GetVisible() {
        return this->visible;
}

void glictContainer::SetEnabled(bool enabled) {
        this->enabled = enabled;
}

bool glictContainer::GetEnabled() {
        return this->enabled;
}

const char* glictContainer::EvtTypeDescriptor(glictEvents evt) {

        if (evt==GLICT_MOUSEDOWN) return "mousedown";
        if (evt==GLICT_MOUSEUP) return "mouseup";
        if (evt==GLICT_MOUSECLICK) return "mouseclick";
        return "UNKNOWN";
}




void glictContainer::RecursiveBoundaryFix() {
    if (parent)
        parent->RecursiveBoundaryFix();
    else
        this->SetPos(x,y);
}

void glictContainer::FixContainerOffsets() {

}



void glictContainer::SetCustomData(void *param) {
    this->customdata = param;
}

void* glictContainer::GetCustomData() {
    return customdata;
}


void glictContainer::SetVirtualSize(float w, float h) {
    virtualsize.w = w;
    virtualsize.h = h;
}
void glictContainer::VirtualScrollBottom() {

}

void glictContainer::SetFont(std::string name, unsigned int size) {
        this->fontname = name;
        this->fontsize = size;
}

void glictContainer::SetPrevious(glictContainer* p) {
        previous = p;
}

void glictContainer::SetNext(glictContainer *n) {
        next = n;
}

---

generated with doxygen 1.5.3 on Mon Oct 29 18:09:26 2007