1866 int scr_Getch(void)

  1897 static void add_keyseq(char *seqstr, guint mkeycode, gint value)

  1867 {

  1898 {

  1868   return wgetch(inputWnd);

  1899   keyseq *ks;

  1900 

  1901   // Let's make sure the length is correct

  1902   if (strlen(seqstr) > MAX_KEYSEQ_LENGTH) {

  1903     scr_LogPrint(LPRINT_LOGNORM, "add_keyseq(): key sequence is too long!");

  1904     return;

  1905   }

  1906 

  1907   ks = g_new0(keyseq, 1);

  1908   ks->seqstr = g_strdup(seqstr);

  1909   ks->mkeycode = mkeycode;

  1910   ks->value = value;

  1911   keyseqlist = g_slist_append(keyseqlist, ks);

  1912 }

  1913 

  1914 //  match_keyseq(iseq, &ret)

  1915 // Check if "iseq" is a known key escape sequence.

  1916 // Return value:

  1917 // -1  if "seq" matches no known sequence

  1918 //  0  if "seq" could match 1 or more known sequences

  1919 // >0  if "seq" matches a key sequence; the mkey code is returned

  1920 //     and *ret is set to the matching keyseq structure.

  1921 static inline guint match_keyseq(int *iseq, keyseq **ret)

  1922 {

  1923   GSList *ksl;

  1924   keyseq *ksp;

  1925   char *p, c;

  1926   int *i;

  1927   int needmore = FALSE;

  1928 

  1929   for (ksl = keyseqlist; ksl; ksl = g_slist_next(ksl)) {

  1930     ksp = ksl->data;

  1931     p = ksp->seqstr;

  1932     i = iseq;

  1933     while (1) {

  1934       c = (unsigned char)*i;

  1935       if (!*p && !c) { // Match

  1936         (*ret) = ksp;

  1937         return ksp->mkeycode;

  1938       }

  1939       if (!c) {

  1940         // iseq is too short

  1941         needmore = TRUE;

  1942         break;

  1943       } else if (!*p || c != *p) {

  1944         // This isn't a match

  1945         break;

  1946       }

  1947       p++; i++;

  1948     }

  1949   }

  1950 

  1951   if (needmore)

  1952     return 0;

  1953   return -1;

  1954 }

  1955 

  1956 void scr_Getch(keycode *kcode)

  1957 {

  1958   keyseq *mks;

  1959   int  ks[MAX_KEYSEQ_LENGTH+1];

  1960   int i;

  1961 

  1962   memset(kcode, 0, sizeof(keycode));

  1963   memset(ks,  0, sizeof(ks));

  1964 

  1965   kcode->value = wgetch(inputWnd);

  1966   if (kcode->value != 27)

  1967     return;

  1968 

  1969   // Check for escape key sequence

  1970   for (i=0; i < MAX_KEYSEQ_LENGTH; i++) {

  1971     int match;

  1972     ks[i] = wgetch(inputWnd);

  1973     if (ks[i] == ERR) break;

  1974     match = match_keyseq(ks, &mks);

  1975     if (match == -1) {

  1976       // No such key sequence.  Let's increment i as it is a valid key.

  1977       i++;

  1978       break;

  1979     }

  1980     if (match > 0) {

  1981       // We have a matching sequence

  1982       kcode->mcode = mks->mkeycode;

  1983       kcode->value = mks->value;

  1984       return;

  1985     }

  1986   }

  1987 

  1988   // No match.  Let's return a meta-key.

  1989   if (i > 0) {

  1990     kcode->mcode = MKEY_META;

  1991     kcode->value = ks[0];

  1992   }

  1993   if (i > 1) {

  1994     // We need to push some keys back to the keyboard buffer

  1995     while (i-- > 1)

  1996       ungetch(ks[i]);

  1997   }

  1998   return;

  1873 int process_key(int key)

  2003 int process_key(keycode kcode)

  1874 {

  2004 {

  1875   if (key == 27) {

  2005   int key = kcode.value;

  1876     key = scr_Getch();

  2006 

  1877     if (key == -1 || key == 27) {

  2007   switch (kcode.mcode) {

  1878       // This is a "real" escape...

  2008     case 0:

  1879       scr_CheckAutoAway(TRUE);

  2009         break;

  1880       currentWindow = NULL;

  2010     case MKEY_EQUIV:

  1881       chatmode = FALSE;

  2011         key = kcode.value;

  1882       if (current_buddy)

  2012         break;

  1883         buddy_setflags(BUDDATA(current_buddy), ROSTER_FLAG_LOCK, FALSE);

  2013     case MKEY_META:

  1884       scr_RosterVisibility(1);

  2014         key = ERR;

  1885       scr_UpdateChatStatus(FALSE);

  2015         switch (kcode.value) {

  1886       top_panel(chatPanel);

  2016           case 27:

  1887       top_panel(inputPanel);

  2017               key = 27;

  1888       update_panels();

  2018               break;

  1889     } else { // Meta

  2019           default:

  1890       switch (key) {

  2020               scr_LogPrint(LPRINT_NORMAL, "Unknown key=M%d", kcode.value);

  1891         default:

  2021         }

  1892             scr_LogPrint(LPRINT_NORMAL, "Unknown key=M%d", key);

  2022         break;

  1893       }

  2023     default:

  1894     }

  2024         scr_LogPrint(LPRINT_NORMAL, "Unknown mkeycode! (%d)", kcode.mcode);

  1895     key = -1;

  2025         key = ERR;

  1896   }

  2026   }

  2027 

  1898     case -1:

  2029     case 0:

  2030     case ERR: