Return to hotkeys.c CVS log

Up to [UNIX Amiga Emulator] / uae / src

Annotation of uae/src/hotkeys.c, revision 1.1.1.1

1.1       root        1:  /*
                      2:   * UAE - The Un*x Amiga Emulator
                      3:   *
                      4:   * Target-independent support for parsing hotkey sequences
                      5:   *
                      6:   * Copyright 2004 Richard Drummond
                      7:   *
                      8:   * Based on the hotkey handling previously found
                      9:   * in x11win.c and sdlgfx.c
                     10:   */
                     11: 
                     12: #include "sysconfig.h"
                     13: #include "sysdeps.h"
                     14: #include "options.h"
                     15: #include "inputdevice.h"
                     16: #include "hotkeys.h"
                     17: 
                     18: 
                     19: static struct uae_hotkeyseq *hotkey_table;
                     20: 
                     21: 
                     22: void set_default_hotkeys (struct uae_hotkeyseq *keys)
                     23: {
                     24:     hotkey_table = keys;
                     25:     reset_hotkeys ();
                     26: }
                     27: 
                     28: void reset_hotkeys (void) {
                     29:     struct uae_hotkeyseq *seq = hotkey_table;
                     30:     int i;
                     31: 
                     32:     if (!seq)
                     33:        return;
                     34: 
                     35:     while (seq->event) {
                     36:        for (i=0; i < HOTKEYSEQ_MAXKEYS; i++)
                     37:            seq->key_pressed[i] = 0;
                     38:        seq->complete = 0;
                     39:        seq++;
                     40:     }
                     41: }
                     42: 
                     43: int match_hotkey_sequence (int key, int state)
                     44: {
                     45:     struct uae_hotkeyseq *seq = hotkey_table;
                     46:     int event = 0;
                     47: 
                     48:     if (!seq)
                     49:        return 0;
                     50: 
                     51:     if (state) {
                     52:        /* Key down */
                     53:        while (seq->event != 0) {
                     54:            int i;
                     55:            /* Check whether key is the next key in this sequence */
                     56:            if (key == seq->keyseq[0])
                     57:                seq->key_pressed[0] = 1;
                     58:            for (i=1; i < HOTKEYSEQ_MAXKEYS; i++) {
                     59:                if ((seq->key_pressed[i-1] == 1) && (key == seq->keyseq[i])) {
                     60:                    seq->key_pressed[i] = 1;
                     61:                    /* Was it the final key in this sequence ? */
                     62:                    if ((i+1 == HOTKEYSEQ_MAXKEYS) || (seq->keyseq[i+1] == (uae_u16)-1)) {
                     63:                        /* Yes. Return the event */
                     64:                        event = seq->event;
                     65:                        seq->complete = 1;
                     66:                        break;
                     67:                    }
                     68:                }
                     69:            }
                     70:            seq++;
                     71:        }
                     72:     } else {
                     73:        /* key up */
                     74:        while (seq->event != 0) {
                     75:            int i, j;
                     76:            for (i = 0; i < HOTKEYSEQ_MAXKEYS; i++) {
                     77:                if ((key == seq->keyseq[i]) && (seq->key_pressed[i] == 1)) {
                     78:                    /* letting up a key - cancels any keys following it
                     79:                     * in the sequence that are pressed */
                     80:                    for (j=i; j < HOTKEYSEQ_MAXKEYS; j++)
                     81:                        seq->key_pressed[j] = 0;
                     82:                    /* if it was previously complete generate return the event
                     83:                     * (so that it can be used as a key-up event */
                     84:                    if (seq->complete) {
                     85:                        seq->complete = 0;
                     86:                        event = seq->event;
                     87:                    }
                     88:                }
                     89:            }
                     90:            seq++;
                     91:        }
                     92:     }
                     93:     return event;
                     94: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.