← Back to branch summary

~ubuntu-branches/ubuntu/precise/xterm/precise-updates

« back to all changes in this revision

Viewing changes to input.c

  • Committer: Bazaar Package Importer
  • Date: 2009-01-04 23:24:52 UTC
  • mfrom: (1.1.11 upstream) (11.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20090104232452-nfe6pqpu99ythwv6
Tags: 238-1ubuntu1
Import packaging changes for version 238-1ubuntu1

Show diffs side-by-side

added added

removed removed

Lines of Context:
input.c
1
 
/* $XTermId: input.c,v 1.300 2008/09/14 16:37:25 Ted.Phelps Exp $ */
 
1
/* $XTermId: input.c,v 1.302 2008/12/30 17:20:39 tom Exp $ */
2
2
 
3
3
/*
4
4
 * Copyright 1999-2007,2008 by Thomas E. Dickey
82
82
 
83
83
#include <data.h>
84
84
#include <fontutils.h>
 
85
#include <xstrings.h>
85
86
#include <xtermcap.h>
86
87
 
87
88
/*
825
826
    kd.is_fkey = False;
826
827
#if OPT_TCAP_QUERY
827
828
    if (screen->tc_query_code >= 0) {
828
 
        kd.keysym = screen->tc_query_code;
 
829
        kd.keysym = (KeySym) screen->tc_query_code;
829
830
        kd.is_fkey = screen->tc_query_fkey;
830
831
        if (kd.keysym != XK_BackSpace) {
831
832
            kd.nbytes = 0;
862
863
                && (keyboard->modify_now.other_keys > 1)
863
864
                && !IsControlInput(&kd)) {
864
865
                kd.nbytes = 1;
865
 
                kd.strbuf[0] = kd.keysym;
 
866
                kd.strbuf[0] = (char) kd.keysym;
866
867
            }
867
868
#endif /* OPT_MOD_FKEYS */
868
869
        } else
983
984
#ifdef XK_KP_Home
984
985
        if (kd.keysym >= XK_KP_Home && kd.keysym <= XK_KP_Begin) {
985
986
            TRACE(("...Input keypad before was " KEYSYM_FMT "\n", kd.keysym));
986
 
            kd.keysym += XK_Home - XK_KP_Home;
 
987
            kd.keysym += (unsigned) (XK_Home - XK_KP_Home);
987
988
            TRACE(("...Input keypad changed to " KEYSYM_FMT "\n", kd.keysym));
988
989
        }
989
990
#endif
1028
1029
 
1029
1030
            TRACE(("...map XK_F%ld", kd.keysym - XK_Fn(1) + 1));
1030
1031
            if (evt_state & ControlMask) {
1031
 
                kd.keysym += xw->misc.ctrl_fkeys;
 
1032
                kd.keysym += (KeySym) xw->misc.ctrl_fkeys;
1032
1033
                evt_state &= ~ControlMask;
1033
1034
            }
1034
1035
            TRACE((" to XK_F%ld\n", kd.keysym - XK_Fn(1) + 1));
1039
1040
 
1040
1041
            TRACE(("...map XK_F%ld", kd.keysym - XK_Fn(1) + 1));
1041
1042
            if (evt_state & ShiftMask) {
1042
 
                kd.keysym += xw->misc.ctrl_fkeys * 1;
 
1043
                kd.keysym += (KeySym) (xw->misc.ctrl_fkeys * 1);
1043
1044
                evt_state &= ~ShiftMask;
1044
1045
            }
1045
1046
            if (evt_state & ControlMask) {
1046
 
                kd.keysym += xw->misc.ctrl_fkeys * 2;
 
1047
                kd.keysym += (KeySym) (xw->misc.ctrl_fkeys * 2);
1047
1048
                evt_state &= ~ControlMask;
1048
1049
            }
1049
1050
            TRACE((" to XK_F%ld\n", kd.keysym - XK_Fn(1) + 1));
1124
1125
                 && (dec_code >= 11 && dec_code <= 14)) {
1125
1126
            reply.a_type = ANSI_SS3;
1126
1127
            VT52_CURSOR_KEYS;
1127
 
            reply.a_final = A2E(dec_code - 11 + E2A('P'));
 
1128
            reply.a_final = (Char) A2E(dec_code - 11 + E2A('P'));
1128
1129
            modifyCursorKey(&reply,
1129
1130
                            keyboard->modify_now.function_keys,
1130
1131
                            &modify_parm);
1167
1168
        key = True;
1168
1169
    } else if (IsPFKey(kd.keysym)) {
1169
1170
        reply.a_type = ANSI_SS3;
1170
 
        reply.a_final = kd.keysym - XK_KP_F1 + 'P';
 
1171
        reply.a_final = (Char) ((kd.keysym - XK_KP_F1) + 'P');
1171
1172
        VT52_CURSOR_KEYS;
1172
1173
        MODIFIER_PARM;
1173
1174
        unparseseq(xw, &reply);
1175
1176
    } else if (IsKeypadKey(kd.keysym)) {
1176
1177
        if (keypad_mode) {
1177
1178
            reply.a_type = ANSI_SS3;
1178
 
            reply.a_final = kypd_apl[kd.keysym - XK_KP_Space];
 
1179
            reply.a_final = (Char) (kypd_apl[kd.keysym - XK_KP_Space]);
1179
1180
            VT52_KEYPAD;
1180
1181
            MODIFIER_PARM;
1181
1182
            unparseseq(xw, &reply);
1190
1191
            reply.a_type = ANSI_CSI;
1191
1192
        }
1192
1193
        modifyCursorKey(&reply, keyboard->modify_now.cursor_keys, &modify_parm);
1193
 
        reply.a_final = curfinal[kd.keysym - XK_Home];
 
1194
        reply.a_final = (Char) (curfinal[kd.keysym - XK_Home]);
1194
1195
        VT52_CURSOR_KEYS;
1195
1196
        MODIFIER_PARM;
1196
1197
        unparseseq(xw, &reply);
1286
1287
            if (eightbit && (kd.nbytes == 1) && screen->input_eight_bits) {
1287
1288
                IChar ch = CharOf(kd.strbuf[0]);
1288
1289
                if (ch < 128) {
1289
 
                    kd.strbuf[0] |= 0x80;
 
1290
                    kd.strbuf[0] |= (char) 0x80;
1290
1291
                    TRACE(("...input shift from %d to %d (%#x to %#x)\n",
1291
1292
                           ch, CharOf(kd.strbuf[0]),
1292
1293
                           ch, CharOf(kd.strbuf[0])));
1299
1300
                         */
1300
1301
                        ch = CharOf(kd.strbuf[0]);
1301
1302
                        kd.nbytes = 2;
1302
 
                        kd.strbuf[0] = 0xc0 | ((ch >> 6) & 0x3);
1303
 
                        kd.strbuf[1] = 0x80 | (ch & 0x3f);
 
1303
                        kd.strbuf[0] = (char) (0xc0 | ((ch >> 6) & 0x3));
 
1304
                        kd.strbuf[1] = (char) (0x80 | (ch & 0x3f));
1304
1305
                        TRACE(("...encoded %#x in UTF-8 as %#x,%#x\n",
1305
1306
                               ch, CharOf(kd.strbuf[0]), CharOf(kd.strbuf[1])));
1306
1307
                    }
1314
1315
            {
1315
1316
                /* VT220 & up: National Replacement Characters */
1316
1317
                if ((xw->flags & NATIONAL) != 0) {
1317
 
                    int cmp = xtermCharSetIn(CharOf(kd.strbuf[0]),
1318
 
                                             screen->keyboard_dialect[0]);
 
1318
                    unsigned cmp = xtermCharSetIn(CharOf(kd.strbuf[0]),
 
1319
                                                  screen->keyboard_dialect[0]);
1319
1320
                    TRACE(("...input NRC %d, %s %d\n",
1320
1321
                           CharOf(kd.strbuf[0]),
1321
1322
                           (CharOf(kd.strbuf[0]) == cmp)
1322
1323
                           ? "unchanged"
1323
1324
                           : "changed to",
1324
1325
                           CharOf(cmp)));
1325
 
                    kd.strbuf[0] = cmp;
 
1326
                    kd.strbuf[0] = (char) cmp;
1326
1327
                } else if (eightbit) {
1327
1328
                    prefix = ANSI_ESC;
1328
1329
                } else if (kd.strbuf[0] == '?'
1399
1400
            /* after F20 the codes are made up and do not correspond to any
1400
1401
             * real terminal.  So they are simply numbered sequentially.
1401
1402
             */
1402
 
            result = 42 + (kd->keysym - XK_Fn(21));
 
1403
            result = 42 + (int) (kd->keysym - XK_Fn(21));
1403
1404
            break;
1404
1405
        }
1405
1406
    } else {
1479
1480
    }
1480
1481
    if (result > 0) {
1481
1482
        reply->a_type = ANSI_ESC;
1482
 
        reply->a_final = result;
 
1483
        reply->a_final = (Char) result;
1483
1484
    }
1484
1485
#else
1485
1486
    (void) reply;
1569
1570
    }
1570
1571
    if (result > 0) {
1571
1572
        reply->a_type = ANSI_CSI;
1572
 
        reply->a_final = result;
 
1573
        reply->a_final = (Char) result;
1573
1574
    }
1574
1575
#else
1575
1576
    (void) reply;
1666
1667
        reply->a_final = 'z';
1667
1668
    } else if (IsCursorKey(kd->keysym)) {
1668
1669
        reply->a_type = ANSI_SS3;
1669
 
        reply->a_final = curfinal[kd->keysym - XK_Home];
 
1670
        reply->a_final = (Char) curfinal[kd->keysym - XK_Home];
1670
1671
    }
1671
1672
#else
1672
1673
    (void) reply;
1678
1679
#define isName(c) ((c) == '_' || isalnum(CharOf(c)))
1679
1680
 
1680
1681
/*
1681
 
 * Strip unneeded whitespace from a translations resource, lowercasing and
 
1682
 * Strip unneeded whitespace from a translations resource, mono-casing and
1682
1683
 * returning a malloc'd copy of the result.
1683
1684
 */
1684
1685
static char *
1700
1701
                ch = *s++;
1701
1702
                if (ch == '\n') {
1702
1703
                    if (d != dst)
1703
 
                        *d++ = ch;
 
1704
                        *d++ = (char) ch;
1704
1705
                    state = 0;
1705
1706
                } else if (strchr(":!#", ch) != 0) {
1706
1707
                    while (d != dst && isspace(CharOf(d[-1])))
1714
1715
                        while (d != dst && isspace(CharOf(d[-1])))
1715
1716
                            --d;
1716
1717
                    }
1717
 
                    *d++ = char2lower(ch);
 
1718
                    *d++ = x_toupper(ch);
1718
1719
                    ++state;
1719
1720
                }
1720
1721
                prv = ch;