case SCANCODE_LEFTSHIFT:
                    shift1 = make;
                    break;
                    
                case SCANCODE_RIGHTSHIFT:
                    shift2 = make;
                    break;
                    
                case SCANCODE_LEFTALT:
                    alt1 = make;
                    break;

                case SCANCODE_RIGHTALT:
                    alt2 = make;
                    break;
                    
            }

            status &= ~(MASK_KS_SHIFTKEYS);

            status |= (DWORD)((capslock << 8) |
                             (numlock << 7)   |
                             (slock << 6)     |
                             (control1 << 5)  |
                             (control2 << 4)  |
                             (alt1 << 3)      |
                             (alt2 << 2)      |
                             (shift1 << 1)    |
                             (shift2));
                             
            // Mouse button status
            if (oldbutton & IAL_MOUSE_LEFTBUTTON)
                status |= KS_LEFTBUTTON;
            else if (oldbutton & IAL_MOUSE_RIGHTBUTTON)
                status |= KS_RIGHTBUTTON;
        }
        ke->status = status;
#ifndef _STAND_ALONE
        SHAREDRES_SHIFTSTATUS = status;
#endif
        memcpy (oldkeystate, keystate, nr_keys);
        memcpy (&old_lwe, lwe, sizeof (LWEVENT));
        return 1;
    } 

    old_lwe.type = 0;
    return 0;

mouseret:
    status &= ~(MASK_KS_BUTTONS);
    oldbutton = button;
    if (oldbutton & IAL_MOUSE_LEFTBUTTON)
        status |= KS_LEFTBUTTON;
    if (oldbutton & IAL_MOUSE_RIGHTBUTTON)
        status |= KS_RIGHTBUTTON;
    me->status = status;
#ifndef _STAND_ALONE
    SHAREDRES_SHIFTSTATUS = status;
#endif
    memcpy (&old_lwe, lwe, sizeof (LWEVENT));
    return 1;
}

#else

BOOL GetLWEvent (int event, PLWEVENT lwe)
{
    static int timeout_count = 0;
    static LWEVENT old_lwe = {0, 0};

    int nr_keys = 0;
    unsigned int interval;
    int button;
    PMOUSEEVENT me = &(lwe->data.me);
    PKEYEVENT ke = &(lwe->data.ke);
    const unsigned char* keystate;
    int i;
    int make;       /* 0 = release, 1 = presse */

    if (event & IAL_MOUSEEVENT) {
        if (!IAL_UpdateMouse ())
            event &= ~IAL_MOUSEEVENT;
    }
    if (event & IAL_KEYEVENT) {
        if ((nr_keys = IAL_UpdateKeyboard ()) == 0)
            event &= ~IAL_KEYEVENT;
    }
    
    if (event == 0) {
        if (__mg_event_timeout.tv_sec == 0 && __mg_event_timeout.tv_usec == 0) {

            // set repeat time
            __mg_event_timeout.tv_sec = 0;
            __mg_event_timeout.tv_usec = repeatusec;

            // repeat last event
            if (old_lwe.type == LWETYPE_KEY 
                    && old_lwe.data.ke.event == KE_KEYDOWN) {
               memcpy (lwe, &old_lwe, sizeof (LWEVENT));
               lwe->data.ke.status |= KE_REPEATED;
               return 1;
            }

            if (!(old_lwe.type == LWETYPE_MOUSE
                    && (old_lwe.data.me.event == ME_LEFTDOWN ||
                        old_lwe.data.me.event == ME_RIGHTDOWN ||
                        old_lwe.data.me.event == ME_MIDDLEDOWN))) {
                // reset delay time
                __mg_event_timeout.tv_sec = 0;
                __mg_event_timeout.tv_usec = timeoutusec;
            }

            lwe->type = LWETYPE_TIMEOUT;
            lwe->count = ++timeout_count;
            return 1;
        }
        old_lwe.type = 0;
        return 0;
    }

    timeout_count = 0;
    // There was a event occurred.
    if (event & IAL_MOUSEEVENT) {
        lwe->type = LWETYPE_MOUSE;
        if (RefreshCursor(&me->x, &me->y, &button)) {

            me->event = ME_MOVED;
            time1 = 0;
            time2 = 0;

            if (oldbutton == button)
                return 1;
        }
   
        if ( !(oldbutton & IAL_MOUSE_LEFTBUTTON) && 
              (button & IAL_MOUSE_LEFTBUTTON) )
        {
            if (time1) {
                interval = __mg_timer_counter - time1;
                if (interval <= dblclicktime)
                    me->event = ME_LEFTDBLCLICK;
                else
                    me->event = ME_LEFTDOWN;
                time1 = 0;
            }
            else {
                time1 = __mg_timer_counter;
                me->event = ME_LEFTDOWN;
            }
            goto mouseret;
        }

        if ( (oldbutton & IAL_MOUSE_LEFTBUTTON) && 
             !(button & IAL_MOUSE_LEFTBUTTON) )
        {
            me->event = ME_LEFTUP;
            goto mouseret;
        }

        if ( !(oldbutton & IAL_MOUSE_RIGHTBUTTON) && 
              (button & IAL_MOUSE_RIGHTBUTTON) )
        {
            if (time2) {
                interval = __mg_timer_counter - time2;
                if (interval <= dblclicktime)
                    me->event = ME_RIGHTDBLCLICK;
                else
                    me->event = ME_RIGHTDOWN;
                time2 = 0;
            }
            else {
                time2 = __mg_timer_counter;
                me->event = ME_RIGHTDOWN;
            }
            goto mouseret;
        }

        if ( (oldbutton & IAL_MOUSE_RIGHTBUTTON) && 
            !(button & IAL_MOUSE_RIGHTBUTTON) )
        {
            me->event = ME_RIGHTUP;
            goto mouseret;
        }
    }

    if (event & IAL_KEYEVENT) {
        lwe->type = LWETYPE_KEY;
        keystate = IAL_GetKeyboardState ();
        for (i = 0; i < nr_keys; i++) {
            if(!oldkeystate[i] && keystate[i]) {
                 ke->event = KE_KEYDOWN;
                 ke->scancode = i;
                 olddownkey = i;
                 break;
            }
            if(oldkeystate[i] && !keystate[i]) {
                 ke->event = KE_KEYUP;
                 ke->scancode = i;
                 break;
            }
        }

        if (i == nr_keys) {
            ke->event = KE_KEYDOWN;
            ke->scancode = olddownkey;
        }
        
        make = (ke->event == KE_KEYDOWN) ? 1 : 0;

        if (i != nr_keys) {
            unsigned leds;

            switch (ke->scancode) {
                case SCANCODE_CAPSLOCK:
                    if (make && caps_off) {
                        capslock = 1 - capslock;
                        leds = slock | (numlock << 1) | (capslock << 2);
                        IAL_SetLeds (leds);
                        status = (DWORD)leds << 16;
                    }
                    caps_off = 1 - make;
                break;
                    
                case SCANCODE_NUMLOCK:
                    if (make && num_off) {
                        numlock = 1 - numlock;
                        leds = slock | (numlock << 1) | (capslock << 2);
                        IAL_SetLeds (leds);
                        status = (DWORD)leds << 16;
                    }
                    num_off = 1 - make;
                break;
                
                case SCANCODE_SCROLLLOCK:
                    if (make & slock_off) {
                        slock = 1 - slock;
                        leds = slock | (numlock << 1) | (capslock << 2);
                        IAL_SetLeds (leds);
                        status = (DWORD)leds << 16;
                    }
                    slock_off = 1 - make;
                    break;

                case SCANCODE_LEFTCONTROL:
                    control1 = make;
                    break;
                    
                case SCANCODE_RIGHTCONTROL:
                    control2 = make;
                    break;
                    
                case SCANCODE_LEFTSHIFT:
                    shift1 = make;
                    break;
                    
                case SCANCODE_RIGHTSHIFT:
                    shift2 = make;
                    break;
                    
                case SCANCODE_LEFTALT:
                    alt1 = make;
                    break;

                case SCANCODE_RIGHTALT:
                    alt2 = make;
                    break;
                    
            }

            status &= ~(MASK_KS_SHIFTKEYS);

            status |= (DWORD)((capslock << 8) |
                             (numlock << 7)   |
                             (slock << 6)     |
                             (control1 << 5)  |
                             (control2 << 4)  |
                             (alt1 << 3)      |
                             (alt2 << 2)      |
                             (shift1 << 1)    |
                             (shift2));
                             
            // Mouse button status
            if (oldbutton & IAL_MOUSE_LEFTBUTTON)
                status |= KS_LEFTBUTTON;
            else if (oldbutton & IAL_MOUSE_RIGHTBUTTON)
                status |= KS_RIGHTBUTTON;
        }
        ke->status = status;
        memcpy (oldkeystate, keystate, nr_keys);
        memcpy (&old_lwe, lwe, sizeof (LWEVENT));
        __mg_event_timeout.tv_sec = 0;
        __mg_event_timeout.tv_usec = timeoutusec;
        return 1;
    } 

    old_lwe.type = 0;
    return 0;

mouseret:
    status &= ~(MASK_KS_BUTTONS);
    oldbutton = button;
    if (oldbutton & IAL_MOUSE_LEFTBUTTON)
        status |= KS_LEFTBUTTON;
    if (oldbutton & IAL_MOUSE_RIGHTBUTTON)
        status |= KS_RIGHTBUTTON;
    me->status = status;
    memcpy (&old_lwe, lwe, sizeof (LWEVENT));
    __mg_event_timeout.tv_sec = 0;
    __mg_event_timeout.tv_usec = timeoutusec;
    return 1;
}
#endif

BOOL GUIAPI GetKeyStatus (UINT uKey)
{
#if defined (_LITE_VERSION) && !defined(_STAND_ALONE)
    if (!mgIsServer) {
        if (uKey & 0xF000)      // this is a mouse key
            return SHAREDRES_BUTTON & (uKey >> 8);
        return 0;
    }
#endif

    if (uKey & 0xF000)      // this is a mouse key
        return oldbutton & (uKey >> 8);
    else if (uKey <= MGUI_NR_KEYS)
        return oldkeystate [uKey];

    return FALSE;
}

DWORD GUIAPI GetShiftKeyStatus (void)
{
#if defined (_LITE_VERSION) && !defined(_STAND_ALONE)
    return SHAREDRES_SHIFTSTATUS;
#else
    return status;
#endif
}

BOOL InitLWEvent (void)
{
    GetDblclickTime ();
    GetTimeout ();

    if (InitIAL ())
        return FALSE;

    ResetMouseEvent();
    ResetKeyEvent();

    return TRUE;
}

void TerminateLWEvent (void)
{
#if 0
    ResetMouseEvent ();
    ResetKeyEvent ();
#endif

    TerminateIAL ();
}