---

ui_main.cpp

Go to the documentation of this file.

// OMICRON ENGINE HEADER FILE
//
// --------------------------------------------------------------------------
// Copyright (C) 2001-2002 by Bjoern Paetzel <kolrabi@gmx.de>
//
// This file is part of the Omicron Engine.
//
// The Omicron Engine 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.
//
// The Omicron Engine  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 The Omicron Engine;  if not,  write to the  Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
//
// --------------------------------------------------------------------------
// Last modified:       $Date: 2002/12/07 19:02:03 $
// By           :       $Author: kolrabi $
// $Id: ui_main.cpp,v 1.1.1.1 2002/12/07 19:02:03 kolrabi Exp $ 

/*

  $Log: ui_main.cpp,v $
  Revision 1.1.1.1  2002/12/07 19:02:03  kolrabi
  initial release


*/

#include            "omicron/internal.h" 
#include            "omicron/render.h"
#include            "omicron/image.h"
#include            "omicron/gui.h" 
#include            "omicron/list.h"
#include            "omicron/input.h" 
#include            "omicron/file.h"
#include            "omicron/texture.h"

/**************************************************************************** 
 **************************************************************************** 
 * UI OBJ. FUNCTIONS ******************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 

ushort gui_c::get_key_ascii(uchar key)
{
    AssertThisV;

    switch(key)
    { 
        case OK_LEFT: 
            return UI_KEY_LEFT; 
        case OK_RIGHT: 
            return UI_KEY_RIGHT; 
        case OK_UP: 
            return UI_KEY_UP; 
        case OK_DOWN: 
            return UI_KEY_DOWN; 
        case OK_BACKSPACE: 
            return UI_KEY_BACKSPACE; 
        case OK_DELETE: 
            return UI_KEY_DELETE; 
        case OK_HOME: 
            return UI_KEY_HOME; 
        case OK_END: 
            return UI_KEY_END; 
    } 

    return _get_key_ascii(key);
}

/***************************************************************************/

uiobject_c::uiobject_c()
{
    classname       = "generic";

    text            = NULL;
    img             = new image_c;
    children        = new list_c<uiobject_c>;
    id              = 0;
    parent          = NULL;

    visible         = true;
    disabled        = false;

    growth[0]       = 0;
    growth[1]       = 0;
    growth[2]       = 0;
    growth[3]       = 0;

    styleflags      = 0;

    width           = 0;
    height          = 0;

    bgcolor         = color_from_floats(1,1,1,1);

    movable         = false;
    mousedrag       = false;

    cursor          = 0;

    fnt             = gv.gui->get_font(UIF_FONT8);

    set_needs_refresh();
}

uiobject_c::~uiobject_c()
{
    AssertThis;

    if (children)
    {
        uiobject_c *obj = (uiobject_c *)children->get_first();

        while(obj)
        {
            SafeDelete(obj);
            obj = (uiobject_c *)children->get_next();
        }
    }

    SafeDelete(children);
    SafeDelete(img);
    SafeArrayDelete(text);
}

void uiobject_c::resize(ushort w, ushort h)
{
    AssertThis;

    ushort pw = 0, ph = 0;
    ushort lw = width, lh = height;

    width=w; height=h;

    if (parent)
    {
        if (!strcmp(parent->classname, "desktop"))
        {
            pw = parent->get_width();
            ph = parent->get_height();
        }
    }
    else
    {
        pw = gv.init.hres;
        ph = gv.init.vres;
    }

    if (pw && ph)
    {
        if (posx+width>pw)
            width = pw-posx;

        if (posy+height>ph)
            height = ph-posy;
    }

    img->create(width,height);
    set_needs_refresh();

    uievent_s eve;

    eve.event   = UIE_PARENTSIZE;
    eve.key     = 0;
    eve.x       = width-lw;
    eve.y       = height-lh;
    eve.mod     = 0;

    if (children)
    {
        eve.obj = (uiobject_c *)children->get_first();

        while(eve.obj)
        {
            eve.obj->event(&eve);
            eve.obj = (uiobject_c *)children->get_next();
        }
    }
}

void uiobject_c::move(sshort x, sshort y)
{ 
    AssertThis;

    posx=x; 
    posy=y;

    if (!strcmp(classname, "desktop"))
        return;

    if (!parent || (0 == strcmp(parent->get_classname(), "desktop")))
    {
        if (posx<0) posx = 0;
        if (posx>parent->get_width()-width) posx = parent->get_width()-width;
        if (posy<0) 
            posy = 0;
        if (posy>parent->get_height()-height) 
            posy = parent->get_height()-height;

        if (parent)
            parent->set_needs_refresh();
    }
}

void uiobject_c::draw(image_c *dst)
{
    AssertThis;

    if (!visible)
        return;

    if (needsrefresh || this==gv.gui->get_desktop())
        refresh();

    if (this==gv.gui->get_desktop())
        return;

    if (dst)
    {
        dst->blt_blend(img, 0, 0, posx, posy, width, height, BT_BLEND);
    }
    else
    {
        img->draw(posx, posy);
    }
}

void uiobject_c::refresh()
{
    AssertThis;

    paint();

    uiobject_c *obj = (uiobject_c *)children->get_first();

    while(obj)
    {
        if (this == gv.gui->get_desktop())
            obj->draw(NULL);
        else
            obj->draw(img);

        obj = (uiobject_c *)children->get_next();
    }

    needsrefresh = false;
}

void uiobject_c::paint()
{
    AssertThis;

    if (gv.gui->get_desktop()==this)
        return;

    if (!(styleflags&UI_TRANSPARENT))
        img->filled_rectangle(0,0,width,height, bgcolor);

    if (styleflags&UI_BORDER_FLAT)
    {
        img->rectangle(0,0,width,height, gv.gui->get_color(UIC_BORDER));
    }
    else
    {
        if (styleflags&UI_BORDER_OUTERSUNKEN)
        {
            // top left
            img->hline(0, 0, width-2,    gv.gui->get_color(UIC_BLACK));
            img->vline(0, 0, height-2,   gv.gui->get_color(UIC_BLACK));

            // bottom right
            img->hline(1, height-1, width-2,    gv.gui->get_color(UIC_FACE));
            img->vline(width-1, 1, height-2,    gv.gui->get_color(UIC_FACE));
        }
        if (styleflags&UI_BORDER_INNERSUNKEN)
        {
            // top left +1,1
            img->hline(1, 1, width-3,   gv.gui->get_color(UIC_SHADOW));
            img->vline(1, 1, height-3,  gv.gui->get_color(UIC_SHADOW));

            // botton right -1,1
            img->hline(2, height-2, width-3,   gv.gui->get_color(UIC_LIGHT));
            img->vline(width-2, 2, height-3,   gv.gui->get_color(UIC_LIGHT));
        }
        if (styleflags&UI_BORDER_OUTERRAISED)
        {
            // top left
            img->hline(0, 0, width-2,    gv.gui->get_color(UIC_FACE));
            img->vline(0, 0, height-2,   gv.gui->get_color(UIC_FACE));

            // bottom right
            img->hline(1, height-1, width-2,    gv.gui->get_color(UIC_BLACK));
            img->vline(width-1, 1, height-2,    gv.gui->get_color(UIC_BLACK));
        }
        if (styleflags&UI_BORDER_INNERRAISED)
        {
            // top left +1,1
            img->hline(1, 1, width-3,   gv.gui->get_color(UIC_LIGHT));
            img->vline(1, 1, height-3,  gv.gui->get_color(UIC_LIGHT));

            // botton right -1,1
            img->hline(2, height-2, width-3,   gv.gui->get_color(UIC_SHADOW));
            img->vline(width-2, 2, height-3,   gv.gui->get_color(UIC_SHADOW));
        }
    }
}

void uiobject_c::add_child(uiobject_c *obj)
{
    AssertThis;

    AssertReturn1(obj);

    if (obj == this)
        return;

    children->append(obj);
    obj->parent = this;
}

void uiobject_c::remove_child(uiobject_c *obj)
{
    AssertThis;

    AssertReturn1(obj);

    children->remove(obj);
    SafeDelete(obj);
}

void uiobject_c::bring_child_to_front(uiobject_c *obj)
{
    AssertThis;

    AssertReturn1(obj);
    children->set_current(obj);
    if (obj != children->get_current())
        return;

    children->remove(obj);
    children->append(obj);
}

uiobject_c *uiobject_c::get_object(ulong id)
{
    AssertThisV;

    if (id==get_id())
        return this;

    if (children)
    {
        uiobject_c *obj = (uiobject_c *)children->get_first();

        while(obj)
        {
            if (obj->get_id() == id)
                return obj;

            uiobject_c *obj2 = obj->get_object(id);

            if (obj2)
                return obj2;

            obj = (uiobject_c *)children->get_next();
        }
    }
    return NULL;
}

uiobject_c *uiobject_c::find_mouse_object(ushort mx, ushort my) 
{ 
    AssertThisV;

    uiobject_c  *mouseobj   = NULL, 
                *obj        = (uiobject_c*)children->get_last(), 
                *subobj; 
    
    // find object under mouse cursor 
    while(obj) 
    { 
        sshort pos[4];

        pos[0] = obj->posx;
        pos[1] = obj->posy;
        pos[2] = pos[0]+obj->width;
        pos[3] = pos[1]+obj->height;

        if (mx>pos[0] && mx<pos[2] && 
            my>pos[1] && my<pos[3]) 
        { 
            mouseobj  = obj; 
            subobj    = mouseobj->find_mouse_object(mx-pos[0],my-pos[1]);
            if (subobj) 
                mouseobj = subobj; 

            return mouseobj;
        } 
 
        obj = (uiobject_c*)children->get_prev(); 
    } 
 
    return mouseobj; 
} 

void uiobject_c::event(uievent_s *eve)
{
    AssertThis;

    AssertReturn1(eve);

    switch (eve->event)
    {
        case UIE_PARENTSIZE:
            {
                move(posx+eve->x*growth[0], posy+eve->y*growth[1]);
                resize(width+eve->x*growth[2], height+eve->y*growth[3]);
            }
            break;

        case UIE_MOUSEOVER: 
            if (movable && !(gv.mouse_b&1))
                mousedrag = false;
            break; 

        case UIE_MOUSEDOWN:
            if (movable)
            {
                mousedrag = true;
                dragdownx = eve->x;
                dragdowny = eve->y;

                // set_needs_refresh();
                if (parent)
                    parent->bring_child_to_front(this);
            }
            break;        

        case UIE_MOUSEMOVE:
            if (movable & mousedrag)
                move(eve->x-dragdownx+posx, eve->y-dragdowny+posy);
            break;

        case UIE_MOUSEUP: 
            mousedrag = false;
            break; 
    }
    
    gv.iface->gui_callback(eve);
}

void uiobject_c::set_text(const char *txt)
{
    AssertThis;

    SafeArrayDelete(text);

    if (txt)
    {
        text = new char[strlen(txt)+1];
        strcpy(text, txt);

        set_needs_refresh();
    }
}

sshort uiobject_c::get_screenposx()
{
    AssertThisV;

    if (parent)
        return posx+parent->get_screenposx();

    return posx;
}

sshort uiobject_c::get_screenposy()
{
    AssertThisV;

    if (parent)
        return posy+parent->get_screenposy();

    return posy;
}

void uiobject_c::set_growth(sshort x, sshort y, sshort w, sshort h)
{
    AssertThis;

    growth[0] = x;
    growth[1] = y;
    growth[2] = w;
    growth[3] = h;
}

/***************************************************************************/

gui_c::gui_c()
{
    SafeDelete(gv.gui);

    if (gv.init.nogfx)
        return;

    gv.fileman->load_pak("gui.pak");

    gv.gui              = this;

    // keyboard stuff
    lastkeydown         = 0;
    keylastrepeattime   = 0;
    keydownstarttime    = 0;
    currentkeymod       = 0;

    // mouse stuff
    mouseobj            = lmouseobj = focus   = NULL;
    cursorx             = cursory   = 0;
    cursor              = 0;

    // the top level object
    desktop             = new uiobject_c;

    if (desktop)
    {
        desktop->classname = "desktop";
        desktop->move(0,0);
        desktop->resize(gv.init.hres, gv.init.vres);
    }

    // gui images
    images              = new animation_c[UII_COUNT];
    if (images)
    {
        images[UII_WINDOW   ].load("gui/wndpix");
        images[UII_WINDOW   ].set_framecount(8);

        images[UII_CHECKBOX ].load("gui/checkbox");
        images[UII_CHECKBOX ].set_framecount(8);

        images[UII_SLIDER   ].load("gui/slider");
        images[UII_SLIDER   ].set_framecount(8);

        images[UII_CURSOR   ].load("gui/cursor");
        images[UII_CURSOR   ].set_framecount(8);
    }

    // colors
    colors[UIC_FACE     ]   = color_from_floats(0.75f, 0.75f, 0.75f, 1.00f);
    colors[UIC_LIGHT    ]   = color_from_floats(1.00f, 1.00f, 1.00f, 1.00f);
    colors[UIC_SHADOW   ]   = color_from_floats(0.50f, 0.50f, 0.50f, 1.00f);
    colors[UIC_BLACK    ]   = color_from_floats(0.00f, 0.00f, 0.00f, 1.00f);
    colors[UIC_HIGHLIGHT]   = color_from_floats(0.85f, 0.85f, 0.85f, 1.00f);
    colors[UIC_SELECTION]   = color_from_floats(0.75f, 0.75f, 1.00f, 1.00f);
    colors[UIC_FOCUS    ]   = color_from_floats(0.50f, 0.50f, 0.50f, 1.00f);
    colors[UIC_DISABLED ]   = color_from_floats(0.60f, 0.60f, 0.60f, 1.00f);
    colors[UIC_TEXT     ]   = color_from_floats(0.00f, 0.00f, 0.00f, 1.00f);
    colors[UIC_EDIT     ]   = color_from_floats(1.00f, 1.00f, 1.00f, 1.00f);
    colors[UIC_BORDER   ]   = color_from_floats(0.50f, 0.50f, 0.50f, 1.00f);
    colors[UIC_WINDOW   ]   = color_from_floats(1.00f, 1.00f, 1.00f, 1.00f);

    // fonts
    image_c     *fntimg = NULL;
    
    fntimg  = new image_c;

    if (fntimg)
    {
        fntimg->load("gui/chars8x8");
        font[UIF_FONT8] = gv.renderer->font_createfromimage_fixed(fntimg, 8);

        fntimg->load("gui/chars8x8fixed");
        font[UIF_FONT8_FIXED] = gv.renderer->font_createfromimage_fixed(fntimg, 8);

        fntimg->load("gui/chars16x16");
        font[UIF_FONT16] = gv.renderer->font_createfromimage_fixed(fntimg, 16);

        fntimg->load("gui/chars16x16fixed");
        font[UIF_FONT16_FIXED] = gv.renderer->font_createfromimage_fixed(fntimg, 16);

        SafeDelete(fntimg);
    }
    
    if (font[UIF_FONT8])
    {
        font[UIF_FONT8]->widths[32] = 4;        font[UIF_FONT8]->widths[33] = 2;
        font[UIF_FONT8]->widths[34] = 4;        font[UIF_FONT8]->widths[35] = 6;
        font[UIF_FONT8]->widths[36] = 6;        font[UIF_FONT8]->widths[37] = 7;
        font[UIF_FONT8]->widths[38] = 6;        font[UIF_FONT8]->widths[39] = 2;
        font[UIF_FONT8]->widths[40] = 3;        font[UIF_FONT8]->widths[41] = 3;
        font[UIF_FONT8]->widths[42] = 4;        font[UIF_FONT8]->widths[43] = 4;
        font[UIF_FONT8]->widths[44] = 2;        font[UIF_FONT8]->widths[45] = 4;
        font[UIF_FONT8]->widths[46] = 2;        font[UIF_FONT8]->widths[47] = 3;

        font[UIF_FONT8]->widths[48] = 5;        font[UIF_FONT8]->widths[49] = 5;
        font[UIF_FONT8]->widths[50] = 5;        font[UIF_FONT8]->widths[51] = 5;
        font[UIF_FONT8]->widths[52] = 5;        font[UIF_FONT8]->widths[53] = 5;
        font[UIF_FONT8]->widths[54] = 5;        font[UIF_FONT8]->widths[55] = 5;
        font[UIF_FONT8]->widths[56] = 5;        font[UIF_FONT8]->widths[57] = 5;
        font[UIF_FONT8]->widths[58] = 2;        font[UIF_FONT8]->widths[59] = 2;
        font[UIF_FONT8]->widths[60] = 4;        font[UIF_FONT8]->widths[61] = 4;
        font[UIF_FONT8]->widths[62] = 4;        font[UIF_FONT8]->widths[63] = 5;

        font[UIF_FONT8]->widths[64] = 8;        font[UIF_FONT8]->widths[65] = 8;
        font[UIF_FONT8]->widths[66] = 8;        font[UIF_FONT8]->widths[67] = 8;
        font[UIF_FONT8]->widths[68] = 8;        font[UIF_FONT8]->widths[69] = 8;
        font[UIF_FONT8]->widths[70] = 8;        font[UIF_FONT8]->widths[71] = 8;
        font[UIF_FONT8]->widths[72] = 8;        font[UIF_FONT8]->widths[73] = 2;
        font[UIF_FONT8]->widths[74] = 5;        font[UIF_FONT8]->widths[75] = 6;
        font[UIF_FONT8]->widths[76] = 4;        font[UIF_FONT8]->widths[77] = 8;
        font[UIF_FONT8]->widths[78] = 7;        font[UIF_FONT8]->widths[79] = 7;

        font[UIF_FONT8]->widths[80] = 7;        font[UIF_FONT8]->widths[81] = 7;
        font[UIF_FONT8]->widths[82] = 7;        font[UIF_FONT8]->widths[83] = 6;
        font[UIF_FONT8]->widths[84] = 6;        font[UIF_FONT8]->widths[85] = 6;
        font[UIF_FONT8]->widths[86] = 6;        font[UIF_FONT8]->widths[87] = 7;
        font[UIF_FONT8]->widths[88] = 7;        font[UIF_FONT8]->widths[89] = 7;
        font[UIF_FONT8]->widths[90] = 7;        font[UIF_FONT8]->widths[91] = 3;
        font[UIF_FONT8]->widths[92] = 3;        font[UIF_FONT8]->widths[93] = 3;
        font[UIF_FONT8]->widths[94] = 4;        font[UIF_FONT8]->widths[95] = 5;

        font[UIF_FONT8]->widths[96]  = 2;       font[UIF_FONT8]->widths[97]  = 5;
        font[UIF_FONT8]->widths[98]  = 5;       font[UIF_FONT8]->widths[99]  = 5;
        font[UIF_FONT8]->widths[100] = 5;       font[UIF_FONT8]->widths[101] = 5;
        font[UIF_FONT8]->widths[102] = 3;       font[UIF_FONT8]->widths[103] = 5;
        font[UIF_FONT8]->widths[104] = 5;       font[UIF_FONT8]->widths[105] = 2;
        font[UIF_FONT8]->widths[106] = 3;       font[UIF_FONT8]->widths[107] = 5;
        font[UIF_FONT8]->widths[108] = 2;       font[UIF_FONT8]->widths[109] = 8;
        font[UIF_FONT8]->widths[110] = 5;       font[UIF_FONT8]->widths[111] = 6;

        font[UIF_FONT8]->widths[112] = 5;       font[UIF_FONT8]->widths[113] = 5;
        font[UIF_FONT8]->widths[114] = 3;       font[UIF_FONT8]->widths[115] = 5;
        font[UIF_FONT8]->widths[116] = 3;       font[UIF_FONT8]->widths[117] = 5;
        font[UIF_FONT8]->widths[118] = 5;       font[UIF_FONT8]->widths[119] = 6;
        font[UIF_FONT8]->widths[120] = 4;       font[UIF_FONT8]->widths[121] = 4;
        font[UIF_FONT8]->widths[122] = 4;       font[UIF_FONT8]->widths[123] = 4;
        font[UIF_FONT8]->widths[124] = 2;       font[UIF_FONT8]->widths[125] = 4;
        font[UIF_FONT8]->widths[126] = 8;       font[UIF_FONT8]->widths[127] = 8;
    }

    if (font[UIF_FONT16])
    {
        uchar widths[] = { 
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
             8,  4,  9, 13, 12, 15, 13,  4,  5,  5,  8,  9,  6,  6,  6, 14, // !"# ...
            11,  8, 11, 11, 11, 11, 11, 11, 11, 11,  6,  6,  8, 10,  9,  8, // 012 ...
            16, 14, 12, 13, 12, 11, 10, 13, 12,  5, 11, 13, 10, 14, 12, 13, // @AB ...
            11, 13, 12, 12, 12, 12, 14, 14, 13, 14, 12,  6, 14,  6,  7, 15, // PQR ...
             4, 11, 11, 11, 11, 11,  8, 11, 10,  5,  7, 11,  5, 14, 10, 11, // 'ab ...
            11, 11,  8, 10, 11, 10, 11, 14, 11, 11, 10,  8,  3,  8,  9, 14  // pqr ...
        };

        memcpy(font[UIF_FONT16]->widths, widths, sizeof(widths));
    }
}

gui_c::~gui_c()
{
    AssertThis;
    
    SafeDelete(desktop);
    SafeArrayDelete(images);

    for (ulong i=0; i<UIF_COUNT; i++)
        gv.renderer->font_free(font[i]);
}

void gui_c::draw()
{
    AssertThis;

    gv.renderer->view_2d(gv.init.hres, gv.init.vres);

    gv.texman->set(-1);
    gv.renderer->set_fog(false);
    gv.renderer->set_zbuffer(ZB_NONE);
    gv.renderer->set_color(COLOR_WHITE);

    if (desktop)
    {
        if (desktop->width!=gv.init.hres || desktop->height!=gv.init.vres)
            desktop->resize(gv.init.hres, gv.init.vres);

        desktop->draw(NULL);
    }

    if (images)
    {
        images[UII_CURSOR].set_frame(cursor);
        images[UII_CURSOR].draw(cursorx, cursory);
    }
}

void gui_c::update()
{
    AssertThis;

    AssertReturn1(desktop);

    // get current key modifiers

    currentkeymod = 0;

    if (gv.kbdstate[OK_LSHIFT] || gv.kbdstate[OK_RSHIFT]) 
        currentkeymod |= UI_KEYFLAG_SHIFT; 

    if (gv.kbdstate[OK_RALT]) 
        currentkeymod |= UI_KEYFLAG_ALTGR; 

    if (gv.kbdstate[OK_LALT]) 
        currentkeymod |= UI_KEYFLAG_ALT; 

    if (gv.kbdstate[OK_LCTRL] || gv.kbdstate[OK_RCTRL]) 
        currentkeymod |= UI_KEYFLAG_CTRL; 


    // update cursor
    cursorlx    = cursorx;
    cursorly    = cursory;

    if (gv.init.fullscreen)
    {
        cursorx     += gv.mouse_dx;
        cursory     += gv.mouse_dy;
    }
    else
    {
#if defined(WIN32) || defined(_WIN32)
        POINT pt;

        GetCursorPos(&pt);
        ScreenToClient((HWND)gv.init.wnd, &pt);

        cursorx = pt.x;
        cursory = pt.y;
#else
#endif
    }

    cursorx     = (cursorx>gv.init.hres?gv.init.hres:(cursorx<0?0:cursorx));
    cursory     = (cursory>gv.init.vres?gv.init.vres:(cursory<0?0:cursory));

    cursordx    = cursorx-cursordx;
    cursordy    = cursory-cursordy;

    lmouseobj   = mouseobj; 
    mouseobj    = desktop->find_mouse_object(cursorx,cursory); 

    if (mouseobj)
    {
        if (cursordx || cursordy)
            send_mouse_event(mouseobj, UIE_MOUSEMOVE);
    }

    // if the object under the mousecursor is different from the one 
    // that was last time, tell the old object it has lost the mouse 
    // and the new object, it has got it 
    if (mouseobj != lmouseobj) 
    { 
        send_mouse_event(lmouseobj,    UIE_MOUSEOUT);

        if (cursordx || cursordy)
            send_mouse_event(lmouseobj,     UIE_MOUSEMOVE);

        send_mouse_event(mouseobj,     UIE_MOUSEOVER);
    }

    // check for mouse down 
    if ((gv.mouse_b&1) && !(gv.mouse_lb&1)) 
    { 
        // if mouse button has gone down, give the focus to the object 
        // under the mouse cursor 
        send_generic_event(focus, UIE_LOSTFOCUS);
        focus = mouseobj; 
        send_generic_event(focus, UIE_GETFOCUS);
        send_mouse_event(focus,   UIE_MOUSEDOWN);
    } 
    // check for mouse up 
    else if (!(gv.mouse_b&1) && (gv.mouse_lb&1) && mouseobj) 
    { 
        // if mouse button has gone up again and there exists an object 
        // under the mousecursor, send the UIM_MOUSEUP message 
        send_mouse_event(mouseobj,    UIE_MOUSEUP);
 
        // if the object has the focus it has been clicked on 
        if (mouseobj == focus)
            send_mouse_event(mouseobj,    UIE_MOUSECLICK);
    }

    if (focus!=mouseobj && (cursordx || cursordy))
        send_mouse_event(focus, UIE_MOUSEMOVE);

    // get mouse pointer from object
    if (mouseobj)
        cursor = mouseobj->get_cursor();
    else
        cursor = 0;

    ushort i = 0; 
    ulong  t = _time_get();

    for (i=0; i<255; i++) 
    { 
        // for any pressed key
        if (gv.kbdstate[i] && (!gv.lkbdstate[i] || (i == lastkeydown))) 
        { 
            // was last pressed key
            if (i == lastkeydown) 
            { 
                if (t-keydownstarttime<200)
                    continue; 
 
                if (t-keylastrepeattime<20) 
                    continue; 
            } 

            // wasnt pressed last frame
            if (!gv.lkbdstate[i]) 
            { 
                lastkeydown       = (uchar)i; 
                keydownstarttime  = t; 
            } 
 
            ushort c = (ushort)get_key_ascii((uchar)i); 
 
            if (c) 
                send_keyboard_event(focus, UIE_CHAR, c);
 
            keylastrepeattime = t; 
        } 
    } 
}


void gui_c::send_mouse_event(uiobject_c *obj, ushort event)
{
    AssertThis;

    if (!obj)
        return;

    uievent_s eve;

    eve.event   = event;
    eve.key     = 0;
    eve.obj     = obj;
    eve.x       = cursorx - obj->get_screenposx();
    eve.y       = cursory - obj->get_screenposy();
    eve.mod     = currentkeymod;

    obj->event(&eve);
}

void gui_c::send_generic_event(uiobject_c *obj, ushort event)
{
    AssertThis;

    if (!obj)
        return;

    uievent_s eve;

    eve.event   = event;
    eve.key     = 0;
    eve.obj     = obj;
    eve.x       = 0;
    eve.y       = 0;
    eve.mod     = currentkeymod;

    obj->event(&eve);
}

void gui_c::send_keyboard_event(uiobject_c *obj, ushort event, ushort key)
{
    AssertThis;

    if (!obj)
        return;

    uievent_s eve;

    eve.event   = event;
    eve.key     = key;
    eve.obj     = obj;
    eve.x       = 0;
    eve.y       = 0;
    eve.mod     = currentkeymod;

    obj->event(&eve);
}

void gui_c::load(const char *fname)
{
    AssertThis;

    file_t      *f;

    f = gv.fileman->load(fname, false);

    if (!f)
        return;

    uiobject_c  *obj, *parentobj;

    char        *comment        = NULL;     // first occ. of #
    char        line[1024]; 
    char        *linebeginning  = line; 

    char        cname[32]; 
    char        mov, ena, checked; 
    sshort      x,y,w,h;
    int         textpos;
    ulong       parentid, thisid;
    
    memset(line, 0, 1024); 
 
    while(!gv.fileman->eof(f)) 
    { 
        gv.fileman->gets(line, 1024, f); 

        comment = strchr(line, '#');
        if (comment)
            *comment = 0;

        linebeginning = _strtrm(line, " \n\r\t"); 

        if (!strlen(linebeginning)) 
            continue; 
 
// class  parent  id x y   w   h   movable enabled checked text
        textpos = strlen(line);
        sscanf(line, "%s %lu %lu %hd %hd %hd %hd %c %c %c %n", cname, &parentid, &thisid, &x, &y, &w, &h, &mov, &ena, &checked, &textpos);

        obj = NULL;
        parentobj = desktop->get_object(parentid);

        if (!parentobj)
            continue;


        if (!strcmpi(cname, "window"))
        {
            obj = new uiwindow_c;
        }
        else if (!strcmpi(cname, "button"))
        {
            obj = new uibutton_c;
        }
        else if (!strcmpi(cname, "label"))
        {
            obj = new uilabel_c;
        }
        else if (!strcmpi(cname, "edit"))
        {
            obj = new uiedit_c;
        }
        else if (!strcmpi(cname, "checkbutton"))
        {
            obj = new uicheckbutton_c;

            ((uicheckbutton_c*)obj)->set_radio(false);
            ((uicheckbutton_c*)obj)->set_checked(strchr(TRUE_STRING, mov)?true:false);
        }
        else if (!strcmpi(cname, "radiobutton"))
        {
            obj = new uicheckbutton_c;

            ((uicheckbutton_c*)obj)->set_radio(true);
            ((uicheckbutton_c*)obj)->set_checked(strchr(TRUE_STRING, mov)?true:false);
        }
        else if (!strcmpi(cname, "slider"))
        {
            obj = new uislider_c;
        }
          
        if (obj)
        {
            if (parentobj && parentobj!=obj)
                parentobj->add_child(obj);

            obj->move(x,y);
            obj->resize(w,h);

            obj->movable    = strchr(TRUE_STRING, mov)?true:false;
            obj->disabled   = (!strchr(TRUE_STRING, ena))?true:false;

            obj->set_text(line+textpos);

            obj->set_id(thisid);
        }
    }

    gv.fileman->close(f);
}

animation_c *gui_c::get_image(ulong nr)
{ 
    AssertThisV;

    AssertReturnValue2(nr>=0, nr<=UII_COUNT, images);
    return &images[nr]; 
}

---